packages feed

Haschoo (empty) → 0.0

raw patch · 51 files changed

+35457/−0 lines, 51 filesdep +arraydep +basedep +list-triessetup-changed

Dependencies added: array, base, list-tries, monad-loops, mtl, numbers, parsec

Files

+ Haschoo.cabal view
@@ -0,0 +1,58 @@+Cabal-Version: >= 1.6++Name:        Haschoo+Version:     0.0+Homepage:    http://iki.fi/matti.niemenmaa/misc-projects.html#haschoo+Synopsis:    Minimalist R5RS Scheme interpreter+Category:    Compilers/Interpreters+Description:+   Haschoo is a minimalist R5RS interpreter written in Haskell for a university+   course.++Author:       Matti Niemenmaa+Maintainer:   Matti Niemenmaa <matti.niemenmaa+haschoo@iki.fi>+License:      BSD3+License-File: LICENSE.txt++Build-Type: Simple++Extra-Source-Files: README.txt+                    tests/*.scm+                    tests/macros/*.scm+                    tests/macros/r5rs/4.3.1.scm+                    tests/macros/r5rs/4.3.2.scm+                    tests/macros/xfail/*.scm++Executable haschoo+   Main-Is: Haschoo/Main.hs++   Build-Depends: base        == 4.*+                , array       == 0.2.*+                , mtl         == 1.1.*+                , list-tries  == 0.1.*+                , numbers     >= 2009.5.28 && <= 2009.8.9+                , monad-loops == 0.3.*+                , parsec      == 2.1.*++   Other-Modules: Haschoo.Evaluator+                  Haschoo.Evaluator.Eval+                  Haschoo.Evaluator.Macros+                  Haschoo.Evaluator.Primitives+                  Haschoo.Evaluator.Standard+                  Haschoo.Evaluator.Standard.Boolean+                  Haschoo.Evaluator.Standard.Characters+                  Haschoo.Evaluator.Standard.Control+                  Haschoo.Evaluator.Standard.Equivalence+                  Haschoo.Evaluator.Standard.Eval+                  Haschoo.Evaluator.Standard.IO+                  Haschoo.Evaluator.Standard.Numeric+                  Haschoo.Evaluator.Standard.PairsLists+                  Haschoo.Evaluator.Standard.Strings+                  Haschoo.Evaluator.Standard.Symbols+                  Haschoo.Evaluator.Standard.Vectors+                  Haschoo.Evaluator.Utils+                  Haschoo.Parser+                  Haschoo.Running+                  Haschoo.Stdlib+                  Haschoo.Types+                  Haschoo.Utils
+ Haschoo/Evaluator.hs view
@@ -0,0 +1,59 @@+-- File created: 2009-07-14 14:37:46++module Haschoo.Evaluator (evalToplevel) where++import Control.Monad.Error (throwError)+import Control.Monad.State (get)+import Data.IORef          (IORef)++import Haschoo.Types            ( Haschoo, runHaschoo+                                , ScmValue( ScmList, ScmIdentifier, ScmSyntax+                                          , ScmVoid)+                                , Context)+import Haschoo.Utils            (ErrOr)+import Haschoo.Evaluator.Eval   (eval, evalBody, define)+import Haschoo.Evaluator.Macros (mkMacro)+import Haschoo.Evaluator.Utils  (tooFewArgs, tooManyArgs)++-- Programs consist of three things:+--    expressions        - valid anywhere+--    definitions        - valid at toplevel or at the beginning of a <body>+--    syntax definitions - valid at toplevel+--+-- Where <body> is a body of one of:+--    lambda, let, let*, letrec, let-syntax, letrec-syntax,+--    or procedure definition+--+-- Hence we need three eval functions (the following, evalBody, and eval) and+-- hence definitions are handled separately in the former two instead of being+-- ordinary primitives.+--+-- "begin" needs special treatment as well, since it depends on the evaluation+-- level (R5RS 5.1, 5.2.2). We special-case it here and in evalBody, leaving+-- ordinary expression usage to the definition given in R5RS 7.3.++evalToplevel :: [IORef Context] -> ScmValue -> IO (ErrOr ScmValue)+evalToplevel ctx = runHaschoo ctx . f+ where+   f (ScmList (ScmIdentifier i : xs))+      | i == "define-syntax" = do+         scmDefineSyntax xs+         return ScmVoid++      | i == "begin" = fmap last $ mapM f xs++   f d = evalBody [d]++scmDefineSyntax :: [ScmValue] -> Haschoo ()+scmDefineSyntax [ScmIdentifier var, x] = do+   x' <- eval x+   case x' of+        ScmSyntax pats lits -> do+           ctx <- get+           define var (mkMacro ctx var pats lits)++        _ -> throwError "define-syntax :: expected instance of syntax-rules"++scmDefineSyntax [_,_]   = throwError  "define-syntax :: expected identifier"+scmDefineSyntax (_:_:_) = tooManyArgs "define-syntax"+scmDefineSyntax _       = tooFewArgs  "define-syntax"
+ Haschoo/Evaluator/Eval.hs view
@@ -0,0 +1,105 @@+-- File created: 2009-07-26 16:26:13++module Haschoo.Evaluator.Eval (eval, maybeEval, evalBody, define) where++import Control.Monad       (msum)+import Control.Monad.Error (throwError, catchError)+import Control.Monad.State (get)+import Control.Monad.Trans (liftIO)+import Data.IORef          (IORef, readIORef, modifyIORef)++import qualified Data.ListTrie.Patricia.Map.Enum as TM+import           Data.ListTrie.Patricia.Map.Enum (TrieMap)++import Haschoo.Types           ( Haschoo+                               , ScmValue( ScmPrim, ScmFunc, ScmMacro+                                         , ScmList, ScmDottedList+                                         , ScmVoid, ScmIdentifier)+                               , MacroCall(..)+                               , Context, addToContext, contextLookup)+import Haschoo.Utils           (lazyMapM, modifyM)+import Haschoo.Evaluator.Utils (tooFewArgs)++eval :: ScmValue -> Haschoo ScmValue+eval = evalWithSpecialCases TM.empty++evalWithSpecialCases :: TrieMap Char [IORef Context]+                     -> ScmValue -> Haschoo ScmValue+evalWithSpecialCases specials (ScmIdentifier s) =+   case TM.lookup s specials of+        Just specialCtx -> lookupId specialCtx+        Nothing         -> lookupId =<< get+ where+   lookupId ctx = do+      lookups <- lazyMapM (fmap (contextLookup s) . readIORef) ctx+      case msum lookups of+           Nothing -> throwError $ "Unbound identifier '" ++ s ++ "'"+           Just v  -> return v++evalWithSpecialCases _  (ScmList [])     = throwError "Empty application"+evalWithSpecialCases sp (ScmList (x:xs)) = do+   evaledHead <- evalWithSpecialCases sp x+   case evaledHead of+        ScmPrim _ f -> f xs+        ScmFunc _ f -> do+           args   <- mapM (evalWithSpecialCases sp) xs+           result <- liftIO $ f args+           case result of+                Left  s   -> throwError s+                Right val -> return val++        m@(ScmMacro _ _) -> evalMacro sp m (MCList xs)++        _ -> throwError "Can't apply non-function"++evalWithSpecialCases sp (ScmDottedList (x:xs) y) = do+   evaledHead <- evalWithSpecialCases sp x+   case evaledHead of+        m@(ScmMacro _ _) -> evalMacro sp m (MCDotted xs y)++        _ -> throwError "Ill-formed procedure application: no dots allowed"++evalWithSpecialCases _ v = return v++evalMacro :: TrieMap Char [IORef Context]+          -> ScmValue -> MacroCall -> Haschoo ScmValue+evalMacro sp (ScmMacro _ f) xs = do+   (expansion, frees) <- f xs+   evalWithSpecialCases (TM.union frees sp) expansion++evalMacro _ _ _ = error "evalMacro :: the impossible happened: not a macro"++maybeEval :: ScmValue -> Haschoo (Maybe ScmValue)+maybeEval = (`catchError` const (return Nothing)) . fmap Just . eval++evalBody :: [ScmValue] -> Haschoo ScmValue+evalBody (ScmList (ScmIdentifier i : xs) : ds)+   | i == "define" = scmDefine xs >> evalBody ds+   | i == "begin"  = evalBody (xs ++ ds)++evalBody ds@(_:_) = fmap last . mapM eval $ ds+evalBody []       = return ScmVoid++define :: String -> ScmValue -> Haschoo ()+define var body = eval body >>= modifyM . f+ where+   f e (c:cs) = do+      liftIO $ modifyIORef c (addToContext var e)+      return (c:cs)+   f _ []     = error "define :: the impossible happened: empty context stack"++scmDefine :: [ScmValue] -> Haschoo ()+scmDefine [ScmIdentifier var, expr] = define var expr++scmDefine (ScmList (ScmIdentifier func : params) : body) =+   define func . ScmList $ ScmIdentifier "lambda" : ScmList params : body++scmDefine (ScmDottedList (ScmIdentifier func : params) final : body) =+   define func . ScmList $ ScmIdentifier "lambda"+                           : (if null params+                                 then final+                                 else ScmDottedList params final)+                           : body++scmDefine (_:_:_) = throwError "define :: expected identifier"+scmDefine _       = tooFewArgs "define"
+ Haschoo/Evaluator/Macros.hs view
@@ -0,0 +1,275 @@+-- File created: 2009-07-26 16:12:14++{-# LANGUAGE PatternGuards #-}++module Haschoo.Evaluator.Macros (mkMacro) where++import Control.Applicative         ((<$>))+import Control.Arrow               (first)+import Control.Monad               (liftM2, when)+import Control.Monad.Error         (throwError)+import Control.Monad.Loops         (andM, allM, firstM, untilM)+import Control.Monad.State.Strict  (State, runState, put, get, modify)+import Control.Monad.Trans         (MonadIO, lift, liftIO)+import Control.Monad.Writer.Strict (WriterT, runWriterT, tell)+import Data.Array.IArray           (elems)+import Data.IORef                  (IORef)+import Data.List                   (find)+import Data.Maybe                  (catMaybes, isNothing)+import Data.Monoid                 (Monoid(mempty, mappend))++import qualified Data.ListTrie.Patricia.Map.Enum as TM+import Data.ListTrie.Patricia.Map.Enum (TrieMap)++import Haschoo.Types                          ( Haschoo+                                              , ScmValue+                                                   ( ScmMacro, ScmIdentifier+                                                   , ScmList, ScmDottedList+                                                   , ScmVector)+                                              , MacroCall(..)+                                              , Context+                                              , isAggregate, toScmVector)+import Haschoo.Utils                          ( fst3, initLast2Maybe+                                              , ptrEq, eqWithM, ErrOr)+import Haschoo.Evaluator.Eval                 (maybeEval)+import Haschoo.Evaluator.Standard.Equivalence (scmEqual)++-- The Left case is for ellipses+newtype PatternMatches = PM (TrieMap Char (Either [ScmValue] ScmValue))++-- Right-biased union instead of the default left-biased: so we can overwrite+-- keys in a Writer with a second call to tell+instance Monoid PatternMatches where+   mempty                = PM mempty+   mappend (PM a) (PM b) = PM (TM.union b a)++type Lits = [(String, Maybe ScmValue)]++mkMacro :: [IORef Context] -> String -> [(ScmValue, ScmValue, [String])]+        -> Lits -> ScmValue+mkMacro ctx name pats ls = ScmMacro name f+ where+   f args = do+      (matching,replacements) <-+         runWriterT $ firstM (match ls args . fst3) pats++      case matching of+           Nothing          -> throwError ("Invalid use of macro " ++ name)+           Just (_,v,frees) ->+              case replaceVars (map fst ls) frees replacements v of+                   Left s -> throwError s+                   Right replaced ->+                      return ( simplifyList replaced+                             , TM.fromList (zip frees (repeat ctx)))++-- Turning MCDotted to ScmDottedList here means that the list in the+-- ScmDottedList may actually be empty, which can't happen normally+match :: Lits -> MacroCall -> ScmValue -> WriterT PatternMatches Haschoo Bool+match lits (MCList   xs)   = match1 lits (ScmList xs)+match lits (MCDotted xs x) = match1 lits (ScmDottedList xs x)++-- Paraphrasing R5RS 4.3.2:+--+-- "... formally, an input form F matches a pattern P iff:" ...+match1 :: Lits -> ScmValue -> ScmValue -> WriterT PatternMatches Haschoo Bool+match1 lits arg (ScmIdentifier i) =+   case find ((== i).fst) lits of+        -- ... "P is a non-literal identifier" ...+        Nothing           -> do tell (PM $ TM.singleton i (Right arg))+                                return True+        Just (_, binding) ->+           case arg of+                -- ... "P is a literal identifier and F is an identifier with+                -- the same binding, or the two identifiers are equal and both+                -- have no lexical binding" ...+                x@(ScmIdentifier i2) -> do+                   xb <- lift $ maybeEval x+                   case binding of+                        Nothing -> return (isNothing xb && i == i2)+                        Just pb -> maybe (return False) (liftIO . ptrEq pb) xb++                _  -> return False++match1 lits (ScmList args) (ScmList ps) =+   case initLast2Maybe ps of+        -- ... "P is of the form (P1 ... Pn Pm <ellipsis>) where <ellipsis> is+        -- the identifier ... and F is a list of at least n forms, the first n+        -- of which match P1 through Pn and each remaining element matches Pm"+        -- ...+        Just (ps', p, ScmIdentifier "...") ->+           let (xs, ys) = splitAt (length ps') args+            in do m <- andM [ allMatch lits xs ps'+                            , allM (flip (match1 lits) p) ys]+                  when m (assignMatches ys p)+                  return m++        -- ... "P is a list (P1 ... Pn) and F is a list of n forms that match+        -- P1 through Pn" ...+        _ -> allMatch lits args ps++ where+   assignMatches ys (ScmIdentifier i) = tell (PM $ TM.singleton i (Left ys))++   -- E.g. pl = (x y z) and ys = [(1 2 3),(4 5 6)]+   --+   -- Bind x to [1,4], y to [2,5], z to [3,6]+   assignMatches ys p =+      case p of+           ScmList       _   -> assignList (\(ScmList       l)   -> l)+           ScmVector     _   -> assignList (\(ScmVector     v)   -> elems v)+           ScmDottedList _ _ -> assignList (\(ScmDottedList l x) -> x:l)+           _                 -> return ()++    where+      assignList toList =+         let -- Continuing the above example, this would give+             -- [(x,1),(x,4),(y,2),(y,5),(z,3),(z,6)]+             lpat    = toList p+             paired  = concatMap (zip lpat . toList) ys++             -- From then on it's quite trivial.+             --+             -- Just be sure to add an initial empty match for each identifier.+             -- This ensures that patterns such as ((x) ...), when matched+             -- against (), result in any x in the output being replaced with+             -- nothing, instead of them not being seen as matches.+             matched = [(i, [])  | ScmIdentifier i <- lpat]+                    ++ [(i, [x]) | (ScmIdentifier i, x) <- paired]++          in tell . PM . TM.map Left $ TM.fromListWith (flip (++)) matched++-- ... "P is an improper list (P1 ... Pn . Pm)" ...+match1 lits args (ScmDottedList ps p) =+   case args of+        -- ... "and F is a list or improper list of n or more forms that match+        -- P1 through Pn and whose nth cdr matches Pm" ...+        ScmList as -> let (xs, ys) = splitAt (length ps) as+                       in andM [ allMatch lits xs ps+                               , match1 lits (ScmList ys) p]++        ScmDottedList as a -> andM [allMatch lits as ps, match1 lits a p]+        _                  -> return False++-- ... "P is a vector of the form #(P1 ... Pn) and F is a vector of n forms+-- that match P1 through Pn" ...+--+-- ... "P is of the form #(P1 ... Pn Pm <ellipsis>) where <ellipsis> is the+-- identifier ... and F is a vector of n or more forms, the first n of which+-- match P1 through Pn and each remaining element matches Pm" ...+--+-- Just forward to the list one, the rules are identical+match1 lits (ScmVector args) (ScmVector ps) =+   match1 lits (ScmList $ elems args) (ScmList $ elems ps)++-- ... "P is a datum and F is equal to P in the sense of the equal? procedure".+match1 _ arg p = liftIO $ scmEqual arg p++allMatch :: Lits -> [ScmValue] -> [ScmValue]+         -> WriterT PatternMatches Haschoo Bool+allMatch = eqWithM . match1++replaceVars :: [String] -> [String] -> PatternMatches+            -> ScmValue -> ErrOr [ScmValue]+replaceVars _ _ (PM replacements) (ScmIdentifier i)+   | Just r <- TM.lookup i replacements = case r of+                                               Right r' -> return [r']+                                               Left  rs -> return rs+   | i == "..." = return []++replaceVars lits frees rs (ScmList   l) =+   (:[]) . ScmList     <$> replaceInAggregate lits frees rs l+replaceVars lits frees rs (ScmVector v) =+   (:[]) . toScmVector <$> replaceInAggregate lits frees rs (elems v)++replaceVars lits frees rs (ScmDottedList l x) =+   (:[]) <$> liftM2 ScmDottedList+                    (replaceInAggregate lits frees rs l)+                    (simplifyList <$> replaceVars lits frees rs x)++replaceVars _ _ _ v = return [v]++replaceInAggregate :: [String] -> [String] -> PatternMatches+                   -> [ScmValue] -> ErrOr [ScmValue]+replaceInAggregate lits frees rs (ag : ScmIdentifier "..." : vs)+   | isAggregate ag =+      liftM2 (++) (replaceInEllipticAggregate lits frees rs ag)+                  (replaceInAggregate lits frees rs vs)++replaceInAggregate lits frees rs (v:vs) =+   liftM2 (++) (replaceVars lits frees rs v)+               (replaceInAggregate lits frees rs vs)++replaceInAggregate _ _ _ [] = return []++-- "Pattern variables that occur in subpatterns followed by one or more+-- instances of the identifier ... are allowed only in subtemplates that are+-- followed by as many instances of ....+--+-- They [the subtemplates] are replaced in the output by all of the subforms+-- they [the subpatterns] match in the input, distributed as indicated [in the+-- template, by the positions of the pattern variables]."+--+-- With square-bracketed stuff added to make some sense of the last sentence+-- there.+--+-- E.g. pattern (_ (#(a b) ...)) and corresponding template ((a b) ...).+--+-- Pattern variables a and b are in a subpattern followed by one ellipsis. We+-- also have a subtemplate followed by as many ellipses, and a and b are found+-- nowhere else, so it's valid. Calling this with (_ (#(1 2) #(3 4))) we get+-- the subtemplate '(a b) ...' replaced by '(1 2) (3 4)'.+replaceInEllipticAggregate :: [String] -> [String] -> PatternMatches+                           -> ScmValue -> ErrOr [ScmValue]+replaceInEllipticAggregate lits frees pms val =+   let (replaced, (replacementsLeft,_)) =+          flip runState (TM.empty, pms) $+             (go val `untilM`+                do rsLeft <- fst <$> get+                   return (TM.null rsLeft || anyT (==0) rsLeft))++    in if allT (==0) replacementsLeft+          then return$ catMaybes replaced+          else -- For example:+               --   Pattern has (a ...) (b ...)+               --   Template has ((a b) ...)+               --   (a ...) was (1 2) and (b ...) was (3)+               --   The first (1 3) is fine, but the next (2 ??) isn't+               throwError "Inconsistent match counts for elliptic variables"+ where+   go :: ScmValue -> State (TrieMap Char Int, PatternMatches) (Maybe ScmValue)+   go (ScmIdentifier i)+      | i `elem` frees || i `elem` lits = return Nothing+      | otherwise = do+         (replacementsLeft, PM pm) <- get+         let (v, pm') =+                TM.updateLookup (Just . either (Left . drop 1) Right) i pm+         case v of+              Just (Right r')    -> return (Just r')+              Just (Left [])     -> do modify (first $ TM.insert i 0)+                                       return Nothing+              Just (Left (r:rs)) -> do+                 let rsLeft' =+                        TM.alter' (Just . maybe (length rs) (subtract 1))+                                  i replacementsLeft+                 put (rsLeft', PM pm')+                 return (Just r)++              -- Blank match: e.g. pattern (a ...) matched ()+              Nothing -> return Nothing++   go (ScmList   l) = fmap ScmList     . sequence <$> mapM go l+   go (ScmVector v) = fmap toScmVector . sequence <$> mapM go (elems v)++   go (ScmDottedList l x) = do+      l' <- sequence <$> mapM go l+      x' <- go x+      return (liftM2 ScmDottedList l' x')++   go x = return (Just x)++   anyT f = TM.foldr ((||).f) False+   allT f = TM.foldr ((&&).f) True++simplifyList :: [ScmValue] -> ScmValue+simplifyList [v] = v+simplifyList vs  = ScmList vs
+ Haschoo/Evaluator/Primitives.hs view
@@ -0,0 +1,534 @@+-- File created: 2009-07-19 18:34:38++{-# LANGUAGE PatternGuards #-}+module Haschoo.Evaluator.Primitives (context) where++import Control.Applicative ((<$>))+import Control.Arrow       (first, (&&&))+import Control.Monad       (when)+import Control.Monad.Error (throwError)+import Control.Monad.State (get)+import Control.Monad.Trans (liftIO)+import Data.Array.IArray   (listArray, elems, bounds)+import Data.IORef          ( IORef, readIORef+                           , newIORef, modifyIORef, writeIORef)+import Data.Maybe          (isJust, catMaybes)+import Numeric             (showHex)++import qualified Control.Monad.State.Strict      as S+import qualified Data.ListTrie.Patricia.Set.Enum as TS++import Haschoo.Types            ( Haschoo, runHaschoo, withHaschoo+                                , ScmValue(..), isTrue+                                , Context, mkContext, contextSize+                                , addToContext, contextLookup+                                , listToPair)+import Haschoo.Utils            ( compareLength, compareLengths, (.:)+                                , fromRights, modifyM)+import Haschoo.Evaluator.Eval   (eval, evalBody, maybeEval)+import Haschoo.Evaluator.Macros (mkMacro)+import Haschoo.Evaluator.Utils  (tooFewArgs, tooManyArgs)++import Haschoo.Evaluator.Standard.PairsLists (scmAppend)++context :: Context+context = mkContext primitives++primitives :: [(String, ScmValue)]+primitives = map (\(a,b) -> (a, ScmPrim a b)) $+   [ ("lambda",        scmLambda)+   , ("quote",         scmQuote)+   , ("if",            scmIf)+   , ("set!",          scmSet)+   , ("letrec",        scmLetRec)+   , ("syntax-rules",  scmSyntaxRules)+   , ("let-syntax",    scmLetSyntax)+   , ("letrec-syntax", scmLetRecSyntax)+   , ("quasiquote",    scmQuasiQuote)+   , ("do",            scmDo) ]++scmLambda :: [ScmValue] -> Haschoo ScmValue+scmLambda []                                          = tooFewArgs "lambda"+scmLambda [_]                                         = tooFewArgs "lambda"+scmLambda (ScmList       ps                   : body) = mkΛ ps  Nothing body+scmLambda (                  ScmIdentifier t  : body) = mkΛ [] (Just t) body+scmLambda (ScmDottedList ps (ScmIdentifier t) : body) = mkΛ ps (Just t) body++scmLambda _ = throwError "Invalid parameters to lambda"++mkΛ :: [ScmValue] -> Maybe String -> [ScmValue] -> Haschoo ScmValue+mkΛ formals tailParams body = ScmFunc name . func <$> get+ where+   func ctx = \args -> do+      case compareLengths args formals of+           (LT,_)      -> return$ tooFewArgs name+           (order,len) -> do+              case tailParams of+                   Nothing ->+                      if order == EQ+                         then make id args+                         else return$ tooManyArgs name+                   Just n ->+                      let (normal, tailArgs) = splitAt len args+                       in make (++[n]) (normal ++ [ScmList tailArgs])+    where+      make mkParams args =+         case paramNames of+              Just ns ->+                 let ns' = mkParams ns+                     c   = subContext ns' args+                  in case compareLength ns' (contextSize c) of+                          EQ -> do+                             c' <- newIORef c+                             runHaschoo (c':ctx) $ evalBody body++                          GT -> return duplicateParam+                          LT -> error "lambda :: the impossible happened"++              Nothing -> return badParam++      paramNames = mapM f formals+       where+         f (ScmIdentifier x) = Just x+         f _                 = Nothing++   name = "<lambda>"+   subContext = mkContext .: zip++   duplicateParam =+      throwError.concat $ ["Duplicate in parameter list of ", name]+   badParam      =+      throwError.concat $ ["Invalid identifier in parameter list of ", name]++scmQuote :: [ScmValue] -> Haschoo ScmValue+scmQuote [x] = return x+scmQuote []  = tooFewArgs  "quote"+scmQuote _   = tooManyArgs "quote"++scmIf :: [ScmValue] -> Haschoo ScmValue+scmIf [b,x,y] = eval b >>= \t -> eval $ if isTrue t then x else y+scmIf [b,x]   = eval b >>= \t -> if isTrue t then eval x else return ScmVoid+scmIf (_:_:_) = tooManyArgs "if"+scmIf _       = tooFewArgs "if"++scmSet :: [ScmValue] -> Haschoo ScmValue+scmSet [ScmIdentifier var, expr] = do+   e  <- eval expr+   set var e+   return ScmVoid++scmSet [_,_]   = throwError $ "Non-identifier argument to set!"+scmSet (_:_:_) = tooManyArgs "set!"+scmSet _       = tooFewArgs  "set!"++scmLetRec :: [ScmValue] -> Haschoo ScmValue+scmLetRec (ScmList l : b@(_:_)) = doLetRec l b+scmLetRec (_:_:_) = throwError "Invalid list of bindings to letrec"+scmLetRec _       = tooFewArgs "letrec"++doLetRec :: [ScmValue] -> [ScmValue] -> Haschoo ScmValue+doLetRec bindings body = do+   ctx      <- liftIO $ newIORef (mkContext [])+   newStack <- fmap (ctx:) get+   mapM_ (bind newStack ctx) bindings+   withHaschoo newStack (evalBody body)+ where+   bind ctxStack ctx (ScmList [ScmIdentifier var, val]) = do+      evaled <- withHaschoo ctxStack (eval val)+      liftIO $ modifyIORef ctx (addToContext var evaled)++   bind _  _ _ = throwError "Invalid binding to letrec"++scmSyntaxRules :: [ScmValue] -> Haschoo ScmValue+scmSyntaxRules (ScmList lits : rest) = do+   evaledLits <- mapM unlit lits+   pats       <- mapM unpat rest+   return$ ScmSyntax pats evaledLits+ where+   unpat (ScmList [pattern, template]) = do+      pat <- case pattern of+                  -- It really does seem to me that the keyword in a syntax+                  -- rule is ignored according to R5RS 4.3.2: what names the+                  -- macro is the identifier in define-syntax / let-syntax /+                  -- letrec-syntax, the name in the pattern match is+                  -- irrelevant.+                  ScmList (ScmIdentifier _keyword : pat) ->+                     return (ScmList pat)+                  ScmDottedList (ScmIdentifier _keyword : pat) pat' ->+                     return (ScmDottedList pat pat')++                  ScmVector xs | maxIdx >= 0 ->+                     case elems xs of+                          ScmIdentifier _keyword : pat ->+                             return (ScmVector $ listArray (0, maxIdx-1) pat)++                          _ -> badPattern+                   where+                     maxIdx = snd (bounds xs)++                  _ -> badPattern++      checkPat pat+      let renamedTmp =+             flip S.evalState 0 $ renameBinds (frees template) template++      return (pat, renamedTmp, TS.toList (frees renamedTmp))+    where+      -- R5RS 4.3: "If a macro transformer inserts a binding for an identifier+      -- (variable or keyword), the identifier will in effect be renamed+      -- throughout its scope to avoid conflicts with other identifiers."+      --+      -- This is a HACK!+      --+      -- It's also buggy:+      --   FIXME: top-level defines don't introduce bindings if the variable is+      --          already bound, this doesn't take that into account.+      --+      --   FIXME: nested binding-creators won't work (fixable by calling+      --          renameBinds from renameUses before doing the rename)+      --+      -- Not sure how to deal with this properly... doing the same thing at+      -- macro expansion time would fix the FIXME but it's still really hacky.+      renameBinds :: TS.TrieSet Char -> ScmValue -> S.State Int ScmValue+      renameBinds fs (ScmList (l@(ScmIdentifier lt) : ScmList bs : body))+         | isLetLike lt = do+            (rens, bs') <- first catMaybes . unzip <$> mapM renameInLet bs+            return$ ScmList (l : ScmList bs' : map (renameUses rens) body)+       where+         isLetLike "let"    = True+         isLetLike "let*"   = True+         isLetLike "letrec" = True+         isLetLike "do"     = True -- The syntax is close enough+         isLetLike _        = False++         renameInLet (ScmList (ScmIdentifier i : val))+            | i `TS.member` fs = do+               i' <- renameBinding i+               return (Just (i,i'), ScmList (i' : val))++         renameInLet x = return (Nothing, x)++      renameBinds fs+         (ScmList (l@(ScmIdentifier "lambda") : ScmList bs : body)) = do+            (rens, bs') <- first catMaybes . unzip <$> mapM renameInLambda bs+            return$ ScmList (l : ScmList bs' : map (renameUses rens) body)+       where+         renameInLambda (ScmIdentifier i) | i `TS.member` fs =+            (Just . (,) i &&& id) <$> renameBinding i++         renameInLambda x = return (Nothing, x)++      renameBinds fs+         (ScmList (d@(ScmIdentifier "define") : ScmList (b:bs) : body)) = do+            (rens, bs') <- first catMaybes . unzip <$> mapM renameInDefine bs+            return$ ScmList (d : ScmList (b:bs') : map (renameUses rens) body)+       where+         renameInDefine (ScmIdentifier i) | i `TS.member` fs =+            (Just . (,) i &&& id) <$> renameBinding i++         renameInDefine x = return (Nothing, x)++      renameBinds _ x = return x++      renameUses :: [(String,ScmValue)] -> ScmValue -> ScmValue+      renameUses [] x = x+      renameUses rens (ScmIdentifier i)+         | Just i' <- lookup i rens = i'++      renameUses rens (ScmList  xs) = ScmList   ( map (renameUses rens) xs)+      renameUses rens (ScmVector v) = ScmVector (fmap (renameUses rens) v)+      renameUses rens (ScmDottedList xs x) =+         ScmDottedList (map (renameUses rens) xs) (renameUses rens x)++      renameUses _ x = x++      -- ; is the comment character and thus can't normally be used in+      -- identifier names, so using it here guarantees the user hasn't+      -- otherwise used it+      renameBinding s = do+         n <- S.get+         S.put (n+1)+         return$ ScmIdentifier (';' : showHex n s)++      frees :: ScmValue -> TS.TrieSet Char+      frees (ScmIdentifier i)    = if isLocal i+                                      then TS.empty+                                      else TS.singleton i+      frees (ScmList       xs)   = TS.unions . map frees $ xs+      frees (ScmVector     v)    = TS.unions . map frees $ elems v+      frees (ScmDottedList xs x) = TS.unions . map frees $ (x:xs)+      frees _                    = TS.empty++      isLocal s = go pattern+       where+         go (ScmIdentifier i)    = s == i+         go (ScmList   xs)       = any go xs+         go (ScmVector v)        = any go (elems v)+         go (ScmDottedList xs x) = any go xs || go x+         go _                    = False++      checkPat p = do+         found <- go False p+         when (not found) (assertNoEllipses template)+       where+         go found (ScmList ls) =+            case findEllipsis ls of+                 Just (_, after)+                    | not (all elliptic after) ->+                       srErr+                          "Nonelliptic identifier follows ellipsis in pattern"++                 Just (Nothing, _) ->+                    srErr "Ellipsis not preceded by anything in pattern"++                 Just (Just (ScmIdentifier i), after) -> do+                    checkEllipsisUse i (length after) template+                    or <$> mapM (go True) ls++                 Nothing -> or <$> mapM (go found) ls+                 _       -> or <$> mapM (go True)  ls++         go _ (ScmDottedList _ (ScmIdentifier "...")) =+            srErr "Ellipsis terminating improper list"++         go _ (ScmDottedList ls _) | isJust (findEllipsis ls) =+            srErr "Ellipsis in improper list"++         go found (ScmDottedList ls x) = do+            found' <- or <$> mapM (go found) ls+            go found' x++         go found (ScmVector v) = go found (ScmList $ elems v)++         go found _ = return found++      checkEllipsisUse var n (ScmList ls) =+            case findEllipsis ls of+                 Just (Just (ScmIdentifier i), after) | var == i ->++                    if (length . filter elliptic . take n $ after) == n+                       then mapM_ (checkEllipsisUse var n) ls+                       else srErr $ "Ellipsis use matches pattern variable " +++                                    "but not ellipsis count"++                 _ -> mapM_ (checkEllipsisUse var n) ls++      checkEllipsisUse var n (ScmDottedList ls x) = do+         mapM_ (checkEllipsisUse var n) ls+         checkEllipsisUse var n x++      checkEllipsisUse var n (ScmVector v) =+         checkEllipsisUse var n (ScmList $ elems v)++      checkEllipsisUse _ _ _ = return ()++      assertNoEllipses (ScmList ls) =+         if isJust (findEllipsis ls)+            then srErr "Ellipsis used as identifier in template"+            else mapM_ assertNoEllipses ls++      assertNoEllipses (ScmDottedList ls x) =+         mapM_ assertNoEllipses ls >> assertNoEllipses x++      assertNoEllipses _ = return ()++      findEllipsis []                             = Nothing+      findEllipsis (    ScmIdentifier "..." : xs) = Just (Nothing, xs)+      findEllipsis (x : ScmIdentifier "..." : xs) = Just (Just x,  xs)+      findEllipsis (_:xs)                         = findEllipsis xs++   unpat _ = badPattern++   badPattern = throwError "Invalid pattern in syntax-rules"++   unlit lit@(ScmIdentifier i) =+      if elliptic lit+         then throwError "Elliptic literal to syntax-rules"+         else fmap ((,) i) (maybeEval lit)++   unlit _ = throwError "Nonidentifier literal to syntax-rules"++   elliptic (ScmIdentifier "...") = True+   elliptic _                     = False++   srErr = throwError . (++ " in syntax-rules")++scmSyntaxRules [] = tooFewArgs "syntax-rules"+scmSyntaxRules _  = throwError "Invalid list of literals to syntax-rules"++scmLetSyntax, scmLetRecSyntax :: [ScmValue] -> Haschoo ScmValue+scmLetSyntax    = syntaxLet (flip const) "let-syntax"+scmLetRecSyntax = syntaxLet (:)          "letrec-syntax"++syntaxLet :: (IORef Context -> [IORef Context] -> [IORef Context]) -> String+          -> [ScmValue] -> Haschoo ScmValue++syntaxLet f s (ScmList bindings : body@(_:_)) = do+   ctx   <- liftIO $ newIORef (mkContext [])+   stack <- fmap (f ctx) get+   mapM_ (go stack ctx) bindings+   withHaschoo (ctx:stack) (evalBody body)+ where+   go stack ctx (ScmList [ScmIdentifier var, binding]) = do+      syntax <- eval binding+      case syntax of+           ScmSyntax pats lits ->+              let macro = mkMacro stack var (map addVar pats) lits+               in liftIO $ modifyIORef ctx (addToContext var macro)+            where+              -- Add the macro's name to the list of free variables to create+              -- the difference between let-syntax and letrec-syntax+              addVar (pat, repl, frees) = (pat, repl, var:frees)++           _ -> badBinding s++   go _ _ _ = badBinding s++   badBinding = throwError . ("Invalid binding to " ++)++syntaxLet _ s (_:_:_) = throwError ("Invalid list of bindings to " ++ s)+syntaxLet _ s _       = tooFewArgs s++scmQuasiQuote :: [ScmValue] -> Haschoo ScmValue+scmQuasiQuote [expr] = finishUnqq <$> unqq 0 expr+ where+   finishUnqq = either (either (uncurry ScmPair) ScmList) id++   finishWrapUnqq s v = Right $ ScmList [ScmIdentifier s, finishUnqq v]++   -- Left results are stuff that need to be spliced+   unqq :: Int+        -> ScmValue+        -> Haschoo (Either (Either (IORef ScmValue, IORef ScmValue) [ScmValue])+                           ScmValue)++   unqq n (ScmList (ScmIdentifier s@"unquote" : vs)) =+      case vs of+           [v] | n == 0    -> Right <$> eval v+               | otherwise -> finishWrapUnqq s <$> unqq (n-1) v+           [] -> tooFewArgs  s+           _  -> tooManyArgs s++   unqq n (ScmList (ScmIdentifier s@"unquote-splicing" : vs)) =+      case vs of+           [v] | n == 0 -> do+              ev <- eval v+              case ev of+                   ScmList evs -> return$ Left . Right $ evs+                   ScmPair a b -> return$ Left . Left  $ (a,b)+                   _           -> notList++               | otherwise -> unqq (n-1) v++           [] -> tooFewArgs  s+           _  -> tooManyArgs s++   unqq n (ScmList (ScmIdentifier s@"quasiquote" : vs)) =+      case vs of+         [v] -> finishWrapUnqq s <$> unqq (n+1) v+         []  -> tooFewArgs  s+         _   -> tooManyArgs s++   unqq n (ScmList xs) =+      Right . either (uncurry ScmPair) ScmList <$>+         (splice =<< mapM (unqq n) xs)++   unqq n (ScmDottedList xs x) = do+      xs' <- splice =<< mapM (unqq n) xs+      x'  <- unqq n x+      case x' of+           Left _  -> throwError "quasiquote :: unexpected unquote-splicing"+           Right v ->+              case xs' of+                   Left (a,b) -> Right <$> (liftIO $ snocPair (ScmPair a b) v)+                   Right ys   -> return$ Right $ ScmDottedList ys v++   unqq _ x = return (Right x)++   splice :: [Either (Either (IORef ScmValue, IORef ScmValue) [ScmValue])+                     ScmValue]+          -> Haschoo (Either (IORef ScmValue, IORef ScmValue) [ScmValue])+   splice xs =+      case fromRights xs of+           Just xs' -> return$ Right xs'+           Nothing  ->+              let listified = map (either id (Right . (:[]))) xs+               in case fromRights listified of+                       Just xs' -> return$ Right (concat xs')+                       Nothing  -> do+                          cat <- liftIO $+                             scmAppend =<<+                                mapM (either (return . uncurry ScmPair)+                                             (fmap fst . listToPair))+                                     listified+                          case cat of+                               Left  _             -> notList+                               Right (ScmPair a b) -> return$ Left (a,b)+                               Right _             ->+                                  error "splice :: the impossible happened"++   snocPair :: ScmValue -> ScmValue -> IO ScmValue+   snocPair p@(ScmPair _ b) x = do+      b' <- liftIO $ readIORef b+      case b' of+           ScmList xs      -> do liftIO $ writeIORef b (ScmList (xs ++ [x]))+                                 return p+           q@(ScmPair _ _) -> snocPair q x++           -- splice's return value should be a proper list+           _               -> error "snocPair :: the impossible happened"++   snocPair _ _ = error "snocPair :: the impossible happened"++   notList :: Haschoo a+   notList = throwError "quasiquote :: unquote-splicing did not return a list"++scmQuasiQuote [] = tooFewArgs  "quasiquote"+scmQuasiQuote _  = tooManyArgs "quasiquote"++scmDo :: [ScmValue] -> Haschoo ScmValue+scmDo (ScmList vars : ScmList (test:result) : cmds) = do+   inited <- mapM initVar vars+   c' <- liftIO $ newIORef (mkContext $ map fst inited)+   ctx <- get+   withHaschoo (c':ctx) (go $ map (first fst) inited)+ where+   go :: [(String, ScmValue)] -> Haschoo ScmValue+   go varSteps = do+      stop <- eval test+      if isTrue stop+         then if null result then return ScmVoid else last <$> mapM eval result+         else do+            mapM_ eval cmds+            evalSteps <- mapM (eval.snd) varSteps+            mapM_ (uncurry set) $ zip (map fst varSteps) evalSteps+            go varSteps++   initVar :: ScmValue -> Haschoo ((String, ScmValue), ScmValue)+   initVar (ScmList (var@(ScmIdentifier v) : i : step)) = do+      step' <- case step of+                    []  -> return var+                    [s] -> return s+                    _   -> throwError "do :: more than one step expression?"+      ei <- eval i+      return ((v, ei), step')++   initVar _ = throwError "do :: expected list of variables and initializers"++scmDo (_:_:_:_) = tooManyArgs "do"+scmDo (_:_:_)   = throwError  "do :: no tests or nonlist arguments"+scmDo _         = tooFewArgs  "do"++set :: String -> ScmValue -> Haschoo ()+set var evaled = modifyM f+ where+   f (c:cs) = do+      c' <- liftIO $ readIORef c+      case contextLookup var c' of+           Just _  -> do+              liftIO $ modifyIORef c (addToContext var evaled)+              return (c:cs)++           Nothing -> (c:) <$> f cs++   f [] = throwError $ "Unbound identifier '" ++ var ++ "'"
+ Haschoo/Evaluator/Standard.hs view
@@ -0,0 +1,32 @@+-- File created: 2009-07-15 11:00:10++module Haschoo.Evaluator.Standard (context) where++import           Haschoo.Types (ScmValue, Context, mkContext)+import qualified Haschoo.Evaluator.Standard.Boolean     as Boolean+import qualified Haschoo.Evaluator.Standard.Characters  as Characters+import qualified Haschoo.Evaluator.Standard.Control     as Control+import qualified Haschoo.Evaluator.Standard.Equivalence as Equivalence+import qualified Haschoo.Evaluator.Standard.Eval        as Eval+import qualified Haschoo.Evaluator.Standard.IO          as IO+import qualified Haschoo.Evaluator.Standard.Numeric     as Numeric+import qualified Haschoo.Evaluator.Standard.PairsLists  as PairsLists+import qualified Haschoo.Evaluator.Standard.Strings     as Strings+import qualified Haschoo.Evaluator.Standard.Symbols     as Symbols+import qualified Haschoo.Evaluator.Standard.Vectors     as Vectors++procedures :: [(String, ScmValue)]+procedures = concat [ Boolean.procedures+                    , Characters.procedures+                    , Control.procedures+                    , Equivalence.procedures+                    , Eval.procedures+                    , IO.procedures+                    , Numeric.procedures+                    , PairsLists.procedures+                    , Strings.procedures+                    , Symbols.procedures+                    , Vectors.procedures ]++context :: Context+context = mkContext procedures
+ Haschoo/Evaluator/Standard/Boolean.hs view
@@ -0,0 +1,22 @@+-- File created: 2009-07-21 22:04:14++module Haschoo.Evaluator.Standard.Boolean (procedures) where++import Haschoo.Types           (ScmValue(..), isTrue)+import Haschoo.Utils           (ErrOr)+import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs)++procedures :: [(String, ScmValue)]+procedures = map (\(a,b) -> (a, ScmFunc a (return . b)))+   [ ("not",      fmap ScmBool . scmNot)+   , ("boolean?", fmap ScmBool . scmIsBoolean) ]++scmNot, scmIsBoolean :: [ScmValue] -> ErrOr Bool+scmNot [x] = Right . not . isTrue $ x+scmNot []  = tooFewArgs  "not"+scmNot _   = tooManyArgs "not"++scmIsBoolean [ScmBool _] = Right True+scmIsBoolean [_]         = Right False+scmIsBoolean []          = tooFewArgs  "boolean?"+scmIsBoolean _           = tooManyArgs "boolean?"
+ Haschoo/Evaluator/Standard/Characters.hs view
@@ -0,0 +1,92 @@+-- File created: 2009-08-04 19:35:58++module Haschoo.Evaluator.Standard.Characters (procedures) where++import Control.Arrow ((&&&))+import Data.Char     ( isAlpha, isDigit, isSpace, isLower, isUpper+                     , isLetter, toLower, toUpper)++import Haschoo.Types           (ScmValue(..))+import Haschoo.Utils           (ErrOr, ($<), (.:))+import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs, notInt, notChar)++procedures :: [(String, ScmValue)]+procedures = map (\(a,b) -> (a, ScmFunc a (return . b)))+   [ ("char?",  fmap ScmBool . scmIsChar)++   , "char=?"  $< id &&& fmap ScmBool .: scmCompare (==) (,)+   , "char<?"  $< id &&& fmap ScmBool .: scmCompare (<)  (,)+   , "char>?"  $< id &&& fmap ScmBool .: scmCompare (>)  (,)+   , "char<=?" $< id &&& fmap ScmBool .: scmCompare (<=) (,)+   , "char>=?" $< id &&& fmap ScmBool .: scmCompare (>=) (,)++   , "char-ci=?"  $< id &&& fmap ScmBool .: scmCompare (==) lower+   , "char-ci<?"  $< id &&& fmap ScmBool .: scmCompare (<)  lower+   , "char-ci>?"  $< id &&& fmap ScmBool .: scmCompare (>)  lower+   , "char-ci<=?" $< id &&& fmap ScmBool .: scmCompare (<=) lower+   , "char-ci>=?" $< id &&& fmap ScmBool .: scmCompare (>=) lower++   , "char-alphabetic?" $< id &&& fmap ScmBool .: scmProperty isAlpha+   , "char-numeric?"    $< id &&& fmap ScmBool .: scmProperty isDigit+   , "char-whitespace?" $< id &&& fmap ScmBool .: scmProperty isSpace+   , "char-upper-case?" $< id &&& fmap ScmBool .: scmProperty isUpper+   , "char-lower-case?" $< id &&& fmap ScmBool .: scmProperty isLower++   , ("char->integer", scmToInt)+   , ("integer->char", scmToChar)++   , "char-upcase"   $< id &&& fmap ScmChar .: scmApply toUpper+   , "char-downcase" $< id &&& fmap ScmChar .: scmApply toLower+   ]+ where+   lower a b = if isLetter a && isLetter b+                  then (toLower a, toLower b)+                  else (a,b)++scmIsChar :: [ScmValue] -> ErrOr Bool+scmIsChar [ScmChar _] = Right True+scmIsChar [_]         = Right False+scmIsChar []          = tooFewArgs  "char?"+scmIsChar _           = tooManyArgs "char?"++scmCompare :: (Char -> Char -> Bool) -> (Char -> Char -> (Char,Char)) -> String+           -> [ScmValue] -> ErrOr Bool+scmCompare p f _ [ScmChar a, ScmChar b] = Right . uncurry p $ f a b+scmCompare _ _ s [_,_]                  = notChar     s+scmCompare _ _ s (_:_:_)                = tooManyArgs s+scmCompare _ _ s _                      = tooFewArgs  s++scmProperty :: (Char -> Bool) -> String -> [ScmValue] -> ErrOr Bool+scmProperty f _ [ScmChar c] = Right $ f c+scmProperty _ s [_]         = notChar     s+scmProperty _ s []          = tooFewArgs  s+scmProperty _ s _           = tooManyArgs s++scmToInt, scmToChar :: [ScmValue] -> ErrOr ScmValue+scmToInt [ScmChar c] = Right . ScmInt . toInt $ c+scmToInt [_]         = notChar     "char->integer"+scmToInt []          = tooFewArgs  "char->integer"+scmToInt _           = tooManyArgs "char->integer"++scmToChar [ScmInt i] =+   if i >= toInt (minBound :: Char) && i <= toInt (maxBound :: Char)+      then Right . ScmChar . toChar $ i+      else fail "Out-of-range integer to integer->char"++scmToChar [_]        = notInt      "integer->char"+scmToChar []         = tooFewArgs  "integer->char"+scmToChar _          = tooManyArgs "integer->char"++scmApply :: (Char -> Char) -> String -> [ScmValue] -> ErrOr Char+scmApply f _ [ScmChar c] = Right $ f c+scmApply _ s [_]         = notChar     s+scmApply _ s []          = tooFewArgs  s+scmApply _ s _           = tooManyArgs s++------++toChar :: Integer -> Char+toChar = toEnum . fromInteger++toInt :: Char -> Integer+toInt = toInteger . fromEnum
+ Haschoo/Evaluator/Standard/Control.hs view
@@ -0,0 +1,100 @@+-- File created: 2009-07-22 21:05:24++{-# LANGUAGE ScopedTypeVariables #-}++module Haschoo.Evaluator.Standard.Control (procedures) where++import Data.List           (transpose, genericLength)+import Data.Number.Natural (Natural)++import Haschoo.Types           (ScmValue(..), pairToList, listToPair)+import Haschoo.Utils           (ErrOr, initLast, (.:))+import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs, notList, notProcedure)++procedures :: [(String, ScmValue)]+procedures = map (\(a,b) -> (a, ScmFunc a b))+   [ ("procedure?",  return . fmap ScmBool . scmIsProcedure)+   , ("apply",       scmApply)+   , ("map",         scmMap)+   , ("for-each",    scmForEach)+   ]++--- procedure?++scmIsProcedure :: [ScmValue] -> ErrOr Bool+scmIsProcedure [ScmFunc _ _] = Right True+scmIsProcedure [_]           = Right False+scmIsProcedure []            = tooFewArgs  "procedure?"+scmIsProcedure _             = tooManyArgs "procedure?"++--- apply++scmApply :: [ScmValue] -> IO (ErrOr ScmValue)+scmApply (ScmFunc _ f : args@(_:_)) =+   case initLast args of+        (xs, ScmList ys)       -> f (xs ++ ys)+        (xs, ys@(ScmPair _ _)) -> do+           ys' <- pairToList ys+           case ys' of+                Right (ScmList l) -> f (xs ++ l)+                _                 -> return$ notList "apply"++        (_, _) -> return$ notList "apply"++scmApply (_:_) = return$ notProcedure "apply"+scmApply _     = return$ tooFewArgs   "apply"++--- map for-each++scmMap, scmForEach :: [ScmValue] -> IO (ErrOr ScmValue)+scmMap (ScmFunc _ f : args@(_:_)) = do+   l <- scmIterate "map" [] (:) f args+   case l of+        Left  s  -> return (Left s)+        Right xs -> fmap (Right . fst) (listToPair xs)++scmMap (_:_) = return$ notProcedure "map"+scmMap _     = return$ tooFewArgs   "map"++scmForEach (ScmFunc _ f : args@(_:_)) = do+   err <- scmIterate "for-each" () (\_ _ -> ()) f args+   return$ either Left (const $ Right ScmVoid) err++scmForEach (_:_:_) = return$ notProcedure "for-each"+scmForEach _       = return$ tooFewArgs   "for-each"++scmIterate :: forall a. String -> a -> (ScmValue -> a -> a)+           -> ([ScmValue] -> IO (ErrOr ScmValue))+           -> [ScmValue]+           -> IO (ErrOr a)+scmIterate s end fuse f args = do+   args' <- prepArgs s args+   case args' of+        Right as -> go (genericLength.head $ as) as+        Left err -> return$ Left err+ where+   go :: Natural -> [[ScmValue]] -> IO (ErrOr a)+   go _   []     = return (Right end)+   go len (a:as) = if genericLength a == len+                      then do+                         fa <- f a+                         case fa of+                              Right a' -> do+                                 bs <- go len as+                                 case bs of+                                      Right bs' -> return.Right $ fuse a' bs'+                                      Left err  -> return.Left  $ err+                              Left err -> return.Left $ err++                      else return.Left $ s ++ " :: unmatching list lengths"++prepArgs :: String -> [ScmValue] -> IO (ErrOr [[ScmValue]])+prepArgs s = fmap (fmap transpose . sequence) .: mapM $ \a ->+      case a of+           ScmList xs       -> return.Right $ xs+           xs@(ScmPair _ _) -> do+              ys <- pairToList xs+              return$ case ys of+                           Right (ScmList l) -> Right l+                           _                 -> notList s+           _ -> return$ notList s
+ Haschoo/Evaluator/Standard/Equivalence.hs view
@@ -0,0 +1,99 @@+-- File created: 2009-07-21 10:36:31++module Haschoo.Evaluator.Standard.Equivalence+   (procedures, scmEq, scmEqv, scmEqual) where++import Control.Arrow       ((&&&))+import Control.Monad       (liftM2, join)+import Control.Monad.Loops (allM)+import Data.Array.IArray   (bounds, elems)+import Data.Array.MArray   (getBounds, getElems, unsafeFreeze)+import Data.Function       (on)++import Haschoo.Types                      (ScmValue(..), pairToList)+import Haschoo.Utils                      (ErrOr, ($<), (.:), eqWithM, ptrEq)+import Haschoo.Evaluator.Utils            (tooFewArgs, tooManyArgs)+import Haschoo.Evaluator.Standard.Numeric (isExact, isNumeric, numEq)++procedures :: [(String, ScmValue)]+procedures = map (\(a,b) -> (a, ScmFunc a b))+   [ "eq?"    $< id &&& fmap (fmap ScmBool) .: scmEquivalence scmEq+   , "eqv?"   $< id &&& fmap (fmap ScmBool) .: scmEquivalence scmEqv+   , "equal?" $< id &&& fmap (fmap ScmBool) .: scmEquivalence scmEqual+   ]++scmEq, scmEqv, scmEqual :: ScmValue -> ScmValue -> IO Bool+scmEqv (ScmBool       a) (ScmBool       b) = return$ a == b+scmEqv (ScmIdentifier a) (ScmIdentifier b) = return$ a == b+scmEqv (ScmChar       a) (ScmChar       b) = return$ a == b+scmEqv (ScmList       a) (ScmList       b) = ptrEq a b+scmEqv (ScmString     a) (ScmString     b) = ptrEq a b+scmEqv (ScmMString    a) (ScmMString    b) = ptrEq a b+scmEqv (ScmVector     a) (ScmVector     b) = ptrEq a b+scmEqv (ScmMVector    a) (ScmMVector    b) = ptrEq a b+scmEqv (ScmFunc  _    a) (ScmFunc  _    b) = ptrEq a b+scmEqv (ScmPrim  _    a) (ScmPrim  _    b) = ptrEq a b+scmEqv (ScmMacro _    a) (ScmMacro _    b) = ptrEq a b++scmEqv (ScmDottedList a b) (ScmDottedList x y) =+   liftM2 (&&) (ptrEq a x) (ptrEq b y)++scmEqv (ScmPair a b) (ScmPair x y) = liftM2 (&&) (ptrEq a x) (ptrEq b y)+scmEqv a b =+   if isNumeric a && isNumeric b+      then return$ isExact a == isExact b && numEq a b+      else ptrEq a b++scmEq a b = if isNumeric a && isNumeric b+               then ptrEq  a b+               else scmEqv a b++scmEqual x@(ScmPair _ _) y@(ScmPair _ _) =+   join $ (liftM2 scmEqual `on` fmap (either id id) . pairToList) x y++scmEqual (ScmList       x)   (ScmList       y)   = eqWithM scmEqual x y+scmEqual (ScmDottedList x a) (ScmDottedList y b) = do+   ab <- scmEqual a b+   if ab+      then eqWithM scmEqual x y+      else return False++scmEqual x@(ScmList _) y@(ScmPair _ _) =+   either (const $ return False) (scmEqual x) =<< pairToList y++scmEqual x@(ScmDottedList _ _) y@(ScmPair _ _) =+   either (scmEqual x) (const $ return False) =<< pairToList y++scmEqual y@(ScmPair _ _) x@(ScmList       _)   = scmEqual x y+scmEqual y@(ScmPair _ _) x@(ScmDottedList _ _) = scmEqual x y++scmEqual (ScmString  a) (ScmString  b) = return$ a == b+scmEqual (ScmMString a) (ScmMString b) = liftM2 (==) (getElems a) (getElems b)+scmEqual (ScmString  a) (ScmMString b) = fmap (elems a==) $ getElems b+scmEqual (ScmMString a) (ScmString  b) = fmap (==elems b) $ getElems a++scmEqual (ScmVector  a) (ScmVector  b) =+   if bounds a == bounds b+      then allM (uncurry scmEqual) $ (zip`on`elems) a b+      else return False++scmEqual (ScmMVector a) (ScmMVector b) = do+   ba <- getBounds a+   bb <- getBounds b+   if ba == bb+      then join $ (liftM2 (allM (uncurry scmEqual) .: zip) `on` getElems) a b+      else return False++scmEqual a@(ScmVector _)  (ScmMVector b) =+   unsafeFreeze b >>= scmEqual a . ScmVector+scmEqual  (ScmMVector a) b@(ScmVector _) =+   unsafeFreeze a >>= scmEqual b . ScmVector++scmEqual a b = scmEqv a b++scmEquivalence :: (ScmValue -> ScmValue -> IO Bool) -> String+               -> [ScmValue] -> IO (ErrOr Bool)++scmEquivalence f _ [x,y]   = fmap Right $ f x y+scmEquivalence _ s (_:_:_) = return$ tooManyArgs s+scmEquivalence _ s _       = return$ tooFewArgs  s
+ Haschoo/Evaluator/Standard/Eval.hs view
@@ -0,0 +1,24 @@+-- File created: 2009-08-08 16:39:10++module Haschoo.Evaluator.Standard.Eval (procedures) where++import Data.IORef (newIORef)++import Haschoo.Types           (ScmValue(..), runHaschoo)+import Haschoo.Utils           (ErrOr)+import Haschoo.Evaluator.Eval  (eval)+import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs)++procedures :: [(String, ScmValue)]+procedures = map (\(a,b) -> (a, ScmFunc a b))+   [ ("eval", scmEval)++   -- scheme-report-environment and null-environment are in Haschoo.Stdlib to+   -- avoid circular dependencies+   ]++scmEval :: [ScmValue] -> IO (ErrOr ScmValue)+scmEval [v, ScmContext ctx] = mapM newIORef ctx >>= flip runHaschoo (eval v)+scmEval [_,_]               = return$ Left "Nonenvironmental argument to eval"+scmEval (_:_:_)             = return$ tooManyArgs "eval"+scmEval _                   = return$ tooFewArgs  "eval"
+ Haschoo/Evaluator/Standard/IO.hs view
@@ -0,0 +1,200 @@+-- File created: 2009-07-20 13:30:25++module Haschoo.Evaluator.Standard.IO (procedures) where++import Control.Arrow     ((&&&))+import Control.Exception (bracket)+import Control.Monad     (liftM2)+import Data.Array.IArray (elems)+import Data.Array.MArray (getElems)+import System.IO         ( Handle, IOMode(..), stdin, stdout+                         , openFile, hClose, hIsEOF+                         , hGetChar, hLookAhead, hReady+                         , hPutStr, hPutStrLn, hPutChar)++import Haschoo.Parser          (runParser, value)+import Haschoo.Types           ( ScmValue(..), scmShow, scmShowWith+                               , isAggregate)+import Haschoo.Utils           (ErrOr, ($<), (.:))+import Haschoo.Evaluator.Utils ( tooFewArgs, tooManyArgs+                               , notProcedure, notString, notChar)++import Haschoo.Evaluator.Standard.Strings (isString, strToList)++procedures :: [(String, ScmValue)]+procedures = map (\(a,b) -> (a, ScmFunc a b))+   [ ("port?",                return .  fmap ScmBool .  scmIsPort)+   , "input-port?"  $< id &&& return .: fmap ScmBool .: scmIsInputPort+   , "output-port?" $< id &&& return .: fmap ScmBool .: scmIsOutputPort++   , ("eof-object?", return . fmap ScmBool . scmIsEof)++   , "call-with-input-file"  $< id &&& scmCallWithFile  ReadMode ScmInput+   , "call-with-output-file" $< id &&& scmCallWithFile WriteMode ScmOutput++   , "current-input-port"  $< id &&& flip constant (return $ ScmInput  stdin)+   , "current-output-port" $< id &&& flip constant (return $ ScmOutput stdout)++   , "open-input-file"  $< id &&& scmOpenFile  ReadMode ScmInput+   , "open-output-file" $< id &&& scmOpenFile WriteMode ScmOutput++   , ("close-input-port",  scmCloseInputPort)+   , ("close-output-port", scmCloseOutputPort)++   , "read"       $< id &&& \s -> withInput 0 s (constant s . scmRead)+   , "read-char"  $< id &&& \s -> withInput 0 s (constant s . scmReadChar)+   , "peek-char"  $< id &&& \s -> withInput 0 s (constant s . scmPeekChar)+   , "char-ready" $< id &&& \s -> withInput 0 s (constant s . scmCharReady)++   , "write"      $< id &&& \s -> withOutput 1 s scmWrite+   , "display"    $< id &&& \s -> withOutput 1 s scmDisplay+   , "newline"    $< id &&& \s -> withOutput 0 s (constant s . scmNewline)+   , "write-char" $< id &&& \s -> withOutput 1 s scmWriteChar+   ]++scmIsInputPort, scmIsOutputPort :: String -> [ScmValue] -> ErrOr Bool+scmIsInputPort  _ [ScmInput _]  = Right True+scmIsInputPort  _ [_]           = Right False+scmIsInputPort  s []            = tooFewArgs  s+scmIsInputPort  s _             = tooManyArgs s+scmIsOutputPort _ [ScmOutput _] = Right True+scmIsOutputPort _ [_]           = Right False+scmIsOutputPort s []            = tooFewArgs  s+scmIsOutputPort s _             = tooManyArgs s++scmIsPort :: [ScmValue] -> ErrOr Bool+scmIsPort x =+   liftM2 (||) (scmIsInputPort "port?" x) (scmIsOutputPort "port?" x)++scmIsEof :: [ScmValue] -> ErrOr Bool+scmIsEof [ScmEOF] = Right True+scmIsEof [_]      = Right False+scmIsEof []       = tooFewArgs "eof-object?"+scmIsEof _        = tooManyArgs "eof-object?"++scmCallWithFile :: IOMode -> (Handle -> ScmValue) -> String+                -> [ScmValue] -> IO (ErrOr ScmValue)+scmCallWithFile mode toPort _ [s, ScmFunc _ f] | isString s = do+   path <- strToList s+   bracket (openFile path mode) hClose (f . (:[]) . toPort)++scmCallWithFile _ _ s [_, ScmFunc _ _] = return$ notString    s+scmCallWithFile _ _ s [_,_]            = return$ notProcedure s+scmCallWithFile _ _ s (_:_:_)          = return$ tooManyArgs  s+scmCallWithFile _ _ s _                = return$ tooFewArgs   s++scmOpenFile :: IOMode -> (Handle -> ScmValue) -> String+            -> [ScmValue] -> IO (ErrOr ScmValue)+scmOpenFile mode toPort _ [s] | isString s = do+   path <- strToList s+   fmap (Right . toPort) (openFile path mode)++scmOpenFile _ _ s [_] = return$ notString   s+scmOpenFile _ _ s []  = return$ tooFewArgs  s+scmOpenFile _ _ s _   = return$ tooManyArgs s++scmCloseInputPort, scmCloseOutputPort :: [ScmValue] -> IO (ErrOr ScmValue)+scmCloseInputPort  [ScmInput  h] = hClose h >> return (Right ScmVoid)+scmCloseInputPort  [_]           = return$ notInput    "close-input-port"+scmCloseInputPort  []            = return$ tooFewArgs  "close-input-port"+scmCloseInputPort  _             = return$ tooManyArgs "close-input-port"+scmCloseOutputPort [ScmOutput h] = hClose h >> return (Right ScmVoid)+scmCloseOutputPort [_]           = return$ notOutput   "close-output-port"+scmCloseOutputPort []            = return$ tooFewArgs  "close-output-port"+scmCloseOutputPort _             = return$ tooManyArgs "close-output-port"++-- Meh, this is a pain. The parser is pure so we'd basically need to give it+-- the result of hGetContents; but that breaks any further input ("semi-closes"+-- the handle). So just read a char at a time until we get a successful parse.+--+-- The spec doesn't say what to do if we get nonsense like anything starting+-- with ")", so we choose to loop forever (or until EOF).+--+-- O(n^2 + np) where n is the length of the input and p the time it takes for a+-- parse.+scmRead :: Handle -> IO ScmValue+scmRead hdl = go []+ where+   go s = do+      eof <- hIsEOF hdl+      if eof+         then return ScmEOF+         else do+            c <- hGetChar hdl+            let s' = s ++ [c]+            either (const $ go s') return (runParser value "" s')++scmReadChar, scmPeekChar, scmCharReady :: Handle -> IO ScmValue+scmReadChar  = fmap ScmChar . hGetChar+scmPeekChar  = fmap ScmChar . hLookAhead+scmCharReady = fmap ScmBool . hReady++scmWrite, scmDisplay :: Handle -> [ScmValue] -> IO (ErrOr ScmValue)+scmWrite   = scmPrint scmShow "write"+scmDisplay = scmPrint f "display"+ where+   f (ScmString  s)    = return (elems s)+   f (ScmMString s)    = getElems s+   f (ScmChar    c)    = return [c]+   f x | isAggregate x = scmShowWith f x+       | otherwise     = scmShow x++scmPrint :: (ScmValue -> IO String) -> String+         -> Handle -> [ScmValue] -> IO (ErrOr ScmValue)+scmPrint f _ h [x] = f x >>= hPutStr h >> return (Right ScmVoid)+scmPrint _ s _ []  = return$ tooFewArgs  s+scmPrint _ s _ _   = return$ tooManyArgs s++scmNewline :: Handle -> IO ScmValue+scmNewline h = hPutStrLn h "" >> return ScmVoid++scmWriteChar :: Handle -> [ScmValue] -> IO (ErrOr ScmValue)+scmWriteChar h [ScmChar c] = hPutChar h c >> return (Right ScmVoid)+scmWriteChar _ [_]         = return$ notChar     "write-char"+scmWriteChar _ []          = return$ tooFewArgs  "write-char"+scmWriteChar _ _           = return$ tooManyArgs "write-char"++-----++notInput, notOutput :: String -> ErrOr a+notInput  = fail . ("Non-input-port argument to " ++)+notOutput = fail . ("Non-output-port argument to " ++)++constant :: String -> IO ScmValue -> [ScmValue] -> IO (ErrOr ScmValue)+constant _ x [] = fmap Right x+constant s _ _  = return$ tooManyArgs s++-- These take advantage of the fact that the port is always the last argument+--+-- withInput does an EOF check as well+withInput, withOutput :: Int+                      -> String+                      -> (Handle -> [ScmValue] -> IO (ErrOr ScmValue))+                      -> [ScmValue] -> IO (ErrOr ScmValue)+withInput idx s f = withPort stdin apply idx s f+ where+   apply (ScmInput h) xs = do+      eof <- hIsEOF h+      if eof+         then return$ Right ScmEOF+         else f h xs+   apply _            _  = return$ notInput s++withOutput idx s f = withPort stdout apply idx s f+ where+   apply (ScmOutput h) = f h+   apply _             = const.return$ notOutput s++withPort :: Handle+         -> (ScmValue -> ([ScmValue] -> IO (ErrOr ScmValue)))+         -> Int+         -> String+         -> (Handle -> [ScmValue] -> IO (ErrOr ScmValue))+         -> [ScmValue] -> IO (ErrOr ScmValue)++withPort defaultHdl apply idx s f args =+   let (xs, p) = splitAt idx args+    in case p of+            [x] -> apply x xs+            []  -> f defaultHdl xs+            _   -> return$ tooManyArgs s
+ Haschoo/Evaluator/Standard/Numeric.hs view
@@ -0,0 +1,744 @@+-- File created: 2009-07-15 21:15:44++{-# LANGUAGE Rank2Types #-}++module Haschoo.Evaluator.Standard.Numeric+   (procedures, isNumeric, isExact, numEq, asInt) where++import Control.Arrow     ((&&&), (***))+import Control.Monad     (ap, foldM)+import Data.Array.IArray (elems)+import Data.Array.MArray (getElems)+import Data.Char         (intToDigit)+import Data.Complex      ( Complex((:+)), mkPolar+                         , imagPart, realPart, phase, magnitude)+import Data.Ratio        (numerator, denominator, approxRational)+import Data.Function     (on)+import Numeric           (showIntAtBase, showSigned)++import qualified Haschoo.Parser as Parser+import           Haschoo.Types           (ScmValue(..), toScmMString)+import           Haschoo.Utils           (ErrOr, allM, ($<), (.:))+import           Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs, notInt)++procedures :: [(String, ScmValue)]+procedures = map (\(a,b) -> (a, ScmFunc a (return . b)))+   [ ("number?",   fmap ScmBool . scmIsNumber)+   , ("complex?",  fmap ScmBool . scmIsNumber)+   , ("real?",     fmap ScmBool . scmIsReal)+   , ("rational?", fmap ScmBool . scmIsRational)+   , ("integer?",  fmap ScmBool . scmIsInteger)++   , "exact?"   $< id &&& fmap  ScmBool        .: scmIsExact+   , "inexact?" $< id &&& fmap (ScmBool . not) .: scmIsExact++   , ("=", fmap ScmBool . scmNumEq)+   , "<"  $< id &&& fmap ScmBool .: scmCompare (<)+   , ">"  $< id &&& fmap ScmBool .: scmCompare (>)+   , "<=" $< id &&& fmap ScmBool .: scmCompare (<=)+   , ">=" $< id &&& fmap ScmBool .: scmCompare (>=)++   , ("zero?",     fmap ScmBool . scmIsZero)+   , ("positive?", fmap ScmBool . scmIsPos)+   , ("negative?", fmap ScmBool . scmIsNeg)+   , "even?" $< id &&& fmap  ScmBool        .: scmIsEven+   , "odd?"  $< id &&& fmap (ScmBool . not) .: scmIsEven++   , ("max", scmMax)+   , ("min", scmMin)++   , ("+", scmPlus)+   , ("-", scmMinus)+   , ("*", scmMul)+   , ("/", scmDiv)++   , ("abs", scmAbs)++   , ("quotient",  scmQuot)+   , ("remainder", scmRem)+   , ("modulo",    scmMod)++   , ("gcd", scmGcd)+   , ("lcm", scmLcm)++   , ("numerator",   scmNumerator)+   , ("denominator", scmDenominator)++   , ("floor",    scmFloor)+   , ("ceiling",  scmCeil)+   , ("truncate", scmTrunc)+   , ("round",    scmRound)++   , ("rationalize", scmRationalize)++   , ("exp",  scmExp)+   , ("log",  scmLog)+   , ("sin",  scmSin)+   , ("cos",  scmCos)+   , ("tan",  scmTan)+   , ("asin", scmAsin)+   , ("acos", scmAcos)+   , ("atan", scmAtan)++   , ("sqrt", scmSqrt)+   , ("expt", scmExpt)++   , ("make-rectangular", scmMakeRectangular)+   , ("make-polar",       scmMakePolar)+   , ("real-part",        scmRealPart)+   , ("imag-part",        scmImagPart)+   , ("magnitude",        scmNorm)+   , ("angle",            scmAngle)++   , ("exact->inexact", scmToInexact)+   , ("inexact->exact", scmToExact) ]++   ++ map (\(a,b) -> (a, ScmFunc a b))+   [ ("number->string", scmToString)+   , ("string->number", scmToNumber) ]++---- Predicates++scmIsNumber, scmIsReal, scmIsRational, scmIsInteger :: [ScmValue] -> ErrOr Bool+scmIsNumber [x] = Right $ isNumeric x+scmIsNumber []  = tooFewArgs  "number?"+scmIsNumber _   = tooManyArgs "number?"++scmIsReal [x] = Right $ isReal x+scmIsReal []  = tooFewArgs  "real?"+scmIsReal _   = tooManyArgs "real?"++scmIsRational [ScmRat _] = Right True+scmIsRational [x]        = Right $ isInteger x+scmIsRational []         = tooFewArgs "rational?"+scmIsRational _          = tooManyArgs "rational?"++scmIsInteger [x] = Right $ isInteger x+scmIsInteger []  = tooFewArgs  "integer?"+scmIsInteger _   = tooManyArgs "integer?"++scmIsExact :: String -> [ScmValue] -> ErrOr Bool+scmIsExact _ [x] | isNumeric x = Right $ isExact x+scmIsExact s [_]               = notNum s+scmIsExact s []                = tooFewArgs s+scmIsExact s _                 = tooManyArgs s++isExact :: ScmValue -> Bool+isExact (ScmInt _) = True+isExact (ScmRat _) = True+isExact _          = False++---- Comparison++scmNumEq :: [ScmValue] -> ErrOr Bool+scmNumEq [] = tooFewArgs "="+scmNumEq xs = allM f . (zip`ap`tail) $ xs+ where+   f (a,b) = if isNumeric a && isNumeric b+                then Right $ numEq a b+                else notNum "="++numEq :: ScmValue -> ScmValue -> Bool+numEq x y =+   case pairScmComplex x y of+        Right (ScmInt     a, ScmInt     b) -> a == b+        Right (ScmRat     a, ScmRat     b) -> a == b+        Right (ScmReal    a, ScmReal    b) -> a == b+        Right (ScmComplex a, ScmComplex b) -> a == b+        _ -> error "numEq :: the impossible happened"++scmCompare :: (forall a. Real a => a -> a -> Bool)+           -> String -> [ScmValue] -> ErrOr Bool+scmCompare p s xs@(_:_:_) = allM f . (zip`ap`tail) $ xs+ where+   f (a,b) = case liftScmRealA2 p a b of+                  Left _ -> notReal s+                  x      -> x++scmCompare _ s _ = tooFewArgs s++scmIsZero :: [ScmValue] -> ErrOr Bool+scmIsZero [ScmInt     0]    = Right True+scmIsZero [ScmRat     0]    = Right True+scmIsZero [ScmReal    0]    = Right True+scmIsZero [ScmComplex 0]    = Right True+scmIsZero [x] | isNumeric x = Right False+scmIsZero [_]               = notNum "zero?"+scmIsZero _                 = tooManyArgs "zero?"++scmIsPos, scmIsNeg :: [ScmValue] -> ErrOr Bool+scmIsPos [x] = scmCompare (>) "positive?" [x, ScmInt 0]+scmIsPos _   = tooManyArgs "positive?"++scmIsNeg [x] = scmCompare (<) "negative?" [x, ScmInt 0]+scmIsNeg _   = tooManyArgs "negative?"++scmIsEven :: String -> [ScmValue] -> ErrOr Bool+scmIsEven s [x] = if isInteger x+                     then (scmIsZero.return) =<< scmMod [x, ScmInt 2]+                     else notInt s+scmIsEven s _   = tooManyArgs s++scmMax, scmMin :: [ScmValue] -> ErrOr ScmValue+scmMax = scmMinMax max "max"+scmMin = scmMinMax min "min"++scmMinMax :: (forall a. Real a => a -> a -> a) -> String+          -> [ScmValue] -> ErrOr ScmValue+scmMinMax _ s []     = tooFewArgs s+scmMinMax f s (x:xs) = if isNumeric x then foldM go x xs else notNum s+ where+   go n a = if isNumeric a+               then case liftScmReal2 f n a of+                         Left _ -> notReal s+                         m      -> m+               else notNum s++---- +-*/++scmPlus, scmMinus, scmMul, scmDiv :: [ScmValue] -> ErrOr ScmValue+scmPlus [] = Right $ ScmInt 0+scmPlus xs = foldM go (ScmInt 0) xs+ where+   go n x = if isNumeric x then liftScmNum2 (+) n x else notNum "+"++scmMinus []                        = tooFewArgs "-"+scmMinus (x:_) | not (isNumeric x) = notNum "-"+scmMinus [x]                       = liftScmNum negate x+scmMinus (x:xs)                    = foldM go x xs+ where+   go n a = if isNumeric a then liftScmNum2 (-) n a else notNum "-"++scmMul [] = Right $ ScmInt 1+scmMul xs = foldM go (ScmInt 1) xs+ where+   go n x = if isNumeric x then liftScmNum2 (*) n x else notNum "*"++scmDiv []     = tooFewArgs "/"+scmDiv (x:xs) =+   unint x >>= case xs of+                    []  -> liftScmFrac recip+                    _:_ -> flip (foldM go) xs+ where+   go n a = unint a >>= liftScmFrac2 (/) n++   unint (ScmInt n) = Right $ ScmRat (fromInteger n)+   unint n          = if isNumeric x then Right n else notNum "/"++---- abs++scmAbs :: [ScmValue] -> ErrOr ScmValue+scmAbs [x] =+   if isReal x+      then liftScmNum abs x+      else notReal "abs"+scmAbs [] = tooFewArgs  "abs"+scmAbs _  = tooManyArgs "abs"++---- quot rem mod++scmQuot, scmRem, scmMod :: [ScmValue] -> ErrOr ScmValue+scmQuot = scmQuotRemMod quot "quotient"+scmRem  = scmQuotRemMod rem "remainder"+scmMod  = scmQuotRemMod mod "modulo"++scmQuotRemMod :: (Integer -> Integer -> Integer) -> String+              -> [ScmValue] -> ErrOr ScmValue+scmQuotRemMod f s [x,y] = do+   (e1,a) <- asInt s x+   (e2,b) <- asInt s y+   return . (if e1 && e2 then ScmInt else ScmReal . fromInteger) $ f a b+scmQuotRemMod _ s (_:_:_) = tooManyArgs s+scmQuotRemMod _ s _       = tooFewArgs  s++---- gcd lcm++scmGcd, scmLcm :: [ScmValue] -> ErrOr ScmValue+scmGcd = scmGcdLcm (\a b -> if a == 0 && b == 0 then 0 else gcd a b) 0 "gcd"+scmLcm = scmGcdLcm lcm 1 "lcm"++scmGcdLcm :: (Integer -> Integer -> Integer) -> Integer -> String+          -> [ScmValue] -> ErrOr ScmValue+scmGcdLcm f i s = fmap fin . foldM go (True,i)+ where+   go  (exact, n) = fmap ((exact &&) *** f n) . asInt s+   fin (exact, n) = if exact then ScmInt n else ScmReal (fromInteger n)++---- numerator denominator++scmNumerator, scmDenominator :: [ScmValue] -> ErrOr ScmValue+scmNumerator   = scmNumerDenom numerator   "numerator"+scmDenominator = scmNumerDenom denominator "denominator"++scmNumerDenom :: (Rational -> Integer) -> String+              -> [ScmValue] -> ErrOr ScmValue+scmNumerDenom f s [n] =+   case n of+        ScmInt      x       -> Right . ScmInt  $ f (fromInteger x)+        ScmRat      x       -> Right . ScmInt  $ f x+        ScmReal     x       -> Right . ScmReal . fromInteger $ f (realToFrac x)+        ScmComplex (x :+ 0) -> Right . ScmReal . fromInteger $ f (realToFrac x)+        _                   -> notRat s++scmNumerDenom _ s [] = tooFewArgs s+scmNumerDenom _ s _  = tooManyArgs s++---- floor ceil trunc round++scmFloor, scmCeil, scmTrunc, scmRound :: [ScmValue] -> ErrOr ScmValue+scmFloor = scmGenericRound floor    "floor"+scmCeil  = scmGenericRound ceiling  "ceiling"+scmTrunc = scmGenericRound truncate "truncate"+scmRound = scmGenericRound round    "round"++scmGenericRound :: (forall a. RealFrac a => a -> Integer) -> String+                -> [ScmValue] -> ErrOr ScmValue+scmGenericRound _ _ [   ScmInt     x]  = Right . ScmInt                $ x+scmGenericRound f _ [   ScmRat     x]  = Right . ScmInt                $ f x+scmGenericRound f _ [   ScmReal    x]  = Right . ScmReal . fromInteger $ f x+scmGenericRound _ s [n@(ScmComplex _)] =+   case asInt s n of+        Right (_,x) -> Right . ScmInt $ x+        Left _      -> notReal s+scmGenericRound _ s [_]            = notNum s+scmGenericRound _ s []             = tooFewArgs s+scmGenericRound _ s _              = tooManyArgs s++---- rationalize++scmRationalize :: [ScmValue] -> ErrOr ScmValue+scmRationalize (_:_:_:_) = tooManyArgs "rationalize"+scmRationalize [x,y]     =+   case liftScmRealFracB2 approxRational x y of+        Left _           -> notReal "rationalize"+        Right (True , n) -> Right (ScmRat  n)+        Right (False, n) -> Right (ScmReal (fromRational n))++scmRationalize _         = tooFewArgs "rationalize"++---- exp log sin cos tan asin acos atan sqrt++scmExp, scmLog,+ scmSin,  scmCos,  scmTan,+ scmAsin, scmAcos, scmAtan,+ scmSqrt :: [ScmValue] -> ErrOr ScmValue++scmExp  = scmComplex1 exp  "exp"+scmLog  = scmComplex1 log  "log"+scmSin  = scmComplex1 sin  "sin"+scmCos  = scmComplex1 cos  "cos"+scmTan  = scmComplex1 tan  "tan"+scmAsin = scmComplex1 asin "asin"+scmAcos = scmComplex1 acos "acos"++scmAtan [y,x] =+   case pairScmReal x y of+        Left  _                      -> notReal "atan"+        Right (ScmReal a, ScmReal b) -> Right (ScmReal $ phase $ a :+ b)+        Right (ScmInt a, ScmInt b)   ->+           Right (ScmReal $ phase $ fromInteger a :+ fromInteger b)+        Right (ScmRat a, ScmRat b)   ->+           Right (ScmReal $ phase $ fromRational a :+ fromRational b)+        Right _                      -> error "scmAtan :: internal error"++scmAtan xs    = scmComplex1 atan "atan" xs++scmSqrt = scmComplex1 sqrt "sqrt"++scmComplex1 :: (Complex Double -> Complex Double) -> String+            -> [ScmValue] -> ErrOr ScmValue+scmComplex1 f _ [ScmInt     x] = Right . fromComplex $ f (fromInteger  x :+ 0)+scmComplex1 f _ [ScmRat     x] = Right . fromComplex $ f (fromRational x :+ 0)+scmComplex1 f _ [ScmReal    x] = Right . fromComplex $ f (x :+ 0)+scmComplex1 f _ [ScmComplex x] = Right . fromComplex $ f x+scmComplex1 _ s [_]            = notNum s+scmComplex1 _ s []             = tooFewArgs s+scmComplex1 _ s _              = tooManyArgs s++---- expt++scmExpt :: [ScmValue] -> ErrOr ScmValue+scmExpt [x,y] =+   case pairScmComplex x y of+        Left _                              -> notNum "expt"+        Right (ScmInt     a, ScmInt      b) ->+           if b < 0+              then Right . ScmReal $ fromInteger a ^^ b+              else Right . ScmInt  $ a ^ b+        Right (ScmReal    a, ScmReal     b) -> Right . ScmReal    $ a ** b+        Right (ScmComplex a, ScmComplex  b) -> Right . ScmComplex $ a ** b+        Right (ScmRat     a, ScmRat      b) ->+           Right . ScmReal $ fromRational a ** fromRational b+        Right _                             -> error "expt :: internal error"++scmExpt (_:_:_) = tooManyArgs "expt"+scmExpt _       = tooFewArgs  "expt"++---- make-rectangular make-polar real-part imag-part magnitude angle++scmMakeRectangular, scmMakePolar :: [ScmValue] -> ErrOr ScmValue+scmMakeRectangular = scmMakeComplex (:+)    "make-rectangular"+scmMakePolar       = scmMakeComplex mkPolar "make-polar"++scmMakeComplex :: (Double -> Double -> Complex Double) -> String+               -> [ScmValue] -> ErrOr ScmValue+scmMakeComplex f s [x,y] =+   case pairScmReal x y of+        Left _                       -> notReal s+        Right (ScmReal a, ScmReal b) -> Right . ScmComplex $ f a b+        Right (ScmRat  a, ScmRat  b) ->+           Right . ScmComplex $ (f `on` fromRational) a b+        Right (ScmInt  a, ScmInt  b) ->+           Right . ScmComplex $ (f `on` fromInteger) a b+        Right _                      ->+           error $ s ++ " :: internal error"++scmMakeComplex _ s (_:_:_) = tooManyArgs s+scmMakeComplex _ s _       = tooFewArgs  s++scmRealPart, scmImagPart, scmNorm, scmAngle :: [ScmValue] -> ErrOr ScmValue+scmRealPart = scmComplexPart realPart  Right                  "real-part"+scmImagPart = scmComplexPart imagPart  (liftScmNum $ const 0) "imag-part"+scmNorm     = scmComplexPart magnitude (liftScmNum abs)       "magnitude"+scmAngle    = scmComplexPart phase     (Right . angle)        "angle"+ where+   angle (ScmReal n) = f ScmReal n+   angle (ScmRat  n) = f ScmRat  n+   angle (ScmInt  n) = f ScmInt  n+   angle _           = error "angle :: the impossible happened"++   f c n = if n >= 0 then c 0 else ScmReal pi++scmComplexPart :: (Complex Double -> Double)+               -> (ScmValue -> ErrOr ScmValue)+               -> String+               -> [ScmValue] -> ErrOr ScmValue+scmComplexPart f _ _ [ScmComplex x]    = Right $ ScmReal (f x)+scmComplexPart _ g _ [x] | isNumeric x = g x+scmComplexPart _ _ s [_]               = notNum s+scmComplexPart _ _ s []                = tooFewArgs s+scmComplexPart _ _ s _                 = tooManyArgs s++---- exact->inexact inexact->exact++scmToInexact, scmToExact :: [ScmValue] -> ErrOr ScmValue+scmToInexact [ScmInt x]         = Right $ ScmReal (fromInteger  x)+scmToInexact [ScmRat x]         = Right $ ScmReal (fromRational x)+scmToInexact [x] | isNumeric x  = Right x+scmToInexact [_]                = notNum      "exact->inexact"+scmToInexact []                 = tooFewArgs  "exact->inexact"+scmToInexact _                  = tooManyArgs "exact->inexact"++scmToExact [ScmReal    x]     =+   let r = toRational x+    in Right $ if denominator r == 1+                  then ScmInt (numerator r)+                  else ScmRat r+scmToExact [ScmComplex x]     =+   case imagPart x of+        0 -> Right $ ScmReal (realPart x)+        _ -> fail $ "inexact->exact :: implementation restriction: " +++                    "can't exactify complex numbers"+scmToExact [x] | isNumeric x  = Right x+scmToExact [_]                = notNum      "exact->inexact"+scmToExact []                 = tooFewArgs  "exact->inexact"+scmToExact _                  = tooManyArgs "exact->inexact"++---- number->string string->number++scmToString, scmToNumber :: [ScmValue] -> IO (ErrOr ScmValue)++-- TODO: scmShow should use this or vice versa+scmToString (x:xs) | isNumeric x =+   case xs of+        []             -> g x 10+        [ScmInt radix] ->+           if radix `elem` [2,8,10,16]+              then g x (fromInteger radix)+              else return. fail $+                      "number->string :: invalid radix " ++ show radix++        [_] -> return$ notInt      "number->string"+        _   -> return$ tooManyArgs "number->string"+ where+   g n radix = case f n radix of+                    Left  err -> return$ fail err+                    Right s   -> fmap Right $ toScmMString s++   f (ScmInt i) radix = Right $ showInt radix i+   f (ScmRat r) radix = Right $+      if denominator r == 1+         then showInt radix (numerator r)+         else concat [ showInt radix (numerator r)+                     , "/"+                     , showInt radix (denominator r) ]++   f (ScmReal r) radix =+      if radix == 10+         then Right $+                 case () of+                      _| isNaN      r -> "+nan.#"+                       | isInfinite r -> (if r < 0 then '-' else '+') : "inf.#"++                       -- R5RS 6.2.6 specifies that "the result contains a+                       -- decimal point" if inexact and a decimal-point+                       -- containing result can make it work+                       | otherwise    -> show r+         else fail "number->string :: nondecimal radix for inexact real"++   f (ScmComplex (a :+ b)) radix =+      -- As in the ScmReal case+      if radix == 10+         then Right . concat $ let bs = either undefined id $ f (ScmReal b) 10+                                in [ either undefined id $ f (ScmReal a) 10+                                   , if head bs `elem` "-+" then [] else "+"+                                   , bs+                                   , "i" ]++         else fail "number->string :: nondecimal radix for inexact complex"++   f _ _ = error "number->string :: the impossible happened"++   showInt radix i = showSigned (showIntAtBase radix intToDigit) 0 i ""++scmToString [] = return$ tooFewArgs "number->string"+scmToString _  = return$ notNum     "number->string"++scmToNumber (ScmString  s : xs) = return$ toNumHelper xs     (elems s)+scmToNumber (ScmMString s : xs) = fmap   (toNumHelper xs) (getElems s)+scmToNumber [] = return$ tooFewArgs "string->number"+scmToNumber _  = return$ fail "Nonstring argument to string->number"++toNumHelper :: [ScmValue] -> String -> ErrOr ScmValue+toNumHelper xs s =+   case xs of+        []             -> Right $ f s 10+        [ScmInt radix] ->+           if radix `elem` [2,8,10,16]+              then Right $ f s (fromInteger radix)+              else fail $ "string->number :: invalid radix " ++ show radix++        [_]            -> notInt       "string->number"+        _              -> tooManyArgs  "string->number"+ where+   f str radix =+       case Parser.runParser (Parser.number radix) "" str of+            Right n | isNumeric n -> n+            _                     -> ScmBool False++-------------++notNum, notReal, notRat :: String -> ErrOr a+notNum  = fail . ("Nonnumeric argument to " ++)+notReal = fail . ("Nonreal argument to " ++)+notRat  = fail . ("Nonrational argument to " ++)++isNumeric, isInteger, isReal :: ScmValue -> Bool+isNumeric (ScmInt     _) = True+isNumeric (ScmRat     _) = True+isNumeric (ScmReal    _) = True+isNumeric (ScmComplex _) = True+isNumeric _              = False++isInteger (ScmInt     _)      = True+isInteger (ScmRat     x)      = denominator x == 1+isInteger (ScmReal    x)      = x == fromInteger (round x)+isInteger (ScmComplex (a:+b)) = b == 0 && a == fromInteger (round a)+isInteger _                   = False++isReal (ScmComplex (_ :+ b)) = b == 0+isReal x                     = isNumeric x++asInt :: String -> ScmValue -> ErrOr (Bool, Integer)+asInt s x | not (isInteger x) = notInt s+asInt _ (ScmInt     x)        = Right (True,  x)+asInt _ (ScmRat     x)        = Right (True,  numerator x)+asInt _ (ScmReal    x)        = Right (False, round x)+asInt _ (ScmComplex (x:+0))   = Right (False, round x)+asInt _ _                     = error "This can't happen"++fromComplex :: Complex Double -> ScmValue+fromComplex (x :+ 0) = ScmReal x+fromComplex x        = ScmComplex x++-- Lift ScmValue's numeric types to a common type+--+-- Versions without 'A' at the end also return results in the correct+-- constructor of the two given. Versions with 'B' just return whether the+-- result should be exact or not.+--+-- Ugly and verbose... too lazy to metaize these {{{++--- Num+liftScmNum :: (forall a. Num a => a -> a) -> ScmValue -> ErrOr ScmValue+liftScmNum f (ScmInt     a) = Right . ScmInt     $ f a+liftScmNum f (ScmRat     a) = Right . ScmRat     $ f a+liftScmNum f (ScmReal    a) = Right . ScmReal    $ f a+liftScmNum f (ScmComplex a) = Right . ScmComplex $ f a+liftScmNum _ _ = fail "liftScmNum :: internal error"++liftScmNum2 :: (forall a. Num a => a -> a -> a)+            -> (ScmValue -> ScmValue -> ErrOr ScmValue)+liftScmNum2 f (ScmInt     a) (ScmInt     b) = Right . ScmInt    $ f a b+liftScmNum2 f (ScmRat     a) (ScmRat     b) = Right . ScmRat    $ f a b+liftScmNum2 f (ScmReal    a) (ScmReal    b) = Right . ScmReal   $ f a b+liftScmNum2 f (ScmComplex a) (ScmComplex b) = Right . ScmComplex$ f a b++-- Int+{Rat,Real,Complex}+liftScmNum2 f (ScmInt     a) (ScmRat     b) = Right . ScmRat    $ f (fInt a) b+liftScmNum2 f (ScmRat     a) (ScmInt     b) = Right . ScmRat    $ f a (fInt b)+liftScmNum2 f (ScmInt     a) (ScmReal    b) = Right . ScmReal   $ f (fInt a) b+liftScmNum2 f (ScmReal    a) (ScmInt     b) = Right . ScmReal   $ f a (fInt b)+liftScmNum2 f (ScmInt     a) (ScmComplex b) = Right . ScmComplex$ f (fInt a) b+liftScmNum2 f (ScmComplex a) (ScmInt     b) = Right . ScmComplex$ f a (fInt b)++-- Rat+{Real,Complex}+liftScmNum2 f (ScmRat     a) (ScmReal    b) = Right . ScmReal   $ f (fRat a) b+liftScmNum2 f (ScmReal    a) (ScmRat     b) = Right . ScmReal   $ f a (fRat b)+liftScmNum2 f (ScmRat     a) (ScmComplex b) = Right . ScmComplex$ f (fRat a) b+liftScmNum2 f (ScmComplex a) (ScmRat     b) = Right . ScmComplex$ f a (fRat b)++-- Real+Complex+liftScmNum2 f (ScmReal    a) (ScmComplex b) = Right . ScmComplex$ f (a :+ 0) b+liftScmNum2 f (ScmComplex a) (ScmReal    b) = Right . ScmComplex$ f a (b :+ 0)++liftScmNum2 _ _ _ = fail "liftScmNum2 :: internal error"++--- Frac+liftScmFrac :: (forall a. Fractional a => a -> a) -> ScmValue -> ErrOr ScmValue+liftScmFrac f (ScmRat     a) = Right . ScmRat     $ f a+liftScmFrac f (ScmReal    a) = Right . ScmReal    $ f a+liftScmFrac f (ScmComplex a) = Right . ScmComplex $ f a+liftScmFrac _ _ = fail "liftScmFrac :: internal error"++liftScmFrac2 :: (forall a. Fractional a => a -> a -> a)+             -> (ScmValue -> ScmValue -> ErrOr ScmValue)+liftScmFrac2 f (ScmRat     a) (ScmRat     b) = Right . ScmRat    $ f a b+liftScmFrac2 f (ScmReal    a) (ScmReal    b) = Right . ScmReal   $ f a b+liftScmFrac2 f (ScmComplex a) (ScmComplex b) = Right . ScmComplex$ f a b++-- Rat+{Real,Complex}+liftScmFrac2 f (ScmRat     a) (ScmReal    b) = Right . ScmReal   $ f (fRat a) b+liftScmFrac2 f (ScmReal    a) (ScmRat     b) = Right . ScmReal   $ f a (fRat b)+liftScmFrac2 f (ScmRat     a) (ScmComplex b) = Right . ScmComplex$ f (fRat a) b+liftScmFrac2 f (ScmComplex a) (ScmRat     b) = Right . ScmComplex$ f a (fRat b)++-- Real+Complex+liftScmFrac2 f (ScmReal    a) (ScmComplex b) = Right . ScmComplex$ f (a :+ 0) b+liftScmFrac2 f (ScmComplex a) (ScmReal    b) = Right . ScmComplex$ f a (b :+ 0)++liftScmFrac2 _ _ _ = fail "liftScmFrac2 :: internal error"++--- Real+liftScmReal2 :: (forall a. Real a => a -> a -> a)+             -> (ScmValue -> ScmValue -> ErrOr ScmValue)+liftScmReal2 f x y =+   case pairScmReal x y of+        Right (ScmReal a, ScmReal b) -> Right . ScmReal $ f a b+        Right (ScmRat  a, ScmRat  b) -> Right . ScmRat  $ f a b+        Right (ScmInt  a, ScmInt  b) -> Right . ScmInt  $ f a b+        Left s                       -> Left s+        Right _                      -> fail "liftScmReal2 :: internal error"++liftScmRealA2 :: (forall a. Real a => a -> a -> b)+              -> (ScmValue -> ScmValue -> ErrOr b)+liftScmRealA2 f x y =+   case pairScmReal x y of+        Right (ScmReal a, ScmReal b) -> Right $ f a b+        Right (ScmRat  a, ScmRat  b) -> Right $ f a b+        Right (ScmInt  a, ScmInt  b) -> Right $ f a b+        Left s                       -> Left s+        Right _                      -> fail "liftScmRealA2 :: internal error"++--- RealFrac+liftScmRealFracB2 :: (forall a. RealFrac a => a -> a -> b)+                  -> (ScmValue -> ScmValue -> ErrOr (Bool, b))+liftScmRealFracB2 f x y =+   case pairScmReal x y of+        Right (ScmReal a, ScmReal b) -> Right (False, f a b)+        Right (ScmRat  a, ScmRat  b) -> Right (True,  f a b)+        Right (ScmInt  a, ScmInt  b) ->+           Right (True,  f (fInt a) (fInt b :: Rational))+        Left s                       -> Left s+        Right _                      ->+           fail "liftScmRealFracB2 :: internal error"++pairScmReal :: ScmValue -> ScmValue -> ErrOr (ScmValue, ScmValue)+pairScmReal (ScmComplex a) _ | imagPart a /= 0 = fail "pairScmReal :: complex"+pairScmReal _ (ScmComplex b) | imagPart b /= 0 = fail "pairScmReal :: complex"++pairScmReal a@(ScmInt     _) b@(ScmInt     _) = Right (a,b)+pairScmReal a@(ScmRat     _) b@(ScmRat     _) = Right (a,b)+pairScmReal a@(ScmReal    _) b@(ScmReal    _) = Right (a,b)+pairScmReal   (ScmComplex a)   (ScmComplex b) =+   Right $ ((,) `on` ScmReal . realPart) a b++-- Int+{Rat,Real,Complex}+pairScmReal (ScmInt     a) (ScmRat     b) = Right $ ((,)`on`ScmRat)  (fInt a) b+pairScmReal (ScmRat     a) (ScmInt     b) = Right $ ((,)`on`ScmRat)  a (fInt b)+pairScmReal (ScmInt     a) (ScmReal    b) = Right $ ((,)`on`ScmReal) (fInt a) b+pairScmReal (ScmReal    a) (ScmInt     b) = Right $ ((,)`on`ScmReal) a (fInt b)+pairScmReal (ScmInt     a) (ScmComplex b) =+   Right $ ((,)`on`ScmReal) (fInt a) (realPart b)+pairScmReal (ScmComplex a) (ScmInt     b) =+   Right $ ((,)`on`ScmReal) (realPart a) (fInt b)++-- Rat+{Real,Complex}+pairScmReal (ScmRat     a) (ScmReal    b) = Right $ ((,)`on`ScmReal) (fRat a) b+pairScmReal (ScmReal    a) (ScmRat     b) = Right $ ((,)`on`ScmReal) a (fRat b)+pairScmReal (ScmRat     a) (ScmComplex b) =+   Right $ ((,)`on`ScmReal) (fRat a) (realPart b)+pairScmReal (ScmComplex a) (ScmRat     b) =+   Right $ ((,)`on`ScmReal) (realPart a) (fRat b)++-- Real+Complex+pairScmReal (ScmReal    a) (ScmComplex b) =+   Right $ ((,)`on`ScmReal) a (realPart b)+pairScmReal (ScmComplex a) (ScmReal    b) =+   Right $ ((,)`on`ScmReal) (realPart a) b++pairScmReal _ _ = fail "pairScmReal :: internal error"++pairScmComplex :: ScmValue -> ScmValue -> ErrOr (ScmValue, ScmValue)+pairScmComplex a@(ScmInt     _) b@(ScmInt     _) = Right (a,b)+pairScmComplex a@(ScmRat     _) b@(ScmRat     _) = Right (a,b)+pairScmComplex a@(ScmReal    _) b@(ScmReal    _) = Right (a,b)+pairScmComplex a@(ScmComplex _) b@(ScmComplex _) = Right (a,b)++-- Int+{Rat,Real,Complex}+pairScmComplex (ScmInt     a) (ScmRat     b) = Right$((,)`on`ScmRat) (fInt a) b+pairScmComplex (ScmRat     a) (ScmInt     b) = Right$((,)`on`ScmRat) a (fInt b)+pairScmComplex (ScmInt     a) (ScmReal    b) =+   Right $ ((,)`on`ScmReal) (fInt a) b+pairScmComplex (ScmReal    a) (ScmInt     b) =+   Right $ ((,)`on`ScmReal) a (fInt b)+pairScmComplex (ScmInt     a) (ScmComplex b) =+   Right $ ((,)`on`ScmComplex) (fInt a) b+pairScmComplex (ScmComplex a) (ScmInt     b) =+   Right $ ((,)`on`ScmComplex) a (fInt b)++-- Rat+{Real,Complex}+pairScmComplex (ScmRat     a) (ScmReal    b) =+   Right $ ((,)`on`ScmReal) (fRat a) b+pairScmComplex (ScmReal    a) (ScmRat     b) =+   Right $ ((,)`on`ScmReal) a (fRat b)+pairScmComplex (ScmRat     a) (ScmComplex b) =+   Right $ ((,)`on`ScmComplex) (fRat a) b+pairScmComplex (ScmComplex a) (ScmRat     b) =+   Right $ ((,)`on`ScmComplex) a (fRat b)++-- Real+Complex+pairScmComplex (ScmReal    a) (ScmComplex b) =+   Right $ ((,)`on`ScmComplex) (a:+0) b+pairScmComplex (ScmComplex a) (ScmReal    b) =+   Right $ ((,)`on`ScmComplex) a (b:+0)++pairScmComplex _ _ = fail "pairScmComplex :: internal error"++fInt :: Num a => Integer -> a+fInt = fromInteger++fRat :: Fractional a => Rational -> a+fRat = fromRational++-- }}}
+ Haschoo/Evaluator/Standard/PairsLists.hs view
@@ -0,0 +1,331 @@+-- File created: 2009-07-21 22:13:29++module Haschoo.Evaluator.Standard.PairsLists (procedures, scmAppend) where++import Control.Applicative ((<$>))+import Control.Arrow       ((&&&))+import Control.Monad       (join, replicateM, (>=>))+import Control.Monad.Loops (dropWhileM, firstM)+import Data.Foldable       (foldrM)+import Data.IORef          (IORef, newIORef, readIORef, writeIORef)+import Data.List           (genericDrop)+import Data.Maybe          (fromMaybe)++import Haschoo.Types                          ( ScmValue(..)+                                              , pairToList, listToPair)+import Haschoo.Utils                          (ErrOr, ($<), ptrEq)+import Haschoo.Evaluator.Utils                (tooFewArgs,tooManyArgs, notList)+import Haschoo.Evaluator.Standard.Equivalence (scmEq, scmEqv, scmEqual)+import Haschoo.Evaluator.Standard.Numeric     (asInt)++procedures :: [(String, ScmValue)]+procedures = map (\(a,b) -> (a, ScmFunc a b)) $+   [ ("pair?", return . fmap ScmBool . scmIsPair)+   , ("cons",  scmCons)+   , "car" $< id &&& scmCar+   , "cdr" $< id &&& scmCdr+   , ("set-car!", scmSetCar)+   , ("set-cdr!", scmSetCdr) ]++   ++ carCdrCompositions ++++   [ ("null?",    return . fmap ScmBool . scmIsNull)+   , ("list?",    fmap (fmap ScmBool) . scmIsList)+   , ("list",     fmap Right . scmList)+   , ("length",   scmLength)+   , ("append",   scmAppend)+   , ("reverse",  scmReverse)+   , ("list-ref", scmListRef)+   , ("memq",     scmMemq)+   , ("memv",     scmMemv)+   , ("member",   scmMember)+   , ("assq",     scmAssq)+   , ("assv",     scmAssv)+   , ("assoc",    scmAssoc) ]++---- Pairs++--- pair?++scmIsPair :: [ScmValue] -> ErrOr Bool+scmIsPair [ScmPair _ _]       = Right True+scmIsPair [ScmList (_:_)]     = Right True+scmIsPair [ScmDottedList _ _] = Right True+scmIsPair [_]                 = Right False+scmIsPair []                  = tooFewArgs  "pair?"+scmIsPair _                   = tooManyArgs "pair?"++--- cons++scmCons :: [ScmValue] -> IO (ErrOr ScmValue)+scmCons [a, b]  = do+   x <- newIORef a+   y <- newIORef b+   return.Right $ ScmPair x y+scmCons (_:_:_) = return$ tooManyArgs "cons"+scmCons _       = return$ tooFewArgs  "cons"++--- car cdr++scmCar, scmCdr :: String -> [ScmValue] -> IO (ErrOr ScmValue)+scmCar _ [ScmPair a _]           = return . Right =<< readIORef a+scmCar _ [ScmList (a:_)]         = return . Right $ a+scmCar _ [ScmDottedList (a:_) _] = return . Right $ a+scmCar s [ScmList []]            = return . fail $ s ++ " :: empty list"+scmCar s [_]                     = return$ notPair s+scmCar s []                      = return$ tooFewArgs  s+scmCar s _                       = return$ tooManyArgs s++scmCdr _ [ScmPair _ b]           = return . Right =<< readIORef b+scmCdr _ [ScmList (_:bs)]        = return . Right $ ScmList bs+scmCdr _ [ScmDottedList [_]   b] = return . Right $ b+scmCdr _ [ScmDottedList (_:a) b] = return . Right $ ScmDottedList a b+scmCdr s [ScmList []]            = return . fail $ s ++ " :: empty list"+scmCdr s [_]                     = return$ notPair s+scmCdr s []                      = return$ tooFewArgs  s+scmCdr s _                       = return$ tooManyArgs s++--- set-car! set-cdr!++scmSetCar, scmSetCdr :: [ScmValue] -> IO (ErrOr ScmValue)+scmSetCar = scmSet (const . writeIORef) "set-car!"+scmSetCdr = scmSet (const   writeIORef) "set-cdr!"++scmSet :: (IORef ScmValue -> IORef ScmValue -> ScmValue -> IO ()) -> String+       -> [ScmValue] -> IO (ErrOr ScmValue)++scmSet f _ [ScmPair a b, v]       = f a b v >> return (Right ScmVoid)+scmSet _ s [ScmList _, _]         = return$ immutable   s+scmSet _ s [ScmDottedList _ _, _] = return$ immutable   s+scmSet _ s [_,_]                  = return$ notPair     s+scmSet _ s (_:_:_)                = return$ tooManyArgs s+scmSet _ s _                      = return$ tooFewArgs  s++--- caar cadr ... cddddr++carCdrCompositions :: [(String, [ScmValue] -> IO (ErrOr ScmValue))]+carCdrCompositions = map (name &&& join func)+                         (concatMap (flip replicateM "ad") [2..depth])+ where+   -- R5RS 6.3.2+   depth = 4++   name a = concat ["c",a,"r"]++   func :: String -> String -> [ScmValue] -> IO (ErrOr ScmValue)+   func _ []       = return . Right . head+   func s ('a':xs) = func s xs >=> next s scmCar+   func s ('d':xs) = func s xs >=> next s scmCdr+   func s _        = error (name s ++ " :: the impossible happened!")++   next _ _ x@(Left _) = return x+   next s f  (Right v) = f (name s) [v]++---- Lists++--- null? list?++scmIsNull :: [ScmValue] -> ErrOr Bool+scmIsNull [ScmList []] = Right True+scmIsNull [_]          = Right False+scmIsNull []           = tooFewArgs  "null?"+scmIsNull _            = tooManyArgs "null?"++scmIsList :: [ScmValue] -> IO (ErrOr Bool)+scmIsList [ScmList _]   = return$ Right True+scmIsList [ScmPair _ b] = Right <$> (readIORef b >>= join go)+ where+   go (ScmPair _ sn) fast@(ScmPair _ fn) = do+      fn' <- readIORef fn+      case fn' of+           ScmPair _ fn2 -> do+              eq <- ptrEq fast fn'+              if eq+                 then return False -- Cycle+                 else do+                    fn2' <- readIORef fn2+                    case fn2' of+                         ScmPair _ _ -> readIORef sn >>= flip go fn2'+                         ScmList _   -> return True+                         _           -> return False+           ScmList _ -> return True+           _         -> return False++   go _ (ScmList _) = return True+   go _ _           = return False++scmIsList [_]           = return$ Right False+scmIsList []            = return$ tooFewArgs  "list?"+scmIsList _             = return$ tooManyArgs "list?"++--- list++scmList :: [ScmValue] -> IO ScmValue+scmList []     = return (ScmList [])+scmList (x:xs) = do+   ys <- scmList xs+   y  <- newIORef x+   z  <- newIORef ys+   return (ScmPair y z)++--- length++scmLength :: [ScmValue] -> IO (ErrOr ScmValue)+scmLength [ScmPair _ p] = readIORef p >>= go 1+ where+   go n _ | n `seq` False = undefined+   go n (ScmList [])  = return . Right . ScmInt . toInteger $ (n :: Int)+   go n (ScmPair _ b) = readIORef b >>= go (n+1)+   go _ _             = return$ notList "length"++scmLength [ScmList xs]  = return . Right . ScmInt . toInteger $ length xs+scmLength [_]           = return$ notList     "length"+scmLength []            = return$ tooFewArgs  "length"+scmLength _             = return$ tooManyArgs "length"++--- append++scmAppend :: [ScmValue] -> IO (ErrOr ScmValue)+scmAppend []   = Right . fst <$> listToPair []+scmAppend args = foldrM fold (Left "") args+ where+   -- The last argument is allowed to be a nonlist: this is a bit of a hack to+   -- catch that case+   --+   -- If we were to just match on ScmList [] in f, we'd allow an arbitrary+   -- number of '() to follow the final argument+   fold x (Left "") = return (Right x)++   fold _ err@(Left _) = return err+   fold a (Right b)    = f a b++   f (p@(ScmPair _ _)) rhs = next rhs p+   f (ScmList xs)      rhs = do+      (xs', fin) <- listToPair xs+      case fin of+           Nothing -> return . Right $ rhs+           Just p  -> do+              writeIORef p rhs+              return . Right $ xs'++   f _ _ = return$ notList "append"++   -- Builds up the list as we iterate through it+   next rhs (ScmPair a b) = do+      b' <- go rhs =<< readIORef b+      case b' of+           Left  _ -> return b'+           Right y -> do+              newA <- newIORef =<< readIORef a+              newB <- newIORef y+              return . Right $ ScmPair newA newB++   next _ _ = error "append :: the impossible happened"++   go rhs x@(ScmPair _ _) = next rhs x+   go rhs x@(ScmList _)   = f x rhs+   go _   _               = return$ notList "append"++--- reverse++scmReverse :: [ScmValue] -> IO (ErrOr ScmValue)+scmReverse [ScmList xs]      = fmap (Right . fst) . listToPair $ reverse xs+scmReverse [x@(ScmPair _ _)] = do+   x' <- pairToList x+   case x' of+        Right (ScmList l) -> fmap (Right . fst) . listToPair $ reverse l+        Left _            -> return $ notList "reverse"+        Right _           -> error "reverse :: the impossible happened"+scmReverse [_]               = return$ notList     "reverse"+scmReverse []                = return$ tooFewArgs  "reverse"+scmReverse _                 = return$ tooManyArgs "reverse"++--- list-ref++scmListRef :: [ScmValue] -> IO (ErrOr ScmValue)+scmListRef [x, n] =+   case fmap snd $ asInt "list-ref" n of+        Right i -> f x i+        Left  s -> return (Left s)+ where+   f (ScmList xs)  i = return$ case genericDrop i xs of+                                    []  -> fail "list-ref :: overlarge index"+                                    v:_ -> Right v++   f (ScmPair a _) 0 = Right <$> readIORef a+   f (ScmPair _ b) i = readIORef b >>= flip f (i-1)+   f _             _ = return$ notList "list-ref"++scmListRef (_:_:_) = return$ tooManyArgs "list-ref"+scmListRef _       = return$ tooFewArgs  "list-ref"++--- memq memv member++scmMemq, scmMemv, scmMember :: [ScmValue] -> IO (ErrOr ScmValue)+scmMemq   = scmFind scmEq    "memq"+scmMemv   = scmFind scmEqv   "memv"+scmMember = scmFind scmEqual "member"++scmFind :: (ScmValue -> ScmValue -> IO Bool) -> String+        -> [ScmValue] -> IO (ErrOr ScmValue)+scmFind p s [obj, list] =+   case list of+        ScmList _   -> go list+        ScmPair _ _ -> go list+        _           -> return$ notList s+ where+   go (ScmList xs) = do+      ys <- dropWhileM (fmap not . p obj) xs+      return.Right $ if null ys+                        then ScmBool False+                        else ScmList ys++   go x@(ScmPair a b) = do+      found <- p obj =<< readIORef a+      if found+         then return . Right $ x+         else readIORef b >>= go++   go _ = return$ notList s++scmFind _ s (_:_:_) = return$ tooManyArgs s+scmFind _ s _       = return$ tooFewArgs  s++--- assq assv assoc++scmAssq, scmAssv, scmAssoc :: [ScmValue] -> IO (ErrOr ScmValue)+scmAssq  = scmLookup scmEq    "assq"+scmAssv  = scmLookup scmEqv   "assv"+scmAssoc = scmLookup scmEqual "assoc"++scmLookup :: (ScmValue -> ScmValue -> IO Bool) -> String+          -> [ScmValue] -> IO (ErrOr ScmValue)+scmLookup p s [obj, list] =+   case list of+        ScmList _   -> go list+        ScmPair _ _ -> go list+        _           -> return$ notList s+ where+   go (ScmList xs) = Right . fromMaybe (ScmBool False) <$> firstM match xs+   go (ScmPair a b) = do+      a'    <- readIORef a+      found <- match a'+      if found+         then return . Right $ a'+         else readIORef b >>= go++   go _ = return$ notList s++   match (ScmPair a _)           = p obj =<< readIORef a+   match (ScmDottedList (a:_) _) = p obj a+   match (ScmList (a:_))         = p obj a+   match _                       = return False++scmLookup _ s (_:_:_) = return$ tooManyArgs s+scmLookup _ s _       = return$ tooFewArgs  s++---- Utils++immutable, notPair :: String -> ErrOr a+immutable = fail . ("Immutable argument to " ++)+notPair   = fail . ("Nonpair argument to " ++)
+ Haschoo/Evaluator/Standard/Strings.hs view
@@ -0,0 +1,256 @@+-- File created: 2009-08-05 20:14:14++module Haschoo.Evaluator.Standard.Strings (procedures, isString, strToList)+ where++import Control.Applicative ((<$>))+import Control.Arrow       ((&&&))+import Control.Monad       (join, liftM2)+import Data.Array.IArray   ((!), bounds, elems)+import Data.Array.IO       (IOUArray)+import Data.Array.MArray   ( readArray, writeArray+                           , newArray, newListArray+                           , getBounds, getElems+                           , freeze, thaw, unsafeFreeze, unsafeThaw)+import Data.Array.Unboxed  (UArray)+import Data.Char           (isLetter, toLower)+import Data.Foldable       (foldrM)+import Data.Function       (on)++import Haschoo.Types           ( ScmValue(..), toScmMString+                               , listToPair, pairToList)+import Haschoo.Utils           (ErrOr, ($<), (.:), mapOnPairs)+import Haschoo.Evaluator.Utils ( tooFewArgs, tooManyArgs, immutable+                               , notChar, notInt, notList, notString)++procedures :: [(String, ScmValue)]+procedures = map (\(a,b) -> (a, ScmFunc a b))+   [ ("string?", return . fmap ScmBool . scmIsString)++   , ("make-string", scmMakeString)+   , ("string",      scmString)++   , ("string-length", scmLength)++   , ("string-ref",  scmRef)+   , ("string-set!", scmSet)++   , "string=?"  $< id &&& fmap (fmap ScmBool) .: scmCompare (==) (,)+   , "string<?"  $< id &&& fmap (fmap ScmBool) .: scmCompare (<)  (,)+   , "string>?"  $< id &&& fmap (fmap ScmBool) .: scmCompare (>)  (,)+   , "string<=?" $< id &&& fmap (fmap ScmBool) .: scmCompare (<=) (,)+   , "string>=?" $< id &&& fmap (fmap ScmBool) .: scmCompare (>=) (,)++   , "string-ci=?"  $< id &&& fmap (fmap ScmBool) .: scmCompare (==) lower+   , "string-ci<?"  $< id &&& fmap (fmap ScmBool) .: scmCompare (<)  lower+   , "string-ci>?"  $< id &&& fmap (fmap ScmBool) .: scmCompare (>)  lower+   , "string-ci<=?" $< id &&& fmap (fmap ScmBool) .: scmCompare (<=) lower+   , "string-ci>=?" $< id &&& fmap (fmap ScmBool) .: scmCompare (>=) lower++   , ("substring", scmSubstring)++   , ("string-append", scmAppend)++   , ("string->list", scmToList)+   , ("list->string", scmFromList)++   , ("string-copy",  scmCopy)+   , ("string-fill!", scmFill)+   ]+ where+   lower a b = if isLetter a && isLetter b+                  then (toLower a, toLower b)+                  else (a,b)++scmIsString :: [ScmValue] -> ErrOr Bool+scmIsString [x] = Right (isString x)+scmIsString []  = tooFewArgs  "string?"+scmIsString _   = tooManyArgs "string?"++scmMakeString, scmString :: [ScmValue] -> IO (ErrOr ScmValue)+scmMakeString (ScmInt l : xs) =+   case xs of+        []          -> f (flip newArray '*')+        [ScmChar c] -> f (flip newArray c)+        [_]         -> return$ notChar     "make-string"+        _           -> return$ tooManyArgs "make-string"+ where+   f mk = tryToLen "make-string" l $ \i -> ScmMString <$> mk (0, i-1)++scmMakeString [_, ScmChar _] = return$ notInt      "make-string"+scmMakeString (_:_:_:_)      = return$ tooManyArgs "make-string"+scmMakeString []             = return$ tooFewArgs  "make-string"+scmMakeString _              = return$ notChar     "make-string"++scmString xs = case mapM (fromChar "string") xs of+                    Left  e -> return$ Left e+                    Right s -> fmap Right $ toScmMString s++scmLength :: [ScmValue] -> IO (ErrOr ScmValue)+scmLength [x] = case x of+                     ScmString  s -> Right . ScmInt . toInteger <$>  sLen s+                     ScmMString s -> Right . ScmInt . toInteger <$> msLen s+                     _            -> return$ notString "string-length"++scmLength [] = return$ tooFewArgs  "string-length"+scmLength _  = return$ tooManyArgs "string-length"++scmRef, scmSet :: [ScmValue] -> IO (ErrOr ScmValue)+scmRef [x, ScmInt i] = case x of+                            ScmString  s -> f (sLen  s) (return . (s!))+                            ScmMString s -> f (msLen s) (readArray s)+                            _            -> return$ notString "string-ref"+ where+   f len = fmap (fmap ScmChar) . tryToIdx "string-ref" len i++scmRef [_,_]   = return$ notInt      "string-ref"+scmRef (_:_:_) = return$ tooManyArgs "string-ref"+scmRef _       = return$ tooFewArgs  "string-ref"++scmSet [x, ScmInt idx, ScmChar c] =+   case x of+        ScmMString s -> do+           tryToIdx "string-set!" (msLen s) idx (\i -> writeArray s i c)+           return (Right ScmVoid)++        ScmString  _ -> return$ immutable "string-set!"+        _            -> return$ notString "string-set!"++scmSet [_, _, ScmChar _] = return$ notInt      "string-set!"+scmSet [_, _, _]         = return$ notChar     "string-set!"+scmSet (_:_:_:_)         = return$ tooManyArgs "string-set!"+scmSet _                 = return$ tooFewArgs  "string-set!"++scmCompare :: (String -> String -> Bool)+           -> (Char -> Char -> (Char, Char))+           -> String+           -> [ScmValue] -> IO (ErrOr Bool)+scmCompare p f s [a, b] =+   if isString a && isString b+      then Right <$> (liftM2 (uncurry p .: mapOnPairs f `on` elems) `on` conv)+                     a b+      else return$ notString s+ where+   conv (ScmString  x) = return x+   conv (ScmMString x) = unsafeFreeze x+   conv _              = error $ s ++ " :: the impossible happpened"+scmCompare _ _ s (_:_:_) = return$ tooManyArgs s+scmCompare _ _ s _       = return$ tooFewArgs  s++scmSubstring :: [ScmValue] -> IO (ErrOr ScmValue)+scmSubstring [x, ScmInt a, ScmInt b] =+   case x of+        ScmMString s -> f (msLen s) (getElems s)+        ScmString  s -> f (sLen s) (return $ elems s)+        _            -> return$ notString "substring"+ where+   f mlen els = mlen >>= \len ->+      fmap join $+      tryRange 0 (toInteger len) "substring" b $ \b' ->+      tryRange 0 (toInteger b')  "substring" a $ \a' ->+      fmap ScmMString $ els >>= newListArray (0, b'-a'-1) . drop a'++scmSubstring [_, _, _] = return$ notInt      "substring"+scmSubstring (_:_:_:_) = return$ tooManyArgs "substring"+scmSubstring _         = return$ tooFewArgs  "substring"++scmAppend :: [ScmValue] -> IO (ErrOr ScmValue)+scmAppend args = do+   x <- foldrM f (Right (0, "")) args+   case x of+        Left  err        -> return (Left err)+        Right (len, cat) -> Right . ScmMString <$> newListArray (0, len-1) cat+ where+   f (ScmString  a) (Right x)  = make  (sLen a) (return $ elems a) x+   f (ScmMString a) (Right x)  = make (msLen a) (getElems a)       x+   f _              (Left err) = return (Left err)+   f _              _          = return$ notString "string-append"++   make ml me (n,s) = ml >>= \l -> me >>= \e -> return.Right $ (n+l, e++s)++scmToList, scmFromList :: [ScmValue] -> IO (ErrOr ScmValue)+scmToList [x] | isString x =+   fmap (Right . fst) . listToPair . map ScmChar =<< strToList x++scmToList [_] = return$ notString   "string->list"+scmToList []  = return$ tooFewArgs  "string->list"+scmToList _   = return$ tooManyArgs "string->list"++scmFromList [x] =+   case x of+        ScmList l       -> f l+        p@(ScmPair _ _) -> do+           l <- pairToList p+           case l of+                Left _             -> return$ notList "list->string"+                Right (ScmList l') -> f l'++                _ -> error "list->string :: the impossible happened"++        _ -> return$ notList "list->string"+ where+   f l = case mapM (fromChar "list->string") l of+              Left  e -> return$ Left e+              Right s -> Right <$> toScmMString s++scmFromList [] = return$ tooFewArgs  "list->string"+scmFromList _  = return$ tooManyArgs "list->string"++scmCopy :: [ScmValue] -> IO (ErrOr ScmValue)+scmCopy [ScmString  s] = Right . ScmMString <$> thaw s+scmCopy [ScmMString s] =+   Right . ScmMString <$>+      (freeze s >>= \a -> unsafeThaw (a :: UArray Int Char))++scmCopy [_] = return$ notString   "string-copy"+scmCopy []  = return$ tooFewArgs  "string-copy"+scmCopy _   = return$ tooManyArgs "string-copy"++scmFill :: [ScmValue] -> IO (ErrOr ScmValue)+scmFill [x, ScmChar c] =+   case x of+        ScmMString s -> do+           (a,b) <- getBounds s+           mapM_ (\i -> writeArray s i c) [a..b]+           return (Right ScmVoid)++        ScmString  _ -> return$ immutable "string-fill!"+        _            -> return$ notString "string-fill!"++scmFill [_, _]  = return$ notChar     "string-fill!"+scmFill (_:_:_) = return$ tooManyArgs "string-fill!"+scmFill _       = return$ tooFewArgs  "string-fill!"++------++isString :: ScmValue -> Bool+isString (ScmString  _) = True+isString (ScmMString _) = True+isString _              = False++strToList :: ScmValue -> IO String+strToList (ScmString  s) = return (elems s)+strToList (ScmMString s) = getElems s+strToList _              = error "strToList :: the impossible happened"++tryToLen :: String -> Integer -> (Int -> IO a) -> IO (ErrOr a)+tryToLen = tryRange 0 (toInteger (maxBound :: Int))++tryToIdx :: String -> IO Int -> Integer -> (Int -> IO a) -> IO (ErrOr a)+tryToIdx s mlen i f = mlen >>= \len -> tryRange 0 (toInteger len - 1) s i f++tryRange :: Integer -> Integer -> String -> Integer -> (Int -> IO a)+         -> IO (ErrOr a)+tryRange a b s i f = if i >= a && i <= b+                        then Right <$> f (fromInteger i)+                        else return.Left $ "Out-of-range integer to " ++ s++fromChar :: String -> ScmValue -> ErrOr Char+fromChar _ (ScmChar c) = Right c+fromChar s _           = notChar s++sLen :: UArray Int Char -> IO Int+sLen = return . (+1) . snd . bounds++msLen :: IOUArray Int Char -> IO Int+msLen = fmap ((+1) . snd) . getBounds
+ Haschoo/Evaluator/Standard/Symbols.hs view
@@ -0,0 +1,39 @@+-- File created: 2009-07-22 20:39:04++module Haschoo.Evaluator.Standard.Symbols (procedures) where++import Data.Array.IArray (elems)+import Data.Array.MArray (getElems)++import Haschoo.Types           (ScmValue(..), toScmString)+import Haschoo.Utils           (ErrOr)+import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs)++procedures :: [(String, ScmValue)]+procedures = map (\(a,b) -> (a, ScmFunc a b))+   [ ("symbol?",        return . fmap ScmBool . scmIsSymbol)+   , ("symbol->string", return . scmToString)+   , ("string->symbol", scmToSymbol)+   ]++scmIsSymbol :: [ScmValue] -> ErrOr Bool+scmIsSymbol [ScmIdentifier _] = Right True+scmIsSymbol [_]               = Right False+scmIsSymbol []                = tooFewArgs  "symbol?"+scmIsSymbol _                 = tooManyArgs "symbol?"++scmToString :: [ScmValue] -> ErrOr ScmValue+scmToString [ScmIdentifier x] = Right (toScmString x)+scmToString [_]               = notSymbol   "symbol->string"+scmToString []                = tooFewArgs  "symbol->string"+scmToString _                 = tooManyArgs "symbol->string"++scmToSymbol :: [ScmValue] -> IO (ErrOr ScmValue)+scmToSymbol [ScmString x]  = return$ Right . ScmIdentifier  $    elems x+scmToSymbol [ScmMString x] = fmap   (Right . ScmIdentifier) $ getElems x+scmToSymbol [_]            = return$ notSymbol   "string->symbol"+scmToSymbol []             = return$ tooFewArgs  "string->symbol"+scmToSymbol _              = return$ tooManyArgs "string->symbol"++notSymbol :: String -> ErrOr a+notSymbol = fail . ("Nonsymbolic argument to " ++)
+ Haschoo/Evaluator/Standard/Vectors.hs view
@@ -0,0 +1,158 @@+-- File created: 2009-08-06 20:47:49++module Haschoo.Evaluator.Standard.Vectors (procedures) where++import Control.Applicative ((<$>))+import Data.Array          (Array)+import Data.Array.IArray   ((!), bounds, elems)+import Data.Array.IO       (IOArray)+import Data.Array.MArray   ( readArray, writeArray+                           , newArray, newListArray+                           , getBounds, getElems)+import Data.Complex        (Complex((:+)))++import Haschoo.Types           (ScmValue(..), listToPair, pairToList)+import Haschoo.Utils           (ErrOr)+import Haschoo.Evaluator.Utils ( tooFewArgs, tooManyArgs, immutable+                               , notInt, notList)++procedures :: [(String, ScmValue)]+procedures = map (\(a,b) -> (a, ScmFunc a b))+   [ ("vector?", return . fmap ScmBool . scmIsVector)++   , ("make-vector", scmMakeVector)+   , ("vector",      scmVector)++   , ("vector-length", scmLength)++   , ("vector-ref",  scmRef)+   , ("vector-set!", scmSet)++   , ("vector->list", scmToList)+   , ("list->vector", scmFromList)++   , ("vector-fill!", scmFill)+   ]++scmIsVector :: [ScmValue] -> ErrOr Bool+scmIsVector [ScmMVector _] = Right True+scmIsVector [ScmVector  _] = Right True+scmIsVector [_]            = Right False+scmIsVector []             = tooFewArgs  "vector?"+scmIsVector _              = tooManyArgs "vector?"++scmMakeVector, scmVector :: [ScmValue] -> IO (ErrOr ScmValue)+scmMakeVector (ScmInt l : xs) =+   case xs of+        []  -> f (flip newArray (ScmComplex $ 0 :+ 42))+        [x] -> f (flip newArray x)+        _   -> return$ tooManyArgs "make-vector"+ where+   f mk = tryToLen "make-vector" l $ \i -> ScmMVector <$> mk (0, i-1)++scmMakeVector (_:_:_:_) = return$ tooManyArgs "make-vector"+scmMakeVector []        = return$ tooFewArgs  "make-vector"+scmMakeVector _         = return$ notInt      "make-vector"++scmVector xs = Right <$> toScmMVector xs++scmLength :: [ScmValue] -> IO (ErrOr ScmValue)+scmLength [x] = case x of+                     ScmVector  s -> Right . ScmInt . toInteger <$>  vLen s+                     ScmMVector s -> Right . ScmInt . toInteger <$> mvLen s+                     _            -> return$ notVector "vector-length"++scmLength [] = return$ tooFewArgs  "vector-length"+scmLength _  = return$ tooManyArgs "vector-length"++scmRef, scmSet :: [ScmValue] -> IO (ErrOr ScmValue)+scmRef [x, ScmInt i] = case x of+                            ScmVector  s -> f (vLen  s) (return . (s!))+                            ScmMVector s -> f (mvLen s) (readArray s)+                            _            -> return$ notVector "vector-ref"+ where+   f len = tryToIdx "vector-ref" len i++scmRef [_,_]   = return$ notInt      "vector-ref"+scmRef (_:_:_) = return$ tooManyArgs "vector-ref"+scmRef _       = return$ tooFewArgs  "vector-ref"++scmSet [v, ScmInt idx, x] =+   case v of+        ScmMVector v' -> do+           tryToIdx "vector-set!" (mvLen v') idx (\i -> writeArray v' i x)+           return (Right ScmVoid)++        ScmVector  _ -> return$ immutable "vector-set!"+        _            -> return$ notVector "vector-set!"++scmSet [_, _, ScmChar _] = return$ notInt      "vector-set!"+scmSet (_:_:_:_)         = return$ tooManyArgs "vector-set!"+scmSet _                 = return$ tooFewArgs  "vector-set!"++scmToList, scmFromList :: [ScmValue] -> IO (ErrOr ScmValue)+scmToList [x] = case x of+                     ScmVector  v -> f (elems v)+                     ScmMVector v -> f =<< getElems v+                     _            -> return$ notVector "vector->list"+ where+   f = fmap (Right . fst) . listToPair++scmToList [] = return$ tooFewArgs  "vector->list"+scmToList _  = return$ tooManyArgs "vector->list"++scmFromList [x] =+   case x of+        ScmList l       -> Right <$> toScmMVector l+        p@(ScmPair _ _) -> do+           l <- pairToList p+           case l of+                Left _             -> return$ notList "list->vector"+                Right (ScmList l') -> Right <$> toScmMVector l'++                _ -> error "list->vector :: the impossible happened"++        _ -> return$ notList "list->vector"++scmFromList [] = return$ tooFewArgs  "list->vector"+scmFromList _  = return$ tooManyArgs "list->vector"++scmFill :: [ScmValue] -> IO (ErrOr ScmValue)+scmFill [v, x] =+   case v of+        ScmMVector v' -> do+           (a,b) <- getBounds v'+           mapM_ (\i -> writeArray v' i x) [a..b]+           return (Right ScmVoid)++        ScmVector _ -> return$ immutable "vector-fill!"+        _           -> return$ notVector "vector-fill!"++scmFill (_:_:_) = return$ tooManyArgs "vector-fill!"+scmFill _       = return$ tooFewArgs  "vector-fill!"++------++notVector :: String -> ErrOr a+notVector = fail . ("Nonvector argument to " ++)++toScmMVector :: [ScmValue] -> IO ScmValue+toScmMVector v = ScmMVector <$> newListArray (0, length v - 1) v++tryToLen :: String -> Integer -> (Int -> IO a) -> IO (ErrOr a)+tryToLen = tryRange 0 (toInteger (maxBound :: Int))++tryToIdx :: String -> IO Int -> Integer -> (Int -> IO a) -> IO (ErrOr a)+tryToIdx s mlen i f = mlen >>= \len -> tryRange 0 (toInteger len - 1) s i f++tryRange :: Integer -> Integer -> String -> Integer -> (Int -> IO a)+         -> IO (ErrOr a)+tryRange a b s i f = if i >= a && i <= b+                        then Right <$> f (fromInteger i)+                        else return.Left $ "Out-of-range integer to " ++ s++vLen :: Array Int ScmValue -> IO Int+vLen = return . (+1) . snd . bounds++mvLen :: IOArray Int ScmValue -> IO Int+mvLen = fmap ((+1) . snd) . getBounds
+ Haschoo/Evaluator/Utils.hs view
@@ -0,0 +1,19 @@+-- File created: 2009-07-19 18:41:22++{-# LANGUAGE FlexibleContexts #-}++module Haschoo.Evaluator.Utils where++import Control.Monad.Error (MonadError, throwError)++tooFewArgs, tooManyArgs, immutable,+ notList, notInt, notChar, notProcedure, notString+ :: MonadError String m => String -> m a+tooFewArgs   = throwError . ("Too few arguments to " ++)+tooManyArgs  = throwError . ("Too many arguments to " ++)+immutable    = throwError . ("Immutable argument to " ++)+notList      = throwError . ("Nonlist argument to "++)+notInt       = throwError . ("Noninteger argument to " ++)+notChar      = throwError . ("Noncharacter argument to " ++)+notProcedure = throwError . ("Nonprocedural argument to "++)+notString    = throwError . ("Nonstring argument to " ++)
+ Haschoo/Main.hs view
@@ -0,0 +1,31 @@+-- File created: 2009-07-21 13:19:42++module Main (main, runOne) where++import Prelude hiding (catch)++import Control.Exception  (catch)+import Data.IORef         (newIORef, readIORef)+import System.Environment (getArgs)++import Haschoo.Running (runRepl, runFile, run, RunError)+import Haschoo.Stdlib  (toplevelContext)+import Haschoo.Utils   (void, errPrint)++main :: IO ()+main = do+   ctx  <- toplevelContext+   args <- getArgs+   if null args+      then runRepl ctx+      else do+         initCtx <- mapM readIORef ctx+         mapM_ (\f -> do+                   ctx' <- mapM newIORef initCtx+                   runFile ctx' f+                      `catch` \e -> errPrint (e :: RunError))+               args++-- For GHCi use+runOne :: String -> IO ()+runOne s = toplevelContext >>= \ctx -> void (run ctx "runOne" s)
+ Haschoo/Parser.hs view
@@ -0,0 +1,312 @@+-- File created: 2009-07-11 20:29:49++module Haschoo.Parser (runParser, programValue, value, number) where++import Control.Applicative                  ((<$>))+import Control.Arrow                        (first)+import Control.Monad                        (liftM2)+import Data.Char                            (digitToInt, toLower)+import Data.Complex                         (Complex((:+)), mkPolar)+import Data.Maybe                           (fromJust, fromMaybe, isJust)+import Data.Ratio                           ((%))+import Numeric                              (readInt)+import Text.ParserCombinators.Parsec hiding (runParser)++import Haschoo.Types (ScmValue(..), toScmString, toScmVector)+import Haschoo.Utils (void, (.:))++runParser :: Parser a -> SourceName -> String -> Either String a+runParser = (either (Left . show) Right .:) . parse++programValue :: Maybe SourcePos -> Parser (Maybe (ScmValue, String, SourcePos))+programValue pos = do+   maybe (return ()) setPosition pos+   optional atmosphere+   v <- (Just <$> value) <|> (eof >> return Nothing)+   case v of+        Nothing -> return Nothing+        Just v' -> liftM2 (Just .: (,,) v') getInput getPosition++values :: Parser [ScmValue]+values = optional atmosphere >> (many $ value `discard` atmosphere)++value :: Parser ScmValue+value = do+   quotes <-+      concat <$> many+         (choice [ string "'"+                 , string "`"+                 , liftM2 (:) (char ',') (string "@" <|> return "") ]+             `discard` atmosphere)++   val <- choice [ ident+                 , list+                 , vector+                 , bool+                 , number 10+                 , character+                 , quotedString ]++   return $ quote quotes val+ where+   quote []            = id+   quote ('\''    :qs) = quoteWith "quote"            qs+   quote ('`'     :qs) = quoteWith "quasiquote"       qs+   quote (',' :'@':qs) = quoteWith "unquote-splicing" qs+   quote (','     :qs) = quoteWith "unquote"          qs+   quote _             = error "Parser.quote :: the impossible happened"++   quoteWith s qs = ScmList . (ScmIdentifier s :) . (:[]) . quote qs++ident :: Parser ScmValue+ident = do+   -- peculiar needs the try due to negative numbers+   x <- try $ choice [ peculiar `discard` try delimiter+                     , ordinary `discard` delimiter ]+   return (ScmIdentifier $ map toLower x)+ where+   peculiar = choice [return <$> oneOf "+-", string "..."]+   ordinary = do+      x  <- oneOf initial+      xs <- many (oneOf (initial ++ "+-.@" ++ ['0'..'9']))+      return (x:xs)+    where+      initial = ['a'..'z'] ++ ['A'..'Z'] ++ "!$%&*/:<=>?^_~"++bool :: Parser ScmValue+bool = ScmBool . (`elem` "tT") <$> try (char '#' >> oneOf "ftFT")++character :: Parser ScmValue+character = do+   try (string "#\\")+   c <- try named <|> anyChar+   delimiter+   return (ScmChar c)+ where+   named = choice [ string "space"   >> return ' '+                  , string "newline" >> return '\n' ]++quotedString :: Parser ScmValue+quotedString =+   fmap toScmString+      . between (try $ char '"') (char '"')+      . many $+          (char '\\' >> (oneOf "\\\"" <?> concat [show "\\"," or ",show "\""]))+      <|> satisfy (/= '"')++list :: Parser ScmValue+list =+   between (try $ char '(') (optional atmosphere >> char ')') $ do+      vals <- values+      if null vals+         then return$ ScmList vals+         else do+            optional atmosphere+            dot <- optionMaybe (char '.')+            if isJust dot+               then do+                  atmosphere+                  end <- value+                  return$ case end of+                               ScmList l -> ScmList (vals ++ l)+                               _         -> mkDotted vals end+               else return$ ScmList vals+ where+   -- Flatten (1 . (2 . 3)) to (1 2 . 3)+   mkDotted xs (ScmDottedList ys z) = mkDotted (xs ++ ys) z+   mkDotted xs x                    = ScmDottedList xs x++vector :: Parser ScmValue+vector = do+   try (char '#' >> char '(')+   toScmVector <$> values `discard` (optional atmosphere >> char ')')++number :: Int -> Parser ScmValue+number defRadix = do+   (radix,exact) <- try prefix++   let p = if isJust radix || isJust exact then id else try+   n <- p $ complex (fromMaybe False exact) (fromMaybe defRadix radix)++   delimiter++   return$ if fromMaybe True exact+              then n+              else case n of+                        ScmInt x -> ScmReal (fromInteger  x)+                        ScmRat x -> ScmReal (fromRational x)+                        _        -> n+ where+   prefix = do+      r <- radix+      e <- exactness+      -- They can be in either order+      flip (,) e <$> if isJust r+                        then return r+                        else radix+    where+      radix     = f [('B',2), ('O',8), ('D',10), ('X',16)]+      exactness = f [('E',True), ('I',False)]+      f xs = optionMaybe . try $ do+         char '#'+         let xs' = map (first toLower) xs ++ xs+         fromJust . (`lookup` xs') <$> oneOf (map fst xs')++   complex exact radix =+      choice [ try $ do n <- sreal False radix+                        ncChar 'i'+                        return (mkImaginary n)++             , try $ do a  <- real exact radix+                        at <- optionMaybe (char '@')+                        if isJust at+                           then mkComplex mkPolar a <$> real False radix+                           else do+                              b <- optionMaybe $ try imaginaryUnit <|>+                                      do n <- sreal False radix+                                         ncChar 'i'+                                         return n++                              return $ case b of+                                            Nothing -> a+                                            Just n  -> mkComplex (:+) a n++             , mkImaginary <$> imaginaryUnit ]+    where+      imaginaryUnit = do+         neg <- sign+         ncChar 'i'+         return (ScmInt neg)++      mkImaginary     = mkComplex (:+) (ScmInt 0)+      mkComplex f a b = ScmComplex $ f (toDouble a) (toDouble b)++   toDouble (ScmInt  i) = fromInteger  i+   toDouble (ScmRat  r) = fromRational r+   toDouble (ScmReal r) = r+   toDouble _           = error "number.toDouble :: internal error"++   real exact radix = do+      neg <- optionMaybe sign+      applySign (fromMaybe 1 neg) <$> ureal exact radix++   sreal exact radix = do+      neg <- sign+      applySign neg <$> ureal exact radix++   applySign neg (ScmInt  n) = ScmInt  (fromIntegral neg * n)+   applySign neg (ScmRat  n) = ScmRat  (fromIntegral neg * n)+   applySign neg (ScmReal n) = ScmReal (fromIntegral neg * n)+   applySign _   _           = error "number.applySign :: іnternal error"++   ureal exact radix = choice [ string "nan.#" >> return (ScmReal $ 0/0)+                              , string "inf.#" >> return (ScmReal $ 1/0)+                              , decimal exact radix+                              , do a <- uint radix+                                   b <- optionMaybe $ char '/' >> uint radix+                                   case b of+                                        Nothing ->+                                           if radix == 10+                                              then tryExponent exact a+                                              else return a+                                        Just n  -> return (mkRatio a n) ]++   mkRatio (ScmInt a) (ScmInt b) = ScmRat (a % b)+   mkRatio _          _          = error "number.mkRatio :: internal error"++   decimal exact radix | radix /= 10 = fail "Decimal outside radix 10"+                       | otherwise   =+      tryExponent exact =<<+         (try . choice) [ do char '.'+                             n <- many1 (digitN 10)+                             skipMany (char '#')+                             return $ readDecimal exact "0" n++                        , do a <- many1 (digitN 10)+                             char '.'+                             b <- many (digitN 10)+                             skipMany (char '#')+                             -- read doesn't like "123." so add a 0 if+                             -- necessary+                             return $+                                readDecimal exact a (if null b then "0" else b)++                        , do n <- many1 (digitN 10)+                             hashes  <- map (const '0') <$> many1 (char '#')+                             char '.'+                             hashes2 <- many (char '#')+                             return . inexactHashes (hashes ++ hashes2) .+                                ScmInt $ readInteger 10 (n ++ hashes)+                        ]++   tryExponent exact n = do+      ex <- optionMaybe $ do+               oneOf "esfdlESFDL" -- Ignore the exponent: all Double+               neg <- optionMaybe sign+               xs  <- many1 (digitN 10)+               return$ fromMaybe 1 neg * readInteger 10 xs++      return$+         case ex of+              Nothing -> n+              Just e | not exact -> ScmReal (10^^e * toDouble n)+                     | otherwise ->+                        case n of+                             ScmInt x -> ScmRat (10^^e * fromInteger x)+                             ScmRat x -> ScmRat (10^^e * x)+                             _        ->+                                error$ "Parser.tryExponent :: "+                                    ++ "the impossible happened"++   uint radix = do+      n <- many1 (digitN radix)+      hashes <- map (const '0') <$> many (char '#')+      return . inexactHashes hashes . ScmInt $ readInteger radix (n ++ hashes)++   -- If any # were present, the value is inexact (R5RS 6.2.4)+   inexactHashes :: String -> ScmValue -> ScmValue+   inexactHashes [] = id+   inexactHashes _  = ScmReal . toDouble++   digitN :: Int -> Parser Char+   digitN 2  = oneOf "01"+   digitN 8  = octDigit+   digitN 10 = digit+   digitN 16 = hexDigit+   digitN _  = error "number.digitN :: internal error"++   sign = (\c -> if c == '+' then 1 else -1) <$> oneOf "+-"++   -- These read functions all assume correctly formed input++   readInteger :: Int -> String -> Integer+   readInteger radix =+      fst.head . readInt (fromIntegral radix) (const True) digitToInt++   readDecimal :: Bool -> String -> String -> ScmValue+   readDecimal False as bs = ScmReal . read . concat $ [as, ".", bs]+   readDecimal True  as bs =+      ScmRat $ fromInteger (readInteger 10 as)+             + fromInteger (readInteger 10 bs) / 10 ^ length bs++-- Pushes back anything relevant for other parsers+delimiter :: Parser ()+delimiter = choice [ whitespaceOrComment+                   , void . lookAhead . try $ oneOf "()\""+                   , try eof ]++atmosphere :: Parser ()+atmosphere = skipMany whitespaceOrComment++whitespaceOrComment :: Parser ()+whitespaceOrComment =+   choice [ void newline+          , char '\r' >> optional newline+          , void space+          , char ';' >> skipMany (noneOf "\n\r") ]++ncChar :: Char -> Parser Char+ncChar c = toLower <$> satisfy ((== c) . toLower)++discard :: Parser a -> Parser b -> Parser a+discard a b = a >>= \a' -> b >> return a'
+ Haschoo/Running.hs view
@@ -0,0 +1,68 @@+-- File created: 2009-07-26 17:17:23++{-# LANGUAGE DeriveDataTypeable, ScopedTypeVariables #-}+module Haschoo.Running (RunError(..), runFile, runHandle, run, runRepl) where++import Control.Exception (Exception, throw, catch)+import Control.Monad     ((>=>), when)+import Data.IORef        (IORef)+import Data.Typeable     (Typeable)+import System.IO         ( Handle, openFile, IOMode(ReadMode), hGetContents+                         , hPutStrLn, hFlush, stderr, stdout )++import Prelude hiding (catch)++import Haschoo.Evaluator (evalToplevel)+import Haschoo.Parser    (runParser, programValue)+import Haschoo.Types     (Context, scmShow)++data RunError = ParseError String | RuntimeError String+ deriving Typeable++instance Show RunError where+   show (ParseError   s) = "Parse error: "   ++ s+   show (RuntimeError s) = "Runtime error: " ++ s++instance Exception RunError++runFile :: [IORef Context] -> FilePath -> IO ()+runFile ctx path = openFile path ReadMode >>= runHandle ctx path++runHandle :: [IORef Context] -> FilePath -> Handle -> IO ()+runHandle ctx name = hGetContents >=> run ctx name++run :: [IORef Context] -> FilePath -> String -> IO ()+run ctx name = go Nothing+ where+   go pos str =+      case runParser (programValue pos) name str of+           Left e               -> throw (ParseError e)+           Right (Just (v,s,p)) -> do+              result <- evalToplevel ctx v+              case result of+                   Left  e -> throw (RuntimeError e)+                   Right _ -> go (Just p) s++           Right Nothing -> return ()++runRepl :: [IORef Context] -> IO ()+runRepl ctx = do+   putStr "Haschoo} "+   hFlush stdout+   line <- fmap Just getLine `catch` (\(_ :: IOError) -> return Nothing)+   maybe (return ()) (\l -> handle (go l) >> runRepl ctx) line+ where+   handle = flip catch $ \e -> hPutStrLn stderr $ show (e :: RunError)+   go str =+      case runParser (programValue Nothing) "<repl>" str of+           Left e               -> throw (ParseError e)+           Right (Just (v,s,_)) -> do+              result <- evalToplevel ctx v+              case result of+                   Left  e -> throw (RuntimeError e)+                   Right r -> do+                      rs <- scmShow r+                      when (not $ null rs) (putStrLn rs)+                      go s++           Right Nothing -> return ()
+ Haschoo/Stdlib.hs view
@@ -0,0 +1,69 @@+-- File created: 2009-07-26 17:13:57++module Haschoo.Stdlib (toplevelContext) where++import Prelude hiding (catch)++import Control.Exception (catch, SomeException)+import Data.IORef        (IORef, newIORef, readIORef)+import System.Exit       (exitFailure)++import Haschoo.Running         (runFile)+import Haschoo.Types           (Context, addToContext, ScmValue(..))+import Haschoo.Utils           (errPut, errPutLn, errPrint, ErrOr)+import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs, notInt)++import qualified Haschoo.Evaluator.Standard   as Standard+import qualified Haschoo.Evaluator.Primitives as Primitives++toplevelContext, primitiveContext :: IO [IORef Context]+toplevelContext = do+   pc <- primitiveContext+   load pc std "std-func.scm"+ where+   std = foldr (uncurry addToContext) Standard.context envFuncs++primitiveContext = load [] Primitives.context "std-prim.scm"++load :: [IORef Context] -> Context -> FilePath -> IO [IORef Context]+load ctx new path = (do+   ctx' <- fmap (:ctx) $ newIORef new+   runFile ctx' path+   return ctx')+ `catch` \e -> do+    errPutLn.concat $ ["Failed to load standard library file '",path,"'!"]+    errPut "  "+    errPrint (e :: SomeException)+    exitFailure++-- These are defined here because they depend on the above+envFuncs :: [(String, ScmValue)]+envFuncs = map (\(a,b) -> (a, ScmFunc a b))+  [ ("scheme-report-environment", fmap (fmap ScmContext) . scmStandardEnv)+  , ("null-environment",          fmap (fmap ScmContext) . scmNullEnv)+  ]++scmStandardEnv, scmNullEnv :: [ScmValue] -> IO (ErrOr [Context])+scmStandardEnv [ScmInt n] =+      if n == 5+         then do+            ctx  <- toplevelContext+            ctx' <- mapM readIORef ctx+            return$ Right ctx'+         else return$ Left ("Nonfive integer to scheme-report-environment")++scmStandardEnv [_] = return$ notInt      "scheme-report-environment"+scmStandardEnv []  = return$ tooFewArgs  "scheme-report-environment"+scmStandardEnv _   = return$ tooManyArgs "scheme-report-environment"++scmNullEnv [ScmInt n] =+      if n == 5+         then do+            ctx  <- primitiveContext+            ctx' <- mapM readIORef ctx+            return$ Right ctx'+         else return$ Left ("Nonfive integer to scheme-report-environment")++scmNullEnv [_] = return$ notInt      "null-environment"+scmNullEnv []  = return$ tooFewArgs  "null-environment"+scmNullEnv _   = return$ tooManyArgs "null-environment"
+ Haschoo/Types.hs view
@@ -0,0 +1,245 @@+-- File created: 2009-07-11 21:47:19++-- ScmValue depends on Haschoo+-- Haschoo  depends on Context+-- Context  depends on ScmValue+--+-- Thus they all have to be in the same module, to avoid circular dependencies.+{-# LANGUAGE BangPatterns, GeneralizedNewtypeDeriving #-}++module Haschoo.Types+   ( Haschoo, runHaschoo, withHaschoo+   , ScmValue(..), MacroCall(..)+   , isTrue, isAggregate+   , toScmString, toScmMString+   , toScmVector+   , pairToList, listToPair+   , Context, mkContext, addToContext, contextLookup, contextSize+   , scmShow, scmShowWith+   ) where++import Control.Applicative        ((<$>))+import Control.Arrow              (second)+import Control.Monad.Error        (ErrorT, MonadError, runErrorT)+import Control.Monad.State.Strict (StateT, MonadState, evalStateT)+import Control.Monad.Trans        (MonadIO, liftIO)+import Data.Array.IO              (IOArray, IOUArray, newListArray, getElems)+import Data.Array.Unboxed         (Array, UArray, elems, listArray)+import Data.Complex               (Complex((:+)))+import Data.IORef                 (IORef, readIORef, newIORef)+import Data.List                  (intercalate)+import Data.Ratio                 (numerator, denominator)+import System.IO                  (Handle)+import System.IO.Unsafe           (unsafeInterleaveIO)+import Text.Show.Functions        ()++import qualified Data.ListTrie.Patricia.Map.Enum as TM+import Data.ListTrie.Patricia.Map.Enum (TrieMap)++import Haschoo.Utils (ErrOr, lazyMapM)++-- Our main monad+newtype Haschoo a = Haschoo (StateT HaschState (ErrorT String IO) a)+   deriving (Functor, Monad, MonadIO, MonadState HaschState, MonadError String)++runHaschoo :: HaschState -> Haschoo a -> IO (ErrOr a)+runHaschoo state (Haschoo h) = runErrorT $ evalStateT h state++-- Like 'local' of the Reader monad+withHaschoo :: HaschState -> Haschoo a -> Haschoo a+withHaschoo state h = either fail return =<< liftIO (runHaschoo state h)++type HaschState = [IORef Context]++data ScmValue = ScmPrim  String !([ScmValue] -> Haschoo   ScmValue)+              | ScmFunc  String !([ScmValue] -> IO (ErrOr ScmValue))++              | ScmMacro String+                   !(MacroCall ->+                        Haschoo (ScmValue, TrieMap Char [IORef Context]))++              | ScmBool       !Bool+              | ScmChar       !Char+              | ScmInt        !Integer+              | ScmRat        !Rational+              | ScmReal       !Double+              | ScmComplex    !(Complex Double)+              | ScmIdentifier !String+              | ScmPair       !(IORef ScmValue) !(IORef ScmValue)+              | ScmString     !(  UArray Int Char)+              | ScmMString    !(IOUArray Int Char)+              | ScmVector     !(   Array Int ScmValue)+              | ScmMVector    !( IOArray Int ScmValue)++              | ScmSyntax { patterns :: ![(ScmValue, ScmValue, [String])]+                          , literals :: ![(String, Maybe ScmValue)] }++              -- These two are only for literal lists, appearing only directly+              -- from the parser+              | ScmList       ![ScmValue]+              | ScmDottedList ![ScmValue] !ScmValue -- The list is never empty++              -- The "unspecified value" returned by IO procedures and such+              | ScmVoid++              | ScmInput  !Handle+              | ScmOutput !Handle+              | ScmEOF++              -- The "environment-specifier" used by eval-related procedures+              | ScmContext ![Context]++-- The form of the macro usage:+--+-- (macro foo bar), (macro foo . bar), or #(macro foo bar)+--+-- The macro keyword is not included regardless of constructor+data MacroCall = MCList   ![ScmValue]+               | MCDotted ![ScmValue] !ScmValue++isTrue, isAggregate :: ScmValue -> Bool+isTrue (ScmBool False) = False+isTrue _               = True++isAggregate (ScmList       _)   = True+isAggregate (ScmDottedList _ _) = True+isAggregate (ScmVector     _)   = True+isAggregate (ScmMVector    _)   = True+isAggregate (ScmPair       _ _) = True+isAggregate _                   = False++-- From ScmPair to Left . ScmDottedList or Right . ScmList+pairToList :: ScmValue -> IO (Either ScmValue ScmValue)+pairToList = go []+ where+   go xs (ScmList       ys)   =+      return . Right $ ScmList       (reverse xs ++ ys)+   go xs (ScmDottedList ys z) =+      return . Left  $ ScmDottedList (reverse xs ++ ys) z++   go xs (ScmPair a b) = do+      a' <- readIORef a+      b' <- readIORef b+      go (a':xs) b'++   go xs v = return . Left $ ScmDottedList (reverse xs) v++-- ScmList -> ScmPair, returns the tail pointer if it wasn't empty+listToPair :: [ScmValue] -> IO (ScmValue, Maybe (IORef ScmValue))+listToPair []     = return (ScmList [], Nothing)+listToPair (x:xs) = second Just <$> go x xs+ where+   go :: ScmValue -> [ScmValue] -> IO (ScmValue, IORef ScmValue)+   go v [] = do+      a <- newIORef v+      b <- newIORef (ScmList [])+      return (ScmPair a b, b)++   go v (y:ys) = do+      a         <- newIORef v+      (zs, fin) <- go y ys+      b         <- newIORef zs+      return (ScmPair a b, fin)++toScmString :: String -> ScmValue+toScmString s = ScmString $ listArray (0, length s - 1) s++toScmMString :: String -> IO ScmValue+toScmMString s = ScmMString <$> newListArray (0, length s - 1) s++toScmVector :: [ScmValue] -> ScmValue+toScmVector v = ScmVector $ listArray (0, length v - 1) v++newtype Context = Context (TrieMap Char ScmValue)++mkContext :: [(String, ScmValue)] -> Context+mkContext = Context . TM.fromList++addToContext :: String -> ScmValue -> Context -> Context+addToContext name val (Context c) = Context (TM.insert' name val c)++contextLookup :: String -> Context -> Maybe ScmValue+contextLookup s (Context c) = TM.lookup s c++contextSize :: Context -> Int+contextSize (Context c) = TM.size' c++scmShow :: ScmValue -> IO String+scmShow ScmVoid           = return "" -- Has no representation+scmShow (ScmBool b)       = return$ '#' : if b then "t" else "f"+scmShow (ScmPrim s _)     = return s+scmShow (ScmFunc s _)     = return s+scmShow (ScmMacro s _)    = return s+scmShow (ScmIdentifier s) = return s+scmShow (ScmInt n)        = return$ show n+scmShow (ScmReal n)+   | isNaN      n = return "+nan.#"+   | isInfinite n = return$ (if n < 0 then '-' else '+') : "inf.#"+   | otherwise    = return$ show n+scmShow (ScmRat n) =+   if denominator n == 1+      then return$ show (numerator n)+      else return$ concat [show (numerator n), "/", show (denominator n)]++scmShow (ScmComplex (a :+ b)) = do+   bs <- scmShow (ScmReal b)+   as <- scmShow (ScmReal a)+   return$ concat [ as+                  , if head bs `elem` "-+" then [] else "+"+                  , bs+                  , "i" ]++scmShow (ScmChar c) | c == ' '  = return  "#\\space"+                    | c == '\n' = return  "#\\newline"+                    | otherwise = return$ "#\\" ++ [c]++scmShow (ScmSyntax  _ _) = return "<syntax rules>"+scmShow (ScmContext _)   = return "<environment specifier>"+scmShow ScmEOF           = return "<end of file object>"+scmShow (ScmInput  _)    = return "<input port>"+scmShow (ScmOutput _)    = return "<output port>"++scmShow (ScmString  s) = return$ showScmString (elems s)+scmShow (ScmMString s) = showScmString <$> getElems s++scmShow x | isAggregate x = scmShowWith scmShow x+          | otherwise     = error "scmShow :: the impossible happened"++scmShowWith :: (ScmValue -> IO String) -> ScmValue -> IO String+scmShowWith f (ScmList xs)        = showScmList f xs+scmShowWith f (ScmDottedList a b) = do+   as <- showScmList f a+   bs <- f b+   return$ concat [init as, " . ", bs, ")"]++scmShowWith f (ScmVector  v) = ('#':) <$>  showScmList f       (elems v)+scmShowWith f (ScmMVector v) = ('#':) <$> (showScmList f =<< getElems v)++scmShowWith f (ScmPair car cdr) = do+   a  <- readIORef car+   as <- f a+   ('(':) . (as ++) <$> unsafeInterleaveIO (readIORef cdr >>= go)+ where+   go   (ScmList [])        = return ")"+   go x@(ScmList _)         = (' ':) . tail <$> f x+   go x@(ScmDottedList _ _) = (' ':) . tail <$> f x++   go (ScmPair x y) = do+      a <- readIORef x+      as <- f a+      (' ':) . (as ++) <$> unsafeInterleaveIO (readIORef y >>= go)++   go x = (" . "++) . (++")") <$> f x++scmShowWith _ _ = error "scmShowWith :: the impossible happened"++showScmString :: String -> String+showScmString s = '"' : foldr ((.) . f) id s "\""+ where+   f c | c == '\\' = showString "\\\\"+       | c == '\"' = showString "\\\""+       | otherwise = showChar c++showScmList :: (a -> IO String) -> [a] -> IO String+showScmList f xs =+   ("("++) . (++")") . intercalate " " <$> lazyMapM f xs
+ Haschoo/Utils.hs view
@@ -0,0 +1,108 @@+-- File created: 2009-07-15 10:37:42++module Haschoo.Utils where++import Control.Arrow         (first, (***))+import Control.Monad         (liftM)+import Control.Monad.Error   () -- Monad ErrOr+import Control.Monad.State   (MonadState, get, put)+import Control.Monad.Trans   (MonadIO, liftIO)+import System.IO             (hPutStr, hPutStrLn, stderr)+import System.IO.Unsafe      (unsafeInterleaveIO)+import System.Mem.StableName (makeStableName)++type ErrOr = Either String++swap :: (a,b) -> (b,a)+swap ~(a,b) = (b,a)++fst3 :: (a,b,c) -> a+fst3 (a,_,_) = a++-- Returns the length of the shorter of the two+compareLengths :: [a] -> [b] -> (Ordering, Int)+compareLengths = go 0+ where+   go n []     []     = (EQ, n)+   go n (_:_)  []     = (GT, n)+   go n []     (_:_)  = (LT, n)+   go n (_:as) (_:bs) = go (n+1) as bs++compareLength :: [a] -> Int -> Ordering+compareLength _      n | n < 0 = GT+compareLength []     0         = EQ+compareLength []     _         = LT+compareLength (_:_)  0         = GT+compareLength (_:as) n         = compareLength as (n-1)++initLast :: [a] -> ([a], a)+initLast [x]    = ([], x)+initLast (x:xs) = first (x:) (initLast xs)+initLast []     = error "initLast :: empty list"++initLast2Maybe :: [a] -> Maybe ([a], a, a)+initLast2Maybe [x,y]  = Just ([], x, y)+initLast2Maybe (a:as) = fmap (\ ~(bs,x,y) -> (a:bs,x,y)) (initLast2Maybe as)+initLast2Maybe []     = Nothing++fromRights :: [Either a b] -> Maybe [b]+fromRights []             = Just []+fromRights (Left _ : _)   = Nothing+fromRights (Right x : xs) = fmap (x:) (fromRights xs)++-- eqWithM p xs ys is kind of like allM (uncurry p) (zip xs ys) but takes into+-- account the lengths of the lists (differing lengths aren't equal)+--+-- Essentially, monadic list equality according to the given predicate+eqWithM :: Monad m => (a -> b -> m Bool) -> [a] -> [b] -> m Bool+eqWithM _ [] [] = return True+eqWithM _ _  [] = return False+eqWithM _ [] _  = return False+eqWithM p (x:xs) (y:ys) = do+   b <- p x y+   if b+      then eqWithM p xs ys+      else return False++-- Applies the function on element pairs while there are enough elements to+-- form pairs+mapOnPairs :: (a -> b -> (a,b)) -> [a] -> [b] -> ([a],[b])+mapOnPairs f (x:xs) (y:ys) = let (x',y') = f x y+                              in ((x':) *** (y':)) (mapOnPairs f xs ys)++mapOnPairs _ xs ys = (xs, ys)++void :: Functor f => f a -> f ()+void = fmap (const ())++allM :: Monad m => (a -> m Bool) -> [a] -> m Bool+allM f = liftM and . mapM f++lazyMapM :: MonadIO io => (a -> IO b) -> [a] -> io [b]+lazyMapM f = mapM (liftIO . unsafeInterleaveIO . f)++modifyM :: (MonadState s m) => (s -> m s) -> m ()+modifyM = (put =<<) . (get >>=)++infixl 0 $<+($<) :: a -> (a -> b) -> b+($<) = flip ($)++infixr 9 .:+(.:) :: (d -> c) -> (a -> b -> d) -> a -> b -> c+f .: g = \x y -> f (g x y)++ptrEq :: a -> a -> IO Bool+ptrEq x y = do+   nx <- makeStableName x+   ny <- makeStableName y+   return (nx == ny)++errPut :: String -> IO ()+errPut = hPutStr stderr++errPutLn :: String -> IO ()+errPutLn = hPutStrLn stderr++errPrint :: Show a => a -> IO ()+errPrint = errPutLn . show
+ LICENSE.txt view
@@ -0,0 +1,24 @@+Copyright (c) 2009, Matti Niemenmaa+All rights reserved.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met:+    * Redistributions of source code must retain the above copyright+      notice, this list of conditions and the following disclaimer.+    * Redistributions in binary form must reproduce the above copyright+      notice, this list of conditions and the following disclaimer in the+      documentation and/or other materials provided with the distribution.+    * Neither the name of the project nor the names of its contributors may be+      used to endorse or promote products derived from this software without+      specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR IMPLIED+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO+EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ README.txt view
@@ -0,0 +1,95 @@+Haschoo: the Scheme interpreter to be sneezed at+=======++Haschoo is a little R5RS [1] interpreter written in Haskell for a university+course. The name, if it's not obvious, is a portmanteau of "Haskell", "Scheme",+and "achoo", the last of which is meant to signify something along the lines of+it being a sneeze's worth of code and not a particularly serious endeavour.++For licensing information, see LICENSE.txt.++Usage+-----++Haschoo is quite spartan. It doesn't understand any command line options: if+given no parameters, it becomes a REPL which terminates on end-of-file,+otherwise it runs the file named by each argument as a standalone Scheme+program.++Building+--------++Haschoo is not written in standard Haskell 98, but depends on GHC-only (at the+time of writing) compiler extensions, so you'll need GHC to build it. Get it at+http://www.haskell.org/ghc/; version 6.10.2 was used for testing, but later+6.10 versions should work as well.++Nowadays you can also try the Haskell Platform, intended as a simple installer+to get you started quickly: http://hackage.haskell.org/platform/++If you have the cabal-install tool installed ([2] or the Haskell Platform),+installing Haschoo without downloading it manually should be as simple as:++cabal install Haschoo++If you've already got Haschoo downloaded, and you have cabal-install, try:++cabal configure+cabal build+cabal install++If you don't have cabal-install, the following commands, run from Haschoo's root+directory, should also work:++runhaskell Setup.hs configure+runhaskell Setup.hs build+runhaskell Setup.hs install++As a last resort:++ghc --make Haschoo/Main.hs -o haschoo -O2++Goal+----++If Haschoo can be said to have had a goal, it is minimalism: it tries to be a+bit of a DeathStation 9000 (see e.g. [3]) for R5RS. Currently it achieves this+in the following ways:++- No non-R5RS procedures are implemented or recognized.+- No extensions are made to existing R5RS procedures.+- Only two optional procedures are implemented: - and / for more than two+  arguments.+- Literal lists, strings, and vectors are immutable, as allowed by R5RS 3.4.++The basic idea was that if something works in Haschoo, it should work in any+R5RS system. That's not quite the current situation, but it seems to be mostly+true, at least based on my limited testing.++Known bugs+----------++Due to time and energy constraints I didn't manage to iron out the following:++- Continuations, regretfully, are not implemented at all.++- Nested ellipses in macros don't always work correctly.+  (e.g. tests/macros/nested-ellipses.scm)++- The "read" procedure doesn't work very well: due to annoying technical+  issues, it works by reading one character at a time and then trying to parse+  the string gathered thus far, stopping on a successful parse. Hence reading+  "-1" gives "-" followed by "1".++- Quasiquotation has some silly bugs. For example, `(1 2 . ,(list 3 4)) results+  in '(1 2 unquote (list 3 4)) instead of '(1 2 (list 3 4)).++No doubt there are many other lurking bugs. Time and energy constraints tend to+limit testing as well.++References+----------++[1]: http://schemers.org/Documents/Standards/R5RS/+[2]: http://hackage.haskell.org/trac/hackage/wiki/CabalInstall+[3]: http://wikibin.org/articles/deathstation-9000.html
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain
+ tests/macros/access-newvar.scm view
@@ -0,0 +1,4 @@+(define-syntax m (syntax-rules () ((m x) x)))+(let ((x 'ok))+  (write (m x))+  (newline))
+ tests/macros/conflicting-bindings.scm view
@@ -0,0 +1,3 @@+(define-syntax m (syntax-rules () ((m n1 n2) (let ((x n1)) n2))))+(define (f x) (m x x))+(write (if (= (f 2) 2) 'ok 'bad))(newline)
+ tests/macros/define-syntax-set.scm view
@@ -0,0 +1,5 @@+(define x 1)+(let-syntax ((m (syntax-rules () ((m) x))))+  (set! x 2)+  (write (if (= (m) 1) 'bad 'ok)))+(newline)
+ tests/macros/define-syntax.scm view
@@ -0,0 +1,4 @@+(define-syntax m1 (syntax-rules () ((m1 x) (m2 x))))+(define-syntax m2 (syntax-rules () ((m2 x) x)))+(write (m1 'ok))+(newline)
+ tests/macros/dottedlist-ellipsis.scm view
@@ -0,0 +1,6 @@+(define-syntax m (syntax-rules ()+  ((m (x . y) ...) (append (list x ...) (list y ...)))))++(letrec ((x (m (1 . 2) (3 . 4))))+  (if (equal? x '(1 3 2 4))+      (begin (write 'ok)(newline))))
+ tests/macros/ellipsis-is-zero.scm view
@@ -0,0 +1,4 @@+(define-syntax m (syntax-rules () ((m (x ...)) 'ok)))+(write (m ()))(newline)+(define-syntax m (syntax-rules () ((m (x y ...)) 'x)))+(write (m (ok)))(newline)
+ tests/macros/elliptic-aggregates.scm view
@@ -0,0 +1,6 @@+(define-syntax m (syntax-rules () ((m (x #(a b) ...)) '((a b) ...))))+(write (if (null? (m (x))) 'ok 'bad))(newline)+           ++(define-syntax m (syntax-rules () ((m (x ...) y) '((x y)...))))+(write (if (equal? (m (a b) x) '((a x) (b x))) 'ok 'bad))(newline)
+ tests/macros/let-vs-letrec.scm view
@@ -0,0 +1,3 @@+(letrec-syntax ((m (syntax-rules () ((m x) x) ((m x y ...) (m y ...)))))+  (write (m 'bad 'ok))+  (newline))
+ tests/macros/list-ellipsis-2.scm view
@@ -0,0 +1,6 @@+(define-syntax m+  (syntax-rules ()+    ((m () b) b)+    ((m ((_1 _2) (x y) ...) b) (m ((x y) ...) b))))+(write (m ((1 2) (3 4)) 'ok))+(newline)
+ tests/macros/list-ellipsis.scm view
@@ -0,0 +1,6 @@+(define-syntax m (syntax-rules ()+  ((m (x y) ...) (append (list x ...) (list y ...)))))++(letrec ((x (m (1 2) (3 4))))+  (if (equal? x '(1 3 2 4))+      (begin (write 'ok)(newline))))
+ tests/macros/literal.scm view
@@ -0,0 +1,3 @@+(define-syntax m (syntax-rules (x) ((m x) 'ok)))+(write (m x))+(newline)
+ tests/macros/multilet.scm view
@@ -0,0 +1,1 @@+(write (if (= 3 (let ((a 1) (b 2)) (+ a b))) 'ok 'bad))(newline)
+ tests/macros/multiletstar.scm view
@@ -0,0 +1,1 @@+(write (if (= 3 (let* ((a 1) (b 2)) (+ a b))) 'ok 'bad))(newline)
+ tests/macros/nested-ellipses.scm view
@@ -0,0 +1,3 @@+(define-syntax m (syntax-rules () ((m (x ...) ...) '(#((x ...) (x ...)) ...)))) (m (a) (b))+(write (if (equal? (m (a) (b)) '(#((a) (a)) #((b) (b)))) 'ok 'bad))+(newline)
+ tests/macros/nested-frees.scm view
@@ -0,0 +1,8 @@+(define x 'ok)+(let-syntax ((m1 (syntax-rules () ((m1) x))))+  (define y 'ok)+  (let ((x 'bad))+    (let-syntax ((m2 (syntax-rules () ((m2) y))))+      (let ((y 'bad))+        (write (m1))(newline)+        (write (m2))(newline)))))
+ tests/macros/r5rs/4.3.1.scm view
@@ -0,0 +1,15 @@+(let-syntax ((when (syntax-rules ()+                     ((when test stmt1 stmt2 ...)+                      (if test+                          (begin stmt1+                                 stmt2 ...) #f)))))+  (let ((if #t))+    (when if (set! if 'ok))+    (write if)))+(newline)++(let ((x 'ok))+  (let-syntax ((m (syntax-rules () ((m) x))))+    (let ((x 'bad))+      (write (m)))))+(newline)
+ tests/macros/r5rs/4.3.2.scm view
@@ -0,0 +1,3 @@+(write (let ((=> #f))+         (cond (#t => 'ok))))+(newline)
+ tests/macros/vec-ellipsis-2.scm view
@@ -0,0 +1,6 @@+(define-syntax m+  (syntax-rules ()+    ((m #() b) b)+    ((m #((_1 _2) #(x y) ...) b) (m #(#(x y) ...) b))))+(write (m #((1 2)) 'ok))+(newline)
+ tests/macros/vec-ellipsis.scm view
@@ -0,0 +1,6 @@+(define-syntax m (syntax-rules ()+  ((m #(x y) ...) (append (list x ...) (list y ...)))))++(letrec ((x (m #(1 2) #(3 4))))+  (if (equal? x '(1 3 2 4))+      (begin (write 'ok)(newline))))
+ tests/macros/xfail/access-newvar.scm view
@@ -0,0 +1,4 @@+(define-syntax m (syntax-rules () ((m) x)))+(let ((x 'bad))+  (write (m))+  (newline))
+ tests/macros/xfail/bad-elliptic-aggregates.scm view
@@ -0,0 +1,3 @@+(define-syntax m (syntax-rules ()+                    ((m (x ...) (y ...))(begin(write 'BAD)(newline)'((x y) ...)))))+(m (a b) (x))
+ tests/macros/xfail/let-vs-letrec.scm view
@@ -0,0 +1,3 @@+(let-syntax ((m (syntax-rules () ((m x) x) ((m x y ...) (m y ...)))))+  (write (m 'BAD 'BAD))+  (newline))
+ tests/macros/xfail/literal.scm view
@@ -0,0 +1,4 @@+(define-syntax m (syntax-rules (x) ((m x) 'ok)))+(let ((x 0))+  (write (m x))+  (newline))
+ tests/r5rstest.scm view
@@ -0,0 +1,31249 @@+;;; R5RS test suite+;;;+;;; Edited for Haschoo...+;;;    removed non-R5RS-stuff (interpreter-specific stuff etc)+;;;    commented out stuff I disagree with or don't implement yet+;;;+;;; sources include+;;;   clisp test suite+;;;   Paul Dietz's CL test suite+;;;   R Kelsey, W Clinger, and J Rees r5rs.html (and r6rs.html)+;;;   A Jaffer's r4rstest.scm (the inspiration for this...)+;;;   guile test suite+;;;   gauche test suite+;;;   gambit test suite+;;;   Kent Dybvig's "The Scheme Programming Language"+;;;   Brad Lucier (who also pointed out many bugs)+;;;   Snd's numtst.c+;;;   GSL tests+;;;   Abramowitz and Stegun, "Handbook of Mathematical Functions"+;;;   Weisstein, "Encyclopedia of Mathematics"+;;;   the arprec package of David Bailey et al+;;;   Maxima, William Schelter et al+;;;   H Cohen, "A Course in Computational Algebraic Number Theory"+;;;   various mailing lists++(define with-bignums #t)                                       ; scheme integer has any number of bits+(define with-bigfloats #f)                                     ; scheme real has any number of bits+(define with-64-bit-ints #t)                                   ; scheme integer has at least 64 bits+(define with-relational-ops-that-require-at-least-2-args #t)   ; < et al min args = 2?+(define with-generic-modulo #f)                                ; #f is the Scheme norm+(define with-syntax-rules #t)                                  ;   only lightly tested+(define with-delay #t)                                         ; delay and force+; Haschoo: breaks with stuff becoming NaN+(define with-error-data #f)                                    ; collect numerical error info and report at end+(define with-error-checks #f)                                  ; include checks for bad arg types etc+(define with-large-powers #t)                                  ; for Gauche+(define with-rationalize #t)                                   ; test rationalize+++(define our-pi 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930382)+++;;; --------------------------------------------------------------------------------++; we're assuming call/cc is defined+;    (define call/cc call-with-current-continuation)+;+;    (define-syntax defmacro+;      (syntax-rules ()+;	((_ name params . body) (define-macro (name . params) . body))))+;+; we also assume there's a "catch" macro trapping all errors+;   if you're not expecting any errors, catch can be:+    (define (catch tag l1 l2) (l1))++;;;--------------------------------------------------------------------------------++(define (ok? tst result expected)+  ;(write tst) (display #\space) (write result) (display #\space) (write expected) (newline)+  (if (not (equal? result expected))+      (begin+	(write tst)+	(display " got ")+	(write result)+	(display " but expected ")+	(write expected)+	(newline)+	)))+++;(defmacro test (tst expected) (begin+;  (display tst) (display #\space) (display expected) (newline)+;  `(let ((result (catch #t (lambda () ,tst) (lambda args 'error))))+;     (ok? ',tst result ,expected)))+(define-syntax test (syntax-rules () ((_ tst expected) (begin+   (let ((result (catch #t (lambda () tst) (lambda args 'error))))+     (ok? 'tst result expected)))+  )))+++;;; the error limits below are pretty expansive in some cases, so with-error-data+;;;   tries to keep a record of the worst case error for each operator.  error-data+;;;   is a list: '(#(op worst-error worst-error-case) ...).++(define error-data '())++(define (op-error op result expected)++  (define (conjugate n)+    (make-rectangular (real-part n) (- (imag-part n))))++  (if (and (real? result)+	   (real? expected))+      (/ (magnitude (- result expected)) (max 1.0 (magnitude expected)))+      (case op+	((acosh)+	 (/ (magnitude (- (cosh result) (cosh expected)))+	    (max 0.001 (magnitude (cosh expected)))))+	((asin)+	 (/ (min (magnitude (- (sin result) (sin expected)))+		 (magnitude (- result expected)))+	    (max 0.001 (* 10 (magnitude (sin expected))))))+	((acos)+	 (/ (min (magnitude (- (cos result) (cos expected)))+		 (magnitude (- result expected)))+	    (max 0.001 (magnitude (cos expected)))))+	((asinh)+	 (/ (magnitude (- (sinh result) (sinh expected)))+	    (max 0.001 (magnitude (sinh expected)))))+	((atanh)+	 (/ (min (magnitude (- (tanh result) (tanh expected)))+		 (magnitude (- result expected)))+	    (max 0.001 (magnitude (tanh expected)))))+	((atan)+	 (/ (min (magnitude (- (tan result) (tan expected)))+		 (magnitude (- result expected)))+	    (max 0.001 (magnitude (tan expected)))))+	((cosh)+	 (/ (min (magnitude (- result expected))+		 (magnitude (- result (- expected))))+	    (max 0.001 (magnitude expected))))+	(else (/ (magnitude (- result expected)) (max 0.001 (magnitude expected)))))))+++(define (check-error tst result expected)+  (if (and (number? result)+	   (number? expected))+      (let ((err (op-error (car tst) result expected)))+	(if (> err 0.0)+	    (letrec ((find-if (lambda (pred l)+				(cond ((null? l) #f)+				      ((pred (car l)) (car l))+				      (else (find-if pred (cdr l)))))))+	      (let* ((op (car tst))+		     (err-op (find-if (lambda (n) (eq? op (vector-ref n 0))) error-data)))+		(if err-op+		    (if (> err (vector-ref err-op 1))+			(begin+			  (vector-set! err-op 1 err)+			  (vector-set! err-op 2 tst)+			  (vector-set! err-op 3 result)+			  (vector-set! err-op 4 expected)))+		    (set! error-data (cons (vector op err tst result expected) error-data)))))))))+++(define (types-consistent? n)+  (not (or (and (integer? n)+	       (or (not (= (denominator n) 1))+		   (not (= n (numerator n)))+		   (not (= (imag-part n) 0))+		   (not (= (floor n) (ceiling n) (truncate n) (round n) n))+		   (not (= n (real-part n)))))+	  (and (rational? n)+	       (not (integer? n))+	       (or (not (= (imag-part n) 0))+		   (= (denominator n) 1)+		   (= (denominator n) 0)+		   (not (= n (real-part n)))+		   (not (= n (/ (numerator n) (denominator n))))))+	  (and (real? n)+	       (not (rational? n))+	       (or (not (= (imag-part n) 0))+		   (not (= n (real-part n)))))+	  (and (complex? n)+	       (not (real? n))+	       (or (= (imag-part n) 0)+		   (not (= n (+ (real-part n) (* 0+i (imag-part n))))))))))+++(define (our-nan? x)+  (or (and (real? x)+	   (not (= 1 (+ (if (positive? x) 1 0)+			(if (negative? x) 1 0)+			(if (zero? x) 1 0)))))+      (and (integer? x)+	   (not (= 1 (+ (if (even? x) 1 0)+			(if (odd? x) 1 0)))))+      (not (= 1 (+ (if (zero? x) 1 0)+		   (if (> (magnitude x) 0) 1 0))))+      (let ((type (+ (if (integer? x) 1 0)+		     (if (rational? x) 2 0)+		     (if (real? x) 4 0)+		     (if (complex? x) 8 0))))+	(and (not (= type 8))+	     (not (= type 12))+	     (not (= type 14))+	     (not (= type 15))))+      (not (zero? (- x x))))) ; inf probably+++(define (number-ok? tst result expected)+  (if (and with-error-data+	   (number? result)+	   (number? expected))+      (check-error tst result expected))++  ;; (number? +nan.0) returns #t in Guile and Gauche -- this strikes me as perverse++  (if (not (eq? result expected))+      (if (or (and (not (number? expected))+		   (not (eq? result expected)))+	      (and (number? expected)+		   (or (not (number? result))+		       (our-nan? result)))+	      (and (rational? expected)+		   (exact? expected)+		   (rational? result)+		   (exact? result)+		   (not (= result expected)))+	      (and (or (and (rational? expected)+			    (exact? expected))+		       (and (rational? result)+			    (exact? result)))+		   (real? expected)+		   (real? result)+		   (> (magnitude (- result expected)) 1.0e-12))+	      (> (op-error (car tst) result expected) 1.0e-6)+	      (and (number? result)+		   (not (types-consistent? result))))+	  (begin+	    ;(display (and (not (number? expected))+	    ;              (not (eq? result expected))))+	    ;(display(and (number? expected)+	    ;             (or (not (number? result))+	    ;                 (our-nan? result))))+	    ;(display(and (rational? expected)+	    ;             (exact? expected)+	    ;             (rational? result)+	    ;             (exact? result)+	    ;             (not (= result expected))))+	    ;(display(and (or (and (rational? expected)+	    ;                      (exact? expected))+	    ;                 (and (rational? result)+	    ;                      (exact? result)))+	    ;             (real? expected)+	    ;             (real? result)+	    ;             (> (magnitude (- result expected)) 1.0e-12)))+	    ;(display(> (op-error (car tst) result expected) 1.0e-6))+	    ;(display (and (number? result)+	    ;             (not (types-consistent? result))))+	    (display tst)+	    (display " got ")+	    (display result)+	    (if (and (rational? result) (not (rational? expected)))+		(begin+		  (display " (")+		  (display (exact->inexact result))+		  (display ")" )))+	    (display " but expected ")+	    (display expected)++;	    (if (defined? 'format)+;		(begin+;		  (if (and (not (number? expected))+;			   (not (eq? result expected)))+;		      (format #t ", (eq? ~A ~A) -> #f" result expected)+;		      (if (and (number? expected)+;			       (or (not (number? result))+;				   (our-nan? result)))+;			  (begin+;			    (if (not (number? result))+;				(format #t ", (number? ~A) but not (number? ~A)" expected result)+;				(format #t ", (number? ~A) but (nan? ~A)" expected result)))+;			  (if (and (rational? expected)+;				   (exact? expected)+;				   (rational? result)+;				   (exact? result)+;				   (not (= result expected)))+;			      (format #t ", exact results but not (= ~A ~A): ~A" expected result (= result expected))+;			      (if (and (or (and (rational? expected)+;						(exact? expected))+;					   (and (rational? result)+;						(exact? result)))+;				       (real? expected)+;				       (real? result)+;				       (> (abs (- result expected)) 1.0e-12))+;				  (format #t ", rational results but diff > 1e-12: ~A" (> (abs (- result expected)) 1.0e-12))+;				  (if (> (op-error (car tst) result expected) 1.0e-6)+;				      (format #t ", op-error ~A is > 1e-6" (op-error (car tst) result expected))+;				      (let ((n result))+;					(format #t ", result not internally consistent")+;					(if (and (integer? n)+;						 (or (not (= (denominator n) 1))+;						     (not (= n (numerator n)))+;						     (not (= (imag-part n) 0))+;						     (not (= (floor n) (ceiling n) (truncate n) (round n) n))+;						     (not (= n (real-part n)))))+;					    (format #t ", ~A integer but den: ~A, num: ~A, imag: ~A, real: ~A, floors: ~A ~A ~A ~A"+;						    n (denominator n) (numerator n) (imag-part n) (real-part n)+;						    (floor n) (ceiling n) (truncate n) (round n))+;					    (if (and (rational? n)+;						     (not (integer? n))+;						     (or (not (= (imag-part n) 0))+;							 (= (denominator n) 1)+;							 (= (denominator n) 0)+;							 (not (= n (real-part n)))+;							 (not (= n (/ (numerator n) (denominator n))))))+;						(format #t ", ~A ratio but imag: ~A, den: ~A, real: ~A, ~A/~A=~A"+;							n (imag-part n) (denominator n) (real-part n)+;							(numerator n) (denominator n) (exact->inexact (/ (numerator n) (denominator n))))+;						(if (and (real? n)+;							 (not (rational? n))+;							 (or (not (= (imag-part n) 0))+;							     (not (= n (real-part n)))))+;						    (format #t ", ~A real but rational: ~A, imag: ~A, real: ~A"+;							    n (rational? n) (imag-part n) (real-part n))+;						    (format #t ", ~A complex but real? ~A, imag: ~A, ~A+~A=~A"+;							    n (real? n) (imag-part n) (real-part n) (imag-part n)+;							    (+ (real-part n) (* 0+i (imag-part n)))))))))))))))+	    (newline)))))++(define-syntax num-test (syntax-rules () ((_ tst expected) (begin+  (let ((result (catch #t (lambda () tst) (lambda args 'error))))+     (number-ok? 'tst result expected)+     ))+ )))++;;; --------------------------------------------------------------------------------+;;; GENERIC STUFF+;;; --------------------------------------------------------------------------------++(test (eq? 'a 3) #f)+(test (eq? #t 't) #f)+(test (eq? "abs" 'abc) #f)+(test (eq? "hi" '(hi)) #f)+(test (eq? "()" '()) #f)+(test (eq? #\a #\b) #f)+(test (eq? #t #t) #t)+(test (eq? #f #f) #t)+(test (eq? #f #t) #f)+(test (eq? (null? '()) #t) #t)+(test (eq? (null? '(a)) #f) #t)+(test (eq? (cdr '(a)) '()) #t)+(test (eq? 'a 'a) #t)+(test (eq? 'a 'b) #f)+(test (eq? 'a (string->symbol "a")) #t)+(test (eq? '(a) '(b)) #f)+(test (let ((x '(a . b))) (eq? x x)) #t)+(test (let ((x (cons 'a 'b))) (eq? x x)) #t)+(test (eq? (cons 'a 'b) (cons 'a 'b)) #f)+(test (eq? "abc" "cba") #f)+(test (let ((x "hi")) (eq? x x)) #t)+(test (eq? (string #\h #\i) (string #\h #\i)) #f)+(test (eq? '#(a) '#(b)) #f)+(test (let ((x (vector 'a))) (eq? x x)) #t)+(test (eq? (vector 'a) (vector 'a)) #f)+(test (eq? car car) #t)+(test (eq? car cdr) #f)+(test (let ((x (lambda () 1))) (eq? x x)) #t)+(test (eq? 'abc 'abc) #t)+(test (eq? eq? eq?) #t)+(test (eq? (if #f 1) 1) #f)+;(test (eq? call/cc call-with-current-continuation) #t)+; guile accepts (eq? #t #t #t)+(test (eq? 3/4 3) #f)+(test (eq? '() '()) #t)+(test (eq? '() (list)) #t)++(let ((things (vector #t #f #\space '() "" 0 1 3/4 1+i 1.5 '(1 .2) '#() (vector) (vector 1) (list 1) 'f 't #\t)))+  (do ((i 0 (+ i 1)))+      ((= i (- (vector-length things) 1)))+    (do ((j (+ i 1) (+ j 1)))+	((= j (vector-length things)))+      (if (eq? (vector-ref things i) (vector-ref things j))+	  (begin+	    (display "(eq? ") (display (vector-ref things i)) (display " ") (display (vector-ref things j)) (display ") -> #t?") (newline))))))++++(test (eqv? 'a 3) #f)+(test (eqv? #t 't) #f)+(test (eqv? "abs" 'abc) #f)+(test (eqv? "hi" '(hi)) #f)+(test (eqv? "()" '()) #f)+(test (eqv? #\a #\b) #f)+(test (eqv? #\a #\a) #t)+(test (let ((x (string-ref "hi" 0))) (eqv? x x)) #t)+(test (eqv? #t #t) #t)+(test (eqv? #f #f) #t)+(test (eqv? #f #t) #f)+(test (eqv? (null? '()) #t) #t)+(test (eqv? (null? '(a)) #f) #t)+(test (eqv? (cdr '(a)) '()) #t)+(test (eqv? 'a 'a) #t)+(test (eqv? 'a 'b) #f)+(test (eqv? 'a (string->symbol "a")) #t)+(test (eqv? '(a) '(b)) #f)+(test (let ((x '(a . b))) (eqv? x x)) #t)+(test (let ((x (cons 'a 'b))) (eqv? x x)) #t)+(test (eqv? (cons 'a 'b) (cons 'a 'b)) #f)+(test (eqv? "abc" "cba") #f)+(test (let ((x "hi")) (eqv? x x)) #t)+(test (eqv? (string #\h #\i) (string #\h #\i)) #f)+(test (eqv? '#(a) '#(b)) #f)+(test (let ((x (vector 'a))) (eqv? x x)) #t)+(test (eqv? (vector 'a) (vector 'a)) #f)+(test (eqv? car car) #t)+(test (eqv? car cdr) #f)+(test (let ((x (lambda () 1))) (eqv? x x)) #t)+(test (eqv? 9/2 9/2) #t)+;(test (eqv? 3.4 (+ 3.0 0.4)) #t) ; can be fooled+(test (let ((x 3.141)) (eqv? x x)) #t)+(test (eqv? (cons 'a 'b) (cons 'a 'c)) #f)+(test (eqv? eqv? eqv?) #t)+;(test (let ((quote -)) (eqv? '1 1)) #f)+(test (eqv? '#(1) '#(1)) #f)+(test (eqv? '(1) '(1)) #f)+(test (eqv? '() '()) #t)+(test (eqv? '() (list)) #t)++(let ((things (vector #t #f #\space '() "" 0 1 3/4 1+i 1.5 '(1 .2) '#() (vector) (vector 1) (list 1) 'f 't #\t)))+  (do ((i 0 (+ i 1)))+      ((= i (- (vector-length things) 1)))+    (do ((j (+ i 1) (+ j 1)))+	((= j (vector-length things)))+      (if (eqv? (vector-ref things i) (vector-ref things j))+	  (begin+	    (display "(eqv? ") (display (vector-ref things i)) (display " ") (display (vector-ref things j)) (display ") -> #t?") (newline))))))++++(test (equal? 'a 3) #f)+(test (equal? #t 't) #f)+(test (equal? "abs" 'abc) #f)+(test (equal? "hi" '(hi)) #f)+(test (equal? "()" '()) #f)+(test (equal? #\a #\b) #f)+(test (equal? #\a #\a) #t)+(test (let ((x (string-ref "hi" 0))) (equal? x x)) #t)+(test (equal? #t #t) #t)+(test (equal? #f #f) #t)+(test (equal? #f #t) #f)+(test (equal? (null? '()) #t) #t)+(test (equal? (null? '(a)) #f) #t)+(test (equal? (cdr '(a)) '()) #t)+(test (equal? 'a 'a) #t)+(test (equal? 'a 'b) #f)+(test (equal? 'a (string->symbol "a")) #t)+(test (equal? '(a) '(b)) #f)+(test (equal? '(a) '(a)) #t)+(test (let ((x '(a . b))) (equal? x x)) #t)+(test (let ((x (cons 'a 'b))) (equal? x x)) #t)+(test (equal? (cons 'a 'b) (cons 'a 'b)) #t)+(test (equal? "abc" "cba") #f)+(test (equal? "abc" "abc") #t)+(test (let ((x "hi")) (equal? x x)) #t)+(test (equal? (string #\h #\i) (string #\h #\i)) #t)+(test (equal? '#(a) '#(b)) #f)+(test (equal? '#(a) '#(a)) #t)+(test (let ((x (vector 'a))) (equal? x x)) #t)+(test (equal? (vector 'a) (vector 'a)) #t)+(test (equal? '#(1 2) (vector 1 2)) #t)+(test (equal? '#(1.0 2/3) (vector 1.0 2/3)) #t)+(test (equal? '#(1 2) (vector 1 2.0)) #f) ; 2 not equal 2.0!+(test (equal? '(1 . 2) (cons 1 2)) #t)+(test (equal? '#(1 "hi" #\a) (vector 1 "hi" #\a)) #t)+(test (equal? '#((1 . 2)) (vector (cons 1 2))) #t)+(test (equal? '#(1 "hi" #\a (1 . 2)) (vector 1 "hi" #\a (cons 1 2))) #t)+(test (equal? '#(#f hi (1 2) 1 "hi" #\a (1 . 2)) (vector #f 'hi (list 1 2) 1 "hi" #\a (cons 1 2))) #t)+(test (equal? '#(#(1) #(1)) (vector (vector 1) (vector 1))) #t)+(test (equal? '#(()) (vector '())) #t)+(test (equal? '#("hi" "ho") (vector "hi" '"ho")) #t)+(test (equal? (list 1 "hi" #\a) '(1 "hi" #\a)) #t)+(test (equal? (list 1.0 2/3) '(1.0 2/3)) #t)+(test (equal? (list 1 2) '(1 2.0)) #f)+(test (equal? '#(1.0+1.0i) (vector 1.0+1.0i)) #t)+(test (equal? (list 1.0+1.0i) '(1.0+1.0i)) #t)+(test (equal? '((())) (list (list (list)))) #t)+(test (equal? car car) #t)+(test (equal? car cdr) #f)+(test (let ((x (lambda () 1))) (equal? x x)) #t)+(test (equal? 9/2 9/2) #t)+;(test (equal? 3.4 (+ 3.0 0.4)) #t)+(test (let ((x 3.141)) (equal? x x)) #t)+(test (equal? 3 3) #t)+(test (equal? 3 3.0) #f)+(test (equal? 3.0 3.0) #t)+(test (equal? 3-4i 3-4i) #t)+(test (equal? (string #\c) "c") #t)+(test (equal? equal? equal?) #t)+(test (equal? (cons 1 (cons 2 3)) '(1 2 . 3)) #t)+(test (equal? '() '()) #t)+(test (equal? '() (list)) #t)++(test (equal? "asd""asd") #t) ; is this the norm?+(let ((streq (lambda (a b) (equal? a b)))) (test (streq "asd""asd") #t))++(let ((things (vector #t #f #\space '() "" 0 1 3/4 1+i 1.5 '(1 .2) '#() (vector 1) (list 1) 'f 't #\t)))+  (do ((i 0 (+ i 1)))+      ((= i (- (vector-length things) 1)))+    (do ((j (+ i 1) (+ j 1)))+	((= j (vector-length things)))+      (if (equal? (vector-ref things i) (vector-ref things j))+	  (begin+	    (display "(equal? ") (display (vector-ref things i)) (display " ") (display (vector-ref things j)) (display ") -> #t?") (newline))))))+++++(test (boolean? #f) #t)+(test (boolean? #t) #t)+(test (boolean? 0) #f)+(test (boolean? 1) #f)+(test (boolean? "") #f)+(test (boolean? #\0) #f)+(test (boolean? '()) #f)+(test (boolean? '#()) #f)+(test (boolean? 't) #f)+(test (boolean? (list)) #f)++(for-each+ (lambda (arg)+   (if (boolean? arg)+       (begin+	 (display "(boolean? ") (display arg) (display ") returned #t?") (newline))))+ (list "hi" (integer->char 65) 1 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f (lambda (a) (+ a 1))))++++(test (not #f) #t)+(test (not #t) #f)+(test (not (not #t)) #t)+(test (not 0) #f)+(test (not 1) #f)+(test (not '()) #f)+(test (not 't) #f)+(test (not (list)) #f)+(test (not (list 3)) #f)+(test (not 'nil) #f)+(test (not not) #f)++(for-each+ (lambda (arg)+   (if (not arg)+       (begin+	 (display "(not ") (display arg) (display ") returned #t?") (newline))))+ (list "hi" (integer->char 65) 1 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f (lambda (a) (+ a 1))))++++(test (symbol? 't) #t)+(test (symbol? "t") #f)+(test (symbol? '(t)) #f)+(test (symbol? #t) #f)+(test (symbol? 4) #f)+(test (symbol? 'foo) #t)+(test (symbol? (car '(a b))) #t)+(test (symbol? 'nil) #t)+(test (symbol? '()) #f)+(test (symbol? #f) #f)+(test (symbol? 'car) #t)+(test (symbol? '#f) #f)+(test (symbol? 'sym0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789) #t) ;M Gran+(test (symbol? (vector-ref '#(1 a 34) 1)) #t)++(for-each+ (lambda (arg)+   (if (symbol? arg)+       (begin+	 (display "(symbol? ") (display arg) (display ") returned #t?") (newline))))+ (list "hi" (integer->char 65) 1 (list 1 2) '#t '3 (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f (lambda (a) (+ a 1))))++++(test (procedure? car) #t)+(test (procedure? procedure?) #t)+(test (procedure? 'car) #f)+(test (procedure? (lambda (x) x)) #t)+(test (procedure? '(lambda (x) x)) #f)+;(test (call/cc procedure?) #t) ; ??+(test (let ((a (lambda (x) x)))	(procedure? a)) #t)+(test (letrec ((a (lambda () (procedure? a)))) (a)) #t)+(test (let ((a 1)) (let ((a (lambda () (procedure? a)))) (a))) #f)++(for-each+ (lambda (arg)+   (if (procedure? arg)+       (begin+	 (display "(procedure? ") (display arg) (display ") returned #t?") (newline))))+ (list "hi" (integer->char 65) 1 (list 1 2) '#t '3 (make-vector 3) 3.14 3/4 1.0+1.0i #\f))+++++;;; --------------------------------------------------------------------------------+;;; CHARACTERS+;;; --------------------------------------------------------------------------------++(test (eqv? '#\  #\space) #t)+(test (eqv? #\space '#\space) #t)++(test (char? #\a) #t)+(test (char? #\() #t)+(test (char? #\space) #t)+(test (char? '#\newline) #t)+(test (char? #\1) #t)+(test (char? #\$) #t)+(test (char? #\.) #t)+(test (char? #\\) #t)+(test (char? #\)) #t)+(test (char? #\%) #t)+(test (char? '#\space) #t)+(test (char? '#\ ) #t)+(test (char? '#\newline) #t)+(test (char? '#\a) #t)+(test (char? '#\8) #t)+(test (char? #\-) #t)+(test (char? #\n) #t)+(test (char? #\() #t)+(test (char? #e1) #f)+(test (char? #\#) #t)+(test (char? #\x) #t)+(test (char? #\o) #t)+(test (char? #\b) #t)+(test (char? #b101) #f)+(test (char? #o73) #f)+(test (char? #x73) #f)+(test (char? 'a) #f)+(test (char? 97) #f)+(test (char? "a") #f)+(test (char? (string-ref "hi" 0)) #t)+(test (char? (string-ref (make-string 1) 0)) #t)+(test (char? #\") #t)+(test (char? #\') #t)+(test (char? #\`) #t)+(test (char? #\@) #t)++(for-each+ (lambda (arg)+   (if (char? arg)+       (begin+	 (display "(char? ") (display arg) (display ") returned #t?") (newline))))+ (list "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #f #t (lambda (a) (+ a 1))))++(do ((i 0 (+ i 1)))+    ((= i 256))+   (if (not (char? (integer->char i)))+       (begin+	 (display "(char? (integer->char ") (display i) (display ")) returned #f?") (newline))))++(num-test (let ((str (make-string 258 #\space)))+	    (do ((i 1 (+ i 1)))+		((= i 256))+	      (string-set! str i (integer->char i)))+	    (string-set! str 257 (integer->char 0))+	    (string-length str))+	  258)+++(let ((a-to-z (list #\a #\b #\c #\d #\e #\f #\g #\h #\i #\j #\k #\l #\m #\n #\o #\p #\q #\r #\s #\t #\u #\v #\x #\y #\z))+      (cap-a-to-z (list #\A #\B #\C #\D #\E #\F #\G #\H #\I #\J #\K #\L #\M #\N #\O #\P #\Q #\R #\S #\T #\U #\V #\X #\Y #\Z))+      (mixed-a-to-z (list #\a #\B #\c #\D #\e #\F #\g #\H #\I #\j #\K #\L #\m #\n #\O #\p #\Q #\R #\s #\t #\U #\v #\X #\y #\Z))+      (digits (list #\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)))+++  (test (char-upper-case? #\a) #f)+  (test (char-upper-case? #\A) #t)++  (for-each+   (lambda (arg)+     (if (not (char-upper-case? arg))+	 (begin+	   (display "(char-upper-case? ") (display arg) (display ") returned #f?") (newline))))+   cap-a-to-z)++  (for-each+   (lambda (arg)+     (if (char-upper-case? arg)+	 (begin+	   (display "(char-upper-case? ") (display arg) (display ") returned #t?") (newline))))+   a-to-z)++  ;; non-alpha chars are "unspecified" here+++  (test (char-lower-case? #\A) #f)+  (test (char-lower-case? #\a) #t)++  (for-each+   (lambda (arg)+     (if (not (char-lower-case? arg))+	 (begin+	   (display "(char-lower-case? ") (display arg) (display ") returned #f?") (newline))))+   a-to-z)++  (for-each+   (lambda (arg)+     (if (char-lower-case? arg)+	 (begin+	   (display "(char-lower-case? ") (display arg) (display ") returned #t?") (newline))))+   cap-a-to-z)+++  (test (char-upcase #\A) #\A)+  (test (char-upcase #\a) #\A)+  (test (char-upcase #\?) #\?)+  (test (char-upcase #\$) #\$)+  (test (char-upcase #\.) #\.)+  (test (char-upcase #\\) #\\)+  (test (char-upcase #\5) #\5)+  (test (char-upcase #\)) #\))+  (test (char-upcase #\%) #\%)+  (test (char-upcase #\0) #\0)+  (test (char-upcase #\_) #\_)+  (test (char-upcase #\space) #\space)+  (test (char-upcase #\newline) #\newline)++  (for-each+   (lambda (arg1 arg2)+     (if (not (char=? (char-upcase arg1) arg2))+	 (begin+	   (display "(char-upcase ") (display arg1) (display ") returned ") (display arg2) (display "?") (newline))))+   a-to-z+   cap-a-to-z)++  (do ((i 1 (+ i 1)))+      ((= i 128))+    (if (and (not (char=? (integer->char i) (char-upcase (integer->char i))))+	     (not (char-alphabetic? (integer->char i))))+	(begin+	  (display "(char-upcase ") (display (integer->char i)) (display ") -> ")+	  (display (integer->char i)) (display ", but not alphabetic?")+	  (newline))))++  (test (char-downcase #\A) #\a)+  (test (char-downcase #\a) #\a)+  (test (char-downcase #\?) #\?)+  (test (char-downcase #\$) #\$)+  (test (char-downcase #\.) #\.)+  (test (char-downcase #\_) #\_)+  (test (char-downcase #\\) #\\)+  (test (char-downcase #\5) #\5)+  (test (char-downcase #\)) #\))+  (test (char-downcase #\%) #\%)+  (test (char-downcase #\0) #\0)+  (test (char-downcase #\space) #\space)++  (for-each+   (lambda (arg1 arg2)+     (if (not (char=? (char-downcase arg1) arg2))+	 (begin+	   (display "(char-downcase ") (display arg1) (display ") returned ") (display arg2) (display "?") (newline))))+   cap-a-to-z+   a-to-z)+++  (test (char-numeric? #\a) #f)+  (test (char-numeric? #\5) #t)+  (test (char-numeric? #\A) #f)+  (test (char-numeric? #\z) #f)+  (test (char-numeric? #\Z) #f)+  (test (char-numeric? #\0) #t)+  (test (char-numeric? #\9) #t)+  (test (char-numeric? #\space) #f)+  (test (char-numeric? #\;) #f)+  (test (char-numeric? #\.) #f)+  (test (char-numeric? #\-) #f)++  (for-each+   (lambda (arg)+     (if (char-numeric? arg)+	 (begin+	   (display "(char-numeric? ") (display arg) (display ") returned #t?") (newline))))+   cap-a-to-z)++  (for-each+   (lambda (arg)+     (if (char-numeric? arg)+	 (begin+	   (display "(char-numeric? ") (display arg) (display ") returned #t?") (newline))))+   a-to-z)+++  (test (char-whitespace? #\a) #f)+  (test (char-whitespace? #\A) #f)+  (test (char-whitespace? #\z) #f)+  (test (char-whitespace? #\Z) #f)+  (test (char-whitespace? #\0) #f)+  (test (char-whitespace? #\9) #f)+  (test (char-whitespace? #\space) #t)+  (test (char-whitespace? #\newline) #t)+  (test (char-whitespace? #\;) #f)++  (for-each+   (lambda (arg)+     (if (char-whitespace? arg)+	 (begin+	   (display "(char-whitespace? ") (display arg) (display ") returned #t?") (newline))))+   mixed-a-to-z)++  (for-each+   (lambda (arg)+     (if (char-whitespace? arg)+	 (begin+	   (display "(char-whitespace? ") (display arg) (display ") returned #t?") (newline))))+   digits)+++  (test (char-alphabetic? #\a) #t)+  (test (char-alphabetic? #\$) #f)+  (test (char-alphabetic? #\A) #t)+  (test (char-alphabetic? #\z) #t)+  (test (char-alphabetic? #\Z) #t)+  (test (char-alphabetic? #\0) #f)+  (test (char-alphabetic? #\9) #f)+  (test (char-alphabetic? #\space) #f)+  (test (char-alphabetic? #\;) #f)+  (test (char-alphabetic? #\.) #f)+  (test (char-alphabetic? #\-) #f)+  (test (char-alphabetic? #\_) #f)+  (test (char-alphabetic? #\^) #f)+  (test (char-alphabetic? #\[) #f)++  (for-each+   (lambda (arg)+     (if (char-alphabetic? arg)+	 (begin+	   (display "(char-alphabetic? ") (display arg) (display ") returned #t?") (newline))))+   digits)++  (for-each+   (lambda (arg)+     (if (not (char-alphabetic? arg))+	 (begin+	   (display "(char-alphabetic? ") (display arg) (display ") returned #f?") (newline))))+   mixed-a-to-z)+++  (test (char=? #\d #\d) #t)+  (test (char=? #\A #\a) #f)+  (test (char=? #\d #\x) #f)+  (test (char=? #\d #\D) #f)+  (test (char=? #\a #\a) #t)+  (test (char=? #\A #\B) #f)+  (test (char=? #\a #\b) #f)+  (test (char=? #\9 #\0) #f)+  (test (char=? #\A #\A) #t)+  (test (char=? #\  #\space) #t)+  (let ((i (char->integer #\space)))+    (test (char=? (integer->char i) #\space) #t))+  (test (char=? (integer->char (char->integer #\")) #\") #t)++  (test (char<? #\z #\0) #f)+  (test (char<? #\d #\x) #t)+  (test (char<? #\d #\d) #f)+  (test (char<? #\d #\x) #t)+  (test (char<? #\A #\B) #t)+  (test (char<? #\a #\b) #t)+  (test (char<? #\9 #\0) #f)+  (test (char<? #\A #\A) #f)+  (test (char<? #\space #\space) #f)++  (test (char<=? #\d #\x) #t)+  (test (char<=? #\d #\d) #t)+  (test (char<=? #\A #\B) #t)+  (test (char<=? #\a #\b) #t)+  (test (char<=? #\9 #\0) #f)+  (test (char<=? #\A #\A) #t)+  (test (char<=? #\space #\space) #t)++  (test (char>? #\e #\d) #t)+  (test (char>? #\z #\a) #t)+  (test (char>? #\A #\B) #f)+  (test (char>? #\a #\b) #f)+  (test (char>? #\9 #\0) #t)+  (test (char>? #\A #\A) #f)+  (test (char>? #\space #\space) #f)++  (test (char>=? #\e #\d) #t)+  (test (char>=? #\A #\B) #f)+  (test (char>=? #\a #\b) #f)+  (test (char>=? #\9 #\0) #t)+  (test (char>=? #\A #\A) #t)+  (test (char>=? #\space #\space) #t)++  (test (char-ci=? #\A #\B) #f)+  (test (char-ci=? #\a #\B) #f)+  (test (char-ci=? #\A #\b) #f)+  (test (char-ci=? #\a #\b) #f)+  (test (char-ci=? #\9 #\0) #f)+  (test (char-ci=? #\A #\A) #t)+  (test (char-ci=? #\A #\a) #t)+  (test (char-ci=? #\a #\A) #t)+  (test (char-ci=? #\space #\space) #t)++  (test (char-ci<? #\A #\B) #t)+  (test (char-ci<? #\a #\B) #t)+  (test (char-ci<? #\A #\b) #t)+  (test (char-ci<? #\a #\b) #t)+  (test (char-ci<? #\9 #\0) #f)+  (test (char-ci<? #\0 #\9) #t)+  (test (char-ci<? #\A #\A) #f)+  (test (char-ci<? #\A #\a) #f)+  (test (char-ci<? #\Y #\_) #t)+  (test (char-ci<? #\\ #\J) #f)+;  (test (char-ci<? #\_ #\e) #f)+;  (test (char-ci<? #\t #\_) #t)+;  (test (char-ci<? #\a #\]) #t)+;  (test (char-ci<? #\z #\^) #t)+++;;; this tries them all:+;(do ((i 0 (+ i 1)))+;    ((= i 128))+;  (do ((k 0 (+ k 1)))+;      ((= k 128))+;    (let ((c1 (integer->char i))+;	  (c2 (integer->char k)))+;      (for-each+;       (lambda (op1 op2)+;	 (if (not (eq? (op1 c1 c2) (op2 (string c1) (string c2))))+;	     (format #t "(~A|~A ~A ~A) -> ~A|~A~%" op1 op2 c1 c2 (op1 c1 c2) (op2 (string c1) (string c2)))))+;       (list char=? char<? char<=? char>? char>=? char-ci=? char-ci<? char-ci<=? char-ci>? char-ci>=?)+;       (list string=? string<? string<=? string>? string>=? string-ci=? string-ci<? string-ci<=? string-ci>? string-ci>=?)))))+++  (test (char-ci>? #\A #\B) #f)+  (test (char-ci>? #\a #\B) #f)+  (test (char-ci>? #\A #\b) #f)+  (test (char-ci>? #\a #\b) #f)+  (test (char-ci>? #\9 #\0) #t)+  (test (char-ci>? #\A #\A) #f)+  (test (char-ci>? #\A #\a) #f)+;  (test (char-ci>? #\^ #\a) #t)+;  (test (char-ci>? #\_ #\e) #t)+  (test (char-ci>? #\[ #\S) #t)+;  (test (char-ci>? #\\ #\l) #t)+;  (test (char-ci>? #\t #\_) #f)+;  (test (char-ci>? #\a #\]) #f)+;  (test (char-ci>? #\z #\^) #f)+  (test (char-ci>? #\] #\X) #t)++  (test (char-ci<=? #\A #\B) #t)+  (test (char-ci<=? #\a #\B) #t)+  (test (char-ci<=? #\A #\b) #t)+  (test (char-ci<=? #\a #\b) #t)+  (test (char-ci<=? #\9 #\0) #f)+  (test (char-ci<=? #\A #\A) #t)+  (test (char-ci<=? #\A #\a) #t)+  (test (char-ci<=? #\` #\H) #f)+;  (test (char-ci<=? #\[ #\m) #f)+;  (test (char-ci<=? #\j #\`) #t)+  (test (char-ci<=? #\\ #\E) #f)+;  (test (char-ci<=? #\t #\_) #t)+;  (test (char-ci<=? #\a #\]) #t)+;  (test (char-ci<=? #\z #\^) #t)++  (test (char-ci>=? #\A #\B) #f)+  (test (char-ci>=? #\a #\B) #f)+  (test (char-ci>=? #\A #\b) #f)+  (test (char-ci>=? #\a #\b) #f)+  (test (char-ci>=? #\9 #\0) #t)+  (test (char-ci>=? #\A #\A) #t)+  (test (char-ci>=? #\A #\a) #t)+  (test (char-ci>=? #\Y #\_) #f)+  (test (char-ci>=? #\` #\S) #t)+  (test (char-ci>=? #\[ #\Y) #t)+;  (test (char-ci>=? #\t #\_) #f)+;  (test (char-ci>=? #\a #\]) #f)+;  (test (char-ci>=? #\z #\^) #f)+  ) ; end let with a-to-z+++(test (integer->char (char->integer #\.)) #\.)+(test (integer->char (char->integer #\A)) #\A)+(test (integer->char (char->integer #\a)) #\a)+(test (integer->char (char->integer #\space)) #\space)+++++;;; --------------------------------------------------------------------------------+;;; STRINGS+;;; --------------------------------------------------------------------------------++(test (string? "abc") #t)+(test (string? ':+*/-) #f)+(test (string? "das ist einer der teststrings") #t)+(test (string? '(das ist natuerlich falsch)) #f)+(test (string? "aaaaaa") #t)+(test (string? #\a) #f)+(test (string? "\"\\\"") #t)++(for-each+ (lambda (arg)+   (test (string? arg) #f))+ (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))+++(test (string=? "foo" "foo") #t)+(test (string=? "foo" "FOO") #f)+(test (string=? "foo" "bar") #f)+(test (string=? "FOO" "FOO") #t)+(test (string=? "A" "B") #f)+(test (string=? "a" "b") #f)+(test (string=? "9" "0") #f)+(test (string=? "A" "A") #t)+(test (string=? "" "") #t)+(test (string=? (string #\newline) (string #\newline)) #t)++(test (let ((str (string #\" #\1 #\\ #\2 #\")))	(string=? str "\"1\\2\"")) #t)+(test (let ((str (string #\\ #\\ #\\)))	(string=? str "\\\\\\")) #t)+(test (let ((str (string #\")))	(string=? str "\"")) #t)+(test (let ((str (string #\\ #\"))) (string=? str "\\\"")) #t)+(test (let ((str (string #\space #\? #\)))) (string=? str " ?)")) #t)+(test (let ((str (string #\# #\\ #\t))) (string=? str "#\\t")) #t)+(test (let ((str (string #\# #\\ #\t))) (string-length str)) 3)+++(test (string<? "aaaa" "aaab") #t)+(test (string<? "aaaa" "aaaaa") #t)+(test (string<? "" "abcdefgh") #t)+(test (string<? "a" "abcdefgh") #t)+(test (string<? "abc" "abcdefgh") #t)+(test (string<? "cabc" "abcdefgh") #f)+(test (string<? "abcdefgh" "abcdefgh") #f)+(test (string<? "xyzabc" "abcdefgh") #f)+(test (string<? "abc" "xyzabcdefgh") #t)+(test (string<? "abcdefgh" "") #f)+(test (string<? "abcdefgh" "a") #f)+(test (string<? "abcdefgh" "abc") #f)+(test (string<? "abcdefgh" "cabc") #t)+(test (string<? "abcdefgh" "xyzabc") #t)+(test (string<? "xyzabcdefgh" "abc") #f)+(test (string<? "abcdef" "bcdefgh") #t)+(test (string<? "" "abcdefgh") #t)+(test (string<? "" "") #f)+(test (string<? "A" "B") #t)+(test (string<? "a" "b") #t)+(test (string<? "9" "0") #f)+(test (string<? "A" "A") #f)+(test (string>? "aaab" "aaaa") #t)+(test (string>? "aaaaa" "aaaa") #t)+(test (string>? "" "abcdefgh") #f)+(test (string>? "a" "abcdefgh") #f)+(test (string>? "abc" "abcdefgh") #f)+(test (string>? "cabc" "abcdefgh") #t)+(test (string>? "abcdefgh" "abcdefgh") #f)+(test (string>? "xyzabc" "abcdefgh") #t)+(test (string>? "abc" "xyzabcdefgh") #f)+(test (string>? "abcdefgh" "") #t)+(test (string>? "abcdefgh" "a") #t)+(test (string>? "abcdefgh" "abc") #t)+(test (string>? "abcdefgh" "cabc") #f)+(test (string>? "abcdefgh" "xyzabc") #f)+(test (string>? "xyzabcdefgh" "abc") #t)+(test (string>? "abcde" "bc") #f)+(test (string>? "bcdef" "abcde") #t)+(test (string>? "bcdef" "abcdef") #t)+(test (string>? "" "") #f)+(test (string>? "A" "B") #f)+(test (string>? "a" "b") #f)+(test (string>? "9" "0") #t)+(test (string>? "A" "A") #f)++(test (string<=? "aaa" "aaaa") #t)+(test (string<=? "aaaaa" "aaaa") #f)+(test (string<=? "a" "abcdefgh") #t)+(test (string<=? "abc" "abcdefgh") #t)+(test (string<=? "aaabce" "aaabcdefgh") #f)+(test (string<=? "cabc" "abcdefgh") #f)+(test (string<=? "abcdefgh" "abcdefgh") #t)+(test (string<=? "xyzabc" "abcdefgh") #f)+(test (string<=? "abc" "xyzabcdefgh") #t)+(test (string<=? "abcdefgh" "") #f)+(test (string<=? "abcdefgh" "a") #f)+(test (string<=? "abcdefgh" "abc") #f)+(test (string<=? "abcdefgh" "cabc") #t)+(test (string<=? "abcdefgh" "xyzabc") #t)+(test (string<=? "xyzabcdefgh" "abc") #f)+(test (string<=? "abcdef" "bcdefgh") #t)+(test (string<=? "" "") #t)+(test (string<=? "A" "B") #t)+(test (string<=? "a" "b") #t)+(test (string<=? "9" "0") #f)+(test (string<=? "A" "A") #t)++(test (string>=? "aaaaa" "aaaa") #t)+(test (string>=? "aaaa" "aaaa") #t)+(test (string>=? "aaa" "aaaa") #f)+(test (string>=? "" "abcdefgh") #f)+(test (string>=? "a" "abcdefgh") #f)+(test (string>=? "abc" "abcdefgh") #f)+(test (string>=? "cabc" "abcdefgh") #t)+(test (string>=? "abcdefgh" "abcdefgh") #t)+(test (string>=? "xyzabc" "abcdefgh") #t)+(test (string>=? "abc" "xyzabcdefgh") #f)+(test (string>=? "abcdefgh" "") #t)+(test (string>=? "abcdefgh" "a") #t)+(test (string>=? "abcdefgh" "abc") #t)+(test (string>=? "abcdefgh" "cabc") #f)+(test (string>=? "abcdefgh" "xyzabc") #f)+(test (string>=? "xyzabcdefgh" "abc") #t)+(test (string>=? "bcdef" "abcdef") #t)+(test (string>=? "A" "B") #f)+(test (string>=? "a" "b") #f)+(test (string>=? "9" "0") #t)+(test (string>=? "A" "A") #t)+(test (string>=? "" "") #t)+++(test (string-ci=? "A" "B") #f)+(test (string-ci=? "a" "B") #f)+(test (string-ci=? "A" "b") #f)+(test (string-ci=? "a" "b") #f)+(test (string-ci=? "9" "0") #f)+(test (string-ci=? "A" "A") #t)+(test (string-ci=? "A" "a") #t)+(test (string-ci=? "" "") #t)+(test (string-ci=? "aaaa" "AAAA") #t)+(test (string-ci=? "aaaa" "Aaaa") #t)+++(test (string-ci<? "a" "Aa") #t)+(test (string-ci<? "A" "B") #t)+(test (string-ci<? "a" "B") #t)+(test (string-ci<? "A" "b") #t)+(test (string-ci<? "a" "b") #t)+(test (string-ci<? "9" "0") #f)+(test (string-ci<? "0" "9") #t)+(test (string-ci<? "A" "A") #f)+(test (string-ci<? "A" "a") #f)+(test (string-ci<? "" "") #f)++;(test (string-ci<? "t" "_") #t)+;(test (string-ci<? "a" "]") #t)+;(test (string-ci<? "z" "^") #t)+(test (string-ci<? "]4.jVKo\\\\^:\\A9Z4" "MImKA[mNv1`") #f)+++(test (string-ci>? "Aaa" "AA") #t)+(test (string-ci>? "A" "B") #f)+(test (string-ci>? "a" "B") #f)+(test (string-ci>? "A" "b") #f)+(test (string-ci>? "a" "b") #f)+(test (string-ci>? "9" "0") #t)+(test (string-ci>? "A" "A") #f)+(test (string-ci>? "A" "a") #f)+(test (string-ci>? "" "") #f)+(test (string-ci>? "Z" "DjNTl0") #t)+(test (string-ci>? "2399dt7BVN[,A" "^KHboHV") #f)++;(test (string-ci>? "t" "_") #f)+;(test (string-ci>? "a" "]") #f)+;(test (string-ci>? "z" "^") #f)+(test (string-ci>? "R*95oG.k;?" "`2?J6LBbLG^alB[fMD") #f)+(test (string-ci>? "]" "X") #t)++(test (string-ci<=? "A" "B") #t)+(test (string-ci<=? "a" "B") #t)+(test (string-ci<=? "A" "b") #t)+(test (string-ci<=? "a" "b") #t)+(test (string-ci<=? "9" "0") #f)+(test (string-ci<=? "A" "A") #t)+(test (string-ci<=? "A" "a") #t)+(test (string-ci<=? "" "") #t)+(test (string-ci<=? ":LPC`" ",O0>affA?(") #f)++;(test (string-ci<=? "t" "_") #t)+;(test (string-ci<=? "a" "]") #t)+;(test (string-ci<=? "z" "^") #t)+(test (string-ci<=? "G888E>beF)*mwCNnagP" "`2uTd?h") #t)++(test (string-ci>=? "A" "B") #f)+(test (string-ci>=? "a" "B") #f)+(test (string-ci>=? "A" "b") #f)+(test (string-ci>=? "a" "b") #f)+(test (string-ci>=? "9" "0") #t)+(test (string-ci>=? "A" "A") #t)+(test (string-ci>=? "A" "a") #t)+(test (string-ci>=? "" "") #t)+(test (string-ci>=? "5d7?[o[:hop=ktv;9)" "p^r9;TAXO=^") #f)++;(test (string-ci>=? "t" "_") #f)+;(test (string-ci>=? "a" "]") #f)+;(test (string-ci>=? "z" "^") #f)+;(test (string-ci>=? "jBS" "`<+s[[:`l") #f)++++(test (string-length "abc") 3)+(test (string-length "") 0)+(test (string-length (string)) 0)+(test (string-length "\"\\\"") 3)+(test (string-length (string #\newline)) 1)+(test (string-length "hi there") 8)+(test (string-length "\"") 1)+(test (string-length (make-string 100 #\a)) 100)+++++(test (string) "")+(test (string #\a #\b #\c) "abc")+(test (string #\a) "a")++++(test (make-string 0) "")+(test (make-string 3 #\a) "aaa")+(test (make-string 0 #\a) "")+(test (make-string 3 #\space) "   ")+(test (let ((hi (make-string 3 #\newline))) (string-length hi)) 3)++++(test (string-ref "abcdef-dg1ndh" 0) #\a)+(test (string-ref "abcdef-dg1ndh" 1) #\b)+(test (string-ref "abcdef-dg1ndh" 6) #\-)+(test (string-ref "\"\\\"" 1) #\\)+(test (string-ref "\"\\\"" 2) #\")++++(test (let ((hi (string-copy "hi"))) (string-set! hi 0 #\H) hi) "Hi")+(test (let ((hi (string-copy "hi"))) (string-set! hi 1 #\H) hi) "hH")+(test (let ((hi (string-copy "\"\\\""))) (string-set! hi 0 #\a) hi) "a\\\"")+(test (let ((hi (string-copy "\"\\\""))) (string-set! hi 1 #\a) hi) "\"a\"")+(test (let ((hi (string #\a #\newline #\b))) (string-set! hi 1 #\c) hi) "acb")++(let ((str (make-string 10 #\x)))+  (string-set! str 3 (integer->char 0))+;  (test (string=? str "xxx") #t)+  (test (char=? (string-ref str 4) #\x) #t)+  (string-set! str 4 #\a)+;  (test (string=? str "xxx") #t)+  (test (char=? (string-ref str 4) #\a) #t)+  (string-set! str 3 #\x)+  (test (string=? str "xxxxaxxxxx") #t))++++(test (substring "ab" 0 0) "")+(test (substring "ab" 1 1) "")+(test (substring "ab" 2 2) "")+(test (substring "ab" 0 1) "a")+(test (substring "ab" 1 2) "b")+(test (substring "ab" 0 2) "ab")+(test (substring "hi there" 3 6) "the")+(test (substring "hi there" 0 (string-length "hi there")) "hi there")+(test (substring "" 0 0) "")+(test (let ((str "012345"))+	(let ((str1 (substring str 2 4)))+	  (string-set! str1 1 #\x))+	(string=? str "012345"))+      #t)+++(test (string-append "hi" "ho") "hiho")+(test (string-append "hi") "hi")+(test (string-append "hi" "") "hi")+(test (string-append "hi" "" "ho") "hiho")+(test (string-append "" "hi") "hi")+(test (string-append) "")+(test (string-append "a" (string-append (string-append "b" "c") "d") "e") "abcde")+(test (string-append "a" "b" "c" "d" "e") "abcde")+(test (string-append (string-append) (string-append (string-append))) "")+(test (let ((hi "hi")) (let ((ho (string-append hi))) (eq? hi ho))) #f)+(test (let ((hi "hi")) (let ((ho (string-append hi))) (string-set! ho 0 #\a) hi)) "hi")+(test (let ((hi "hi")) (set! hi (string-append hi hi hi hi)) hi) "hihihihi")++(num-test (letrec ((hi (lambda (str n)+			 (if (= n 0)+			     str+			     (hi (string-append str "a") (- n 1))))))+	    (string-length (hi "" 100)))+	  100)++(test (let* ((str "hiho")+	     (str1 "ha")+	     (str2 (string-append str1 str)))+	(string-set! str2 1 #\x)+	(string-set! str2 4 #\x)+	(and (string=? str "hiho")+	     (string=? str1 "ha")+	     (string=? str2 "hxhixo")))+      #t)++(test (let* ((str (string-copy "hiho"))+	     (str1 (string-copy "ha"))+	     (str2 (string-append str1 str)))+	(string-set! str1 1 #\x)+	(string-set! str 2 #\x)+	(and (string=? str "hixo")+	     (string=? str1 "hx")+	     (string=? str2 "hahiho")))+      #t)++++(test (let ((hi (string-copy "hi"))) (string-fill! hi #\s) hi) "ss")+(test (let ((hi (string-copy ""))) (string-fill! hi #\x) hi) "")+(test (let ((str (make-string 0))) (string-fill! str #\a) str) "")+(test (let ((hi (make-string 8 (integer->char 0)))) (string-fill! hi #\a) hi) "aaaaaaaa") ; is this result widely accepted?++++(test (string-copy "ab") "ab")+(test (string-copy "") "")+(test (string-copy "\"\\\"") "\"\\\"")+(test (let ((hi "abc")) (eq? hi (string-copy hi))) #f)+(test (let ((hi (string-copy (make-string 8 (integer->char 0))))) (string-fill! hi #\a) hi) "aaaaaaaa") ; is this result widely accepted?+(test (string-copy (string-copy (string-copy "a"))) "a")+(test (string-copy (string-copy (string-copy ""))) "")++++(test (string->list "abc") (list #\a #\b #\c))+(test (string->list "") '())+;(test (string->list (make-string 3 (integer->char 0))) '()) ; others return a list of #\nul or #\null+(test (string->list (list->string (list #\a #\b #\c))) (list #\a #\b #\c))+(test (string->list (list->string '())) '())+(test (list->string (string->list "abc")) "abc")+(test (list->string (string->list "hi there")) "hi there")+(test (list->string (string->list "&*#%^@%$)~@")) "&*#%^@%$)~@")+(test (list->string (string->list "")) "")+(test (let* ((str "abc")+	     (lst (string->list str)))+	(and (string=? str "abc")+	     (equal? lst (list #\a #\b #\c))))+      #t)++(test (list->string (list #\a #\b #\c)) "abc")+(test (list->string (list)) "")++(test (list->string (list #\" #\# #\")) "\"#\"")+(test (list->string (list #\\ #\\ #\# #\\ #\# #\#)) "\\\\#\\##")+(test (list->string (list #\' #\' #\` #\")) '"''`\"")+(test (string #\" #\# #\") "\"#\"")+(test (string #\\ #\\ #\# #\\ #\# #\#) "\\\\#\\##")+(test (string #\' #\' #\` #\") '"''`\"")+;;; some schemes accept \' and other such sequences in a string, but the spec only mentions \\ and \"+++(test (symbol->string 'hi) "hi")+(test (symbol->string (string->symbol "()")) "()")+(test (string->symbol (symbol->string 'hi)) 'hi)+(test (eq? (string->symbol "hi") 'hi) #t)+(test (eq? (string->symbol "hi") (string->symbol "hi")) #t)++(test (string->symbol "hi") 'hi)++(test (let ((str (symbol->string 'hi)))+	;(catch #t (lambda () (string-set! str 1 #\x)) (lambda args 'error)) ; can be disallowed+	(symbol->string 'hi))+      "hi")++(test (symbol->string 'sym0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789)+      "sym0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789")+(test (string->symbol "sym0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789")+      'sym0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789)+(test (let ((sym0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 32))+	(+ sym0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 1))+      33)+++++;;; --------------------------------------------------------------------------------+;;; LISTS+;;; --------------------------------------------------------------------------------++(test (cons 'a '()) '(a))+(test (cons '(a) '(b c d)) '((a) b c d))+(test (cons "a" '(b c)) '("a" b c))+(test (cons 'a 3) '(a . 3))+(test (cons '(a b) 'c) '((a b) . c))+(test (cons '() '()) '(()))+(test (cons '() 1) '(() . 1))+(test (cons 1 2) '(1 . 2))+(test (cons 1 '()) '(1))+(test (cons '() 2) '(() . 2))+(test (cons 1 (cons 2 (cons 3 (cons 4 '())))) '(1 2 3 4))+(test (cons 'a 'b) '(a . b))+(test (cons 'a (cons 'b (cons 'c '()))) '(a b c))+(test (cons 'a (list 'b 'c 'd)) '(a b c d))+(test (cons 'a (cons 'b (cons 'c 'd))) '(a b c . d))+(test '(a b c d e) '(a . (b . (c . (d . (e . ()))))))+(test (cons (cons 1 2) (cons 3 4)) '((1 . 2) 3 . 4))+(test (list (cons 1 2) (cons 3 4)) '((1 . 2) (3 . 4)))+(test (cons (cons 1 (cons 2 3)) 4) '((1 . (2 . 3)) . 4))+(test (cons (cons 1 (cons 2 '())) (cons 1 2)) '((1 2) . (1 . 2)))+(test (let ((lst (list 1 2))) (list (apply cons lst) lst)) '((1 . 2) (1 2)))+(test (let ((lst (list 1 2))) (list lst (apply cons lst))) '((1 2) (1 . 2)))+(test (cdadr (let ((lst (list 1 2))) (list (apply cons lst) lst))) '(2))++(test (car (list 1 2 3)) 1)+(test (car (cons 1 2)) 1)+(test (car (list 1)) 1)+(test (car '(1 2 3)) 1)+(test (car '(1)) 1)+(test (car '(1 . 2)) 1)+(test (car '((1 2) 3)) '(1 2))+(test (car '(((1 . 2) . 3) 4)) '((1 . 2) . 3))+(test (car (list (list) (list 1 2))) '())+(test (car '(a b c)) 'a)+(test (car '((a) b c d)) '(a))+(test (car (reverse (list 1 2 3 4))) 4)+(test (car (list 'a 'b 'c 'd 'e 'f 'g)) 'a)+(test (car '(a b c d e f g)) 'a)+(test (car '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '((((1 2 3) 4) 5) (6 7)))+(test (car '(a)) 'a)+(test (car '(1 ^ 2)) 1)+;(test (car '(1 .. 2)) 1)+(test (car ''foo) 'quote)+(test (car '(1 2 . 3)) 1)++(for-each+ (lambda (arg)+   (if (not (equal? (car (cons arg '())) arg))+       (begin+	 (display "(car '(") (display arg) (display ")) returned ") (display (car (cons arg '()))) (display "?") (newline))))+ (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1))))+++(test (cdr (list 1 2 3)) '(2 3))+(test (cdr (cons 1 2)) 2)+(test (cdr (list 1)) '())+(test (cdr '(1 2 3)) '(2 3))+(test (cdr '(1)) '())+(test (cdr '(1 . 2)) 2)+(test (cdr '((1 2) 3)) '(3))+(test (cdr '(((1 . 2) . 3) 4)) '(4))+(test (cdr (list (list) (list 1 2))) '((1 2)))+(test (cdr '(a b c)) '(b c))+(test (cdr '((a) b c d)) '(b c d))+(test (equal? (cdr (reverse (list 1 2 3 4))) 4) #f)+(test (equal? (cdr (list 'a 'b 'c 'd 'e 'f 'g)) 'a) #f)+(test (cdr '((((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f) g)) '(g))+(test (cdr '(a)) '())+(test (cdr '(a b c d e f g)) '(b c d e f g))+(test (cdr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '((((u v w) x) y) ((q w e) r) (a b c) e f g))+(test (cdr ''foo) '(foo))+(test (cdr (cons (cons 1 2) (cons 3 4))) '(3 . 4))+(test (cdr '(1 2 . 3)) '(2 . 3))++(for-each+ (lambda (arg)+   (if (not (equal? (cdr (cons '() arg)) arg))+       (begin+	 (display "(cdr '(() ") (display arg) (display ")) returned ") (display (cdr (cons '() arg))) (display "?") (newline))))+ (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1))))++(define (cons-r a b n) (if (= 0 n) (cons a b) (cons (cons-r (+ a 1) (+ b 1) (- n 1)) (cons-r (- a 1) (- b 1) (- n 1)))))+(define (list-r a b n) (if (= 0 n) (list a b) (list (list-r (+ a 1) (+ b 1) (- n 1)) (list-r (- a 1) (- b 1) (- n 1)))))++(define lists (list (list 1 2 3)+		    (cons 1 2)+		    (list 1)+		    (list)+		    (list (list 1 2) (list 3 4))+		    (list (list 1 2) 3)+		    '(1 . 2)+		    '(a b c)+		    '((a) b (c))+		    '((1 2) (3 4))+		    '((1 2 3) (4 5 6) (7 8 9))+		    '(((1) (2) (3)) ((4) (5) (6)) ((7) (8) (9)))+		    '((((1 123) (2 124) (3 125) (4 126)) ((5) (6) (7) (8)) ((9) (10) (11) (12)) ((13) (14) (15) (16)))+		      (((21 127) (22 128) (23 129) (24 130)) ((25) (26) (27) (28)) ((29) (30) (31) (32)) ((33) (34) (35) (36)))+		      (((41 131) (42 132) (43 133) (44 134)) ((45) (46) (47) (48)) ((49) (50) (51) (52)) ((53) (54) (55) (56)))+		      (((61 135) (62 136) (63 137) (64 138)) ((65) (66) (67) (68)) ((69) (70) (71) (72)) ((73) (74) (75) (76)))+		      321)+		    (cons 1 (cons 2 (cons 3 4)))+		    (cons (cons 2 (cons 3 4)) 5)+		    (cons '() 1)+		    (cons 1 '())+		    (cons '() '())+		    (list 1 2 (cons 3 4) 5 (list (list 6) 7))+		    (cons-r 0 0 4)+		    (cons-r 0 0 5)+		    (cons-r 0 0 10)+		    (list-r 0 0 3)+		    (list-r 0 0 7)+		    (list-r 0 0 11)+		    ''a+		    ))+(define (caar-1 x) (car (car x)))+(define (cadr-1 x) (car (cdr x)))+(define (cdar-1 x) (cdr (car x)))+(define (cddr-1 x) (cdr (cdr x)))+(define (caaar-1 x) (car (car (car x))))+(define (caadr-1 x) (car (car (cdr x))))+(define (cadar-1 x) (car (cdr (car x))))+(define (caddr-1 x) (car (cdr (cdr x))))+(define (cdaar-1 x) (cdr (car (car x))))+(define (cdadr-1 x) (cdr (car (cdr x))))+(define (cddar-1 x) (cdr (cdr (car x))))+(define (cdddr-1 x) (cdr (cdr (cdr x))))+(define (caaaar-1 x) (car (car (car (car x)))))+(define (caaadr-1 x) (car (car (car (cdr x)))))+(define (caadar-1 x) (car (car (cdr (car x)))))+(define (caaddr-1 x) (car (car (cdr (cdr x)))))+(define (cadaar-1 x) (car (cdr (car (car x)))))+(define (cadadr-1 x) (car (cdr (car (cdr x)))))+(define (caddar-1 x) (car (cdr (cdr (car x)))))+(define (cadddr-1 x) (car (cdr (cdr (cdr x)))))+(define (cdaaar-1 x) (cdr (car (car (car x)))))+(define (cdaadr-1 x) (cdr (car (car (cdr x)))))+(define (cdadar-1 x) (cdr (car (cdr (car x)))))+(define (cdaddr-1 x) (cdr (car (cdr (cdr x)))))+(define (cddaar-1 x) (cdr (cdr (car (car x)))))+(define (cddadr-1 x) (cdr (cdr (car (cdr x)))))+(define (cdddar-1 x) (cdr (cdr (cdr (car x)))))+(define (cddddr-1 x) (cdr (cdr (cdr (cdr x)))))++;(for-each+; (lambda (name op1 op2)+;   (for-each+;    (lambda (lst)+;      (let ((val1 (catch #t (lambda () (op1 lst)) (lambda args 'error)))+;	    (val2 (catch #t (lambda () (op2 lst)) (lambda args 'error))))+;	(if (not (equal? val1 val2))+;	    (begin+;	      (display "(") (display name) (display " ") (display lst) (display ")) returned ") (display val1) (display " ") (display val2) (newline)))))+;    lists))+; (list 'caar 'cadr 'cdar 'cddr 'caaar 'caadr 'cadar 'cdaar 'caddr 'cdddr 'cdadr 'cddar+;       'caaaar 'caaadr 'caadar 'cadaar 'caaddr 'cadddr 'cadadr 'caddar 'cdaaar+;       'cdaadr 'cdadar 'cddaar 'cdaddr 'cddddr 'cddadr 'cdddar)+;+; (list caar cadr cdar cddr caaar caadr cadar cdaar caddr cdddr cdadr cddar+;       caaaar caaadr caadar cadaar caaddr cadddr cadadr caddar cdaaar+;       cdaadr cdadar cddaar cdaddr cddddr cddadr cdddar)+;+; (list caar-1 cadr-1 cdar-1 cddr-1 caaar-1 caadr-1 cadar-1 cdaar-1 caddr-1 cdddr-1 cdadr-1 cddar-1+;       caaaar-1 caaadr-1 caadar-1 cadaar-1 caaddr-1 cadddr-1 cadadr-1 caddar-1 cdaaar-1+;       cdaadr-1 cdadar-1 cddaar-1 cdaddr-1 cddddr-1 cddadr-1 cdddar-1))++++(test (equal? (cadr (list 'a 'b 'c 'd 'e 'f 'g)) 'b) #t)+(test (equal? (cddr (list 'a 'b 'c 'd 'e 'f 'g)) '(c d e f g)) #t)+(test (equal? (caddr (list 'a 'b 'c 'd 'e 'f 'g)) 'c) #t)+(test (equal? (cdddr (list 'a 'b 'c 'd 'e 'f 'g)) '(d e f g)) #t)+(test (equal? (cadddr (list 'a 'b 'c 'd 'e 'f 'g)) 'd) #t)+(test (equal? (cddddr (list 'a 'b 'c 'd 'e 'f 'g)) '(e f g)) #t)+(test (equal? (caadr (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '((u v w) x)) #t)+(test (equal? (cadar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(6 7)) #t)+(test (equal? (cdaar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(5)) #t)+(test (equal? (cdadr (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(y)) #t)+(test (equal? (cddar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '()) #t)+(test (equal? (caaaar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(1 2 3)) #t)+(test (equal? (caadar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) 6) #t)+(test (equal? (caaddr (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(q w e)) #t)+(test (equal? (cadaar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) 5) #t)+(test (equal? (cadadr (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) 'y) #t)+(test (equal? (caddar (list (list (list (list (list 1 2 3) 4) 5) 1 6 (list 5 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) 6) #t)+(test (equal? (cadddr (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(a b c)) #t)+(test (equal? (cdaaar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(4)) #t)+(test (equal? (cdaadr (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(x)) #t)+(test (equal? (cdadar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(7)) #t)++(test (caar '((a) b c d e f g)) 'a)+(test (cadr '(a b c d e f g)) 'b)+(test (cdar '((a b) c d e f g)) '(b))+(test (cddr '(a b c d e f g)) '(c d e f g))+(test (caaar '(((a)) b c d e f g)) 'a)+(test (caadr '(a (b) c d e f g)) 'b)+(test (cadar '((a b) c d e f g)) 'b)+(test (caddr '(a b c d e f g)) 'c)+(test (cdaar '(((a b)) c d e f g)) '(b))+(test (cdadr '(a (b c) d e f g)) '(c))+(test (cddar '((a b c) d e f g)) '(c))+(test (cdddr '(a b c d e f g)) '(d e f g))+(test (caaaar '((((a))) b c d e f g)) 'a)+(test (caaadr '(a ((b)) c d e f g)) 'b)+(test (caadar '((a (b)) c d e f g)) 'b)+(test (caaddr '(a b (c) d e f g)) 'c)+(test (cadaar '(((a b)) c d e f g)) 'b)+(test (cadadr '(a (b c) d e f g)) 'c)+(test (caddar '((a b c) d e f g)) 'c)+(test (cadddr '(a b c d e f g)) 'd)+(test (cdaaar '((((a b))) c d e f g)) '(b))+(test (cdaadr '(a ((b c)) d e f g)) '(c))+(test (cdadar '((a (b c)) d e f g)) '(c))+(test (cdaddr '(a b (c d) e f g)) '(d))+(test (cddaar '(((a b c)) d e f g)) '(c))+(test (cddadr '(a (b c d) e f g)) '(d))+(test (cdddar '((a b c d) e f g)) '(d))+(test (cddddr '(a b c d e f g)) '(e f g))+(test (cadr '(1 2 . 3)) 2)+(test (cddr '(1 2 . 3)) 3)++(test (caar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(((1 2 3) 4) 5))+(test (cadr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(((u v w) x) y))+(test (cdar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '((6 7)))+(test (cddr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(((q w e) r) (a b c) e f g))+(test (caaar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '((1 2 3) 4))+(test (caadr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '((u v w) x))+(test (cadar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(6 7))+(test (caddr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '((q w e) r))+(test (cdaar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(5))+(test (cdadr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(y))+(test (cddar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '())+(test (cdddr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '((a b c) e f g))+(test (caaaar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(1 2 3))+(test (caaadr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(u v w))+(test (caadar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) 6)+(test (caaddr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(q w e))+(test (cadaar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) 5)+(test (cadadr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) 'y)+(test (cadddr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(a b c))+(test (cdaaar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(4))+(test (cdaadr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(x))+(test (cdadar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(7))+(test (cdaddr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(r))+(test (cddaar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '())+(test (cddadr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '())+(test (cddddr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(e f g))++(test (cadr '(a b c d e f g)) 'b)+(test (cddr '(a b c d e f g)) '(c d e f g))+(test (caddr '(a b c d e f g)) 'c)+(test (cdddr '(a b c d e f g)) '(d e f g))+(test (cadddr '(a b c d e f g)) 'd)+(test (cddddr '(a b c d e f g)) '(e f g))++(test (caar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '((a . b) c . d))+(test (caar '(((a . b) c . d) (e . f) g . h)) '(a . b))+(test (caar '((a . b) c . d)) 'a)+(test (cadr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '((i . j) k . l))+(test (cadr '(((a . b) c . d) (e . f) g . h)) '(e . f))+(test (cadr '((a . b) c . d)) 'c)+(test (cdar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '((e . f) g . h))+(test (cdar '(((a . b) c . d) (e . f) g . h)) '(c . d))+(test (cdar '((a . b) c . d)) 'b)+(test (cddr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '((m . n) o . p))+(test (cddr '(((a . b) c . d) (e . f) g . h)) '(g . h))+(test (cddr '((a . b) c . d)) 'd)+(test (caaar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '(a . b))+(test (caaar '(((a . b) c . d) (e . f) g . h)) 'a)+(test (caadr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '(i . j))+(test (caadr '(((a . b) c . d) (e . f) g . h)) 'e)+(test (cddar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '(g . h))+(test (cddar '(((a . b) c . d) (e . f) g . h)) 'd)+(test (cdddr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '(o . p))+(test (cdddr '(((a . b) c . d) (e . f) g . h)) 'h)+(test (caaaar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'a)+(test (caaadr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'i)+(test (caddar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'g)+(test (cadddr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'o)+(test (cdaaar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'b)+(test (cdaadr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'j)+(test (cdddar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'h)+(test (cddddr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'p)++(test (cadr ''foo) 'foo)+++(test (length (list 'a 'b 'c 'd 'e 'f)) 6)+(test (length (list 'a 'b 'c 'd)) 4)+(test (length (list 'a (list 'b 'c) 'd)) 3)+(test (length '()) 0)+(test (length '(this-that)) 1)+(test (length '(this - that)) 3)+(test (length '(a b)) 2)+(test (length '(a b c)) 3)+(test (length '(a (b) (c d e))) 3)+(test (length (list 1 (cons 1 2))) 2)+(test (length (list 1 (cons 1 '()))) 2)+++(test (reverse '(a b c d)) '(d c b a))+(test (reverse '(a b c))  '(c b a))+(test (reverse '(a (b c) d (e (f))))  '((e (f)) d (b c) a))+(test (reverse '()) '())+(test (reverse (list 1 2 3)) '(3 2 1))+(test (reverse (list 1)) '(1))+(test (reverse (list)) (list))+(test (reverse '(1 2 3)) (list 3 2 1))+(test (reverse '(1)) '(1))+(test (reverse '((1 2) 3)) '(3 (1 2)))+(test (reverse '(((1 . 2) . 3) 4)) '(4 ((1 . 2) . 3)))+(test (reverse (list (list) (list 1 2))) '((1 2) ()))+(test (reverse '((a) b c d)) '(d c b (a)))+(test (reverse (reverse (list 1 2 3 4))) (list 1 2 3 4))+(test (reverse ''foo) '(foo quote))+(test (let ((x (list 1 2 3 4)))+	(let ((y (reverse x)))+	  (and (equal? x (list 1 2 3 4))+	       (equal? y (list 4 3 2 1)))))+      #t)+(test (letrec ((hi (lambda (lst n)+	       (if (= n 0)+		   lst+		   (hi (reverse lst) (- n 1))))))+	(hi (list 1 2 3) 100))+      (list 1 2 3))+(test (let ((var (list 1 2 3))) (reverse (cdr var)) var) (list 1 2 3))+(test (let ((var '(1 2 3))) (reverse (cdr var)) var) '(1 2 3))+(test (let ((var (list 1 (list 2 3)))) (reverse (cdr var)) var) (list 1 (list 2 3)))+(test (let ((var '(1 (2 3)))) (reverse (cdr var)) var) '(1 (2 3)))+(test (let ((var (list (list 1 2) (list 3 4 5)))) (reverse (car var)) var) '((1 2) (3 4 5)))+(test (let ((x '(1 2 3))) (list (reverse x) x)) '((3 2 1) (1 2 3)))++(for-each+ (lambda (lst)+   (if (list? lst)+       (if (not (equal? lst (reverse (reverse lst))))+	   (begin+	     (display "(reverse (reverse ") (display lst) (display ")) returned ") (display (reverse (reverse lst))) (newline)))))+ lists)++(for-each+ (lambda (lst)+   (if (list? lst)+       (if (not (equal? lst (reverse (reverse (reverse (reverse lst))))))+	   (begin+	     (display "(reverse...(4x) ") (display lst) (display ")) returned ") (display (reverse (reverse (reverse (reverse lst))))) (newline)))))+ lists)++++(test (pair? 'a) #f)+(test (pair? '()) #f)+(test (pair? '(a b c)) #t)+(test (pair? (cons 1 2)) #t)+(test (pair? ''()) #t)+(test (pair? #f) #f)+(test (pair? (make-vector 6)) #f)+(test (pair? #t) #f)+(test (pair? '(a . b)) #t)+(test (pair? '#(a b))  #f)+(test (pair? (list 1 2)) #t)+(test (pair? (list)) #f)+(test (pair? ''foo) #t)+(test (pair? (list 'a 'b 'c 'd 'e 'f)) #t)+(test (pair? '(this-that)) #t)+(test (pair? '(this - that)) #t)+(let ((x (list 1 2)))+  (set-cdr! x x)+  (test (pair? x) #t))+(test (pair? (list 1 (cons 1 2))) #t)+(test (pair? (list 1 (cons 1 '()))) #t)+(test (pair? (cons 1 '())) #t)+(test (pair? (cons '() '())) #t)+(test (pair? (cons '() 1)) #t)+(test (pair? (list (list))) #t)+(test (pair? '(())) #t)+(test (pair? (cons 1 (cons 2 3))) #t)++(for-each+ (lambda (arg)+   (if (pair? arg)+       (begin+	 (display "(pair? ") (display arg) (display ") returned #t?") (newline))))+ (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1))))++++(test (list? 'a) #f)+(test (list? '()) #t)+(test (list? '(a b c)) #t)+(test (list? (cons 1 2)) #f)+(test (list? ''()) #t)+(test (list? #f) #f)+(test (list? (make-vector 6)) #f)+(test (list? #t) #f)+(test (list? '(a . b)) #f)+(test (list? '#(a b))  #f)+(test (list? (list 1 2)) #t)+(test (list? (list)) #t)+(test (list? ''foo) #t)+(test (list? (list 'a 'b 'c 'd 'e 'f)) #t)+(test (list? '(this-that)) #t)+(test (list? '(this - that)) #t)+(let ((x (list 1 2)))+  (set-cdr! x x)+  (test (list? x) #f))+(test (list? (list 1 (cons 1 2))) #t)+(test (list? (list 1 (cons 1 '()))) #t)+(test (list? (cons 1 '())) #t)+(test (list? (cons '() '())) #t)+(test (list? (cons '() 1)) #f)+(test (list? (list (list))) #t)+(test (list? '(())) #t)+(test (list? '(1 2 . 3)) #f)+(test (list? (cons 1 (cons 2 3))) #f)++(for-each+ (lambda (arg)+   (if (list? arg)+       (begin+	 (display "(list? ") (display arg) (display ") returned #t?") (newline))))+ (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1))))++++(test (null? 'a) '#f)+(test (null? '()) #t)+(test (null? '(a b c)) #f)+(test (null? (cons 1 2)) #f)+(test (null? ''()) #f)+(test (null? #f) #f)+(test (null? (make-vector 6)) #f)+(test (null? #t) #f)+(test (null? '(a . b)) #f)+(test (null? '#(a b))  #f)+(test (null? (list 1 2)) #f)+(test (null? (list)) #t)+(test (null? ''foo) #f)+(test (null? (list 'a 'b 'c 'd 'e 'f)) #f)+(test (null? '(this-that)) #f)+(test (null? '(this - that)) #f)+(let ((x (list 1 2)))+  (set-cdr! x x)+  (test (null? x) #f))+(test (null? (list 1 (cons 1 2))) #f)+(test (null? (list 1 (cons 1 '()))) #f)+(test (null? (cons 1 '())) #f)+(test (null? (cons '() '())) #f)+(test (null? (cons '() 1)) #f)+(test (null? (list (list))) #f)+(test (null? '(())) #f)+(test (null? '#()) #f)++(for-each+ (lambda (arg)+   (if (null? arg)+       (begin+	 (display "(null? ") (display arg) (display ") returned #t?") (newline))))+ (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1))))+++(test (let ((x (cons 1 2))) (set-car! x 3) x) (cons 3 2))+(test (let ((x (list 1 2))) (set-car! x 3) x) (list 3 2))+(test (let ((x (list (list 1 2) 3))) (set-car! x 22) x) (list 22 3))+(test (let ((x (cons 1 2))) (set-car! x '()) x) (cons '() 2))+(test (let ((x (list 1 (list 2 3 4)))) (set-car! x (list 5 (list 6))) x) (list (list 5 (list 6)) (list 2 3 4)))+;(test (let ((x '(((1) 2) (3)))) (set-car! x '((2) 1)) x) '(((2) 1) (3)))+;(test (let ((x ''foo)) (set-car! x "hi") x) (list "hi" 'foo))+;(test (let ((x '((1 . 2) . 3))) (set-car! x 4) x) '(4 . 3))+;(test (let ((x '(1 . 2))) (set-car! x (cdr x)) x) '(2 . 2))+;(test (let ((x '(1 . 2))) (set-car! x x) (list? x)) #f)+(test (let ((x (list 1))) (set-car! x '()) x) '(()))+;(test (let ((x '(((1 2) . 3) 4))) (set-car! x 1) x) '(1 4))+++(test (let ((x (cons 1 2))) (set-cdr! x 3) x) (cons 1 3))+(test (let ((x (list 1 2))) (set-cdr! x 3) x) (cons 1 3))+(test (let ((x (list (list 1 2) 3))) (set-cdr! x 22) x) '((1 2) . 22))+(test (let ((x (cons 1 2))) (set-cdr! x '()) x) (list 1))+(test (let ((x (list 1 (list 2 3 4)))) (set-cdr! x (list 5 (list 6))) x) '(1 5 (6)))+;(test (let ((x '(((1) 2) (3)))) (set-cdr! x '((2) 1)) x) '(((1) 2) (2) 1))+;(test (let ((x ''foo)) (set-cdr! x "hi") x) (cons 'quote "hi"))+;(test (let ((x '((1 . 2) . 3))) (set-cdr! x 4) x) '((1 . 2) . 4))+;(test (let ((x '(1 . 2))) (set-cdr! x (cdr x)) x) '(1 . 2))+;(test (let ((x '(1 . 2))) (set-cdr! x x) (list? x)) #f)+(test (let ((x (list 1))) (set-cdr! x '()) x) (list 1))+;(test (let ((x '(1 . (2 . (3 (4 5)))))) (set-cdr! x 4) x) '(1 . 4))++++(test (list-ref (list 1 2) 1) 2)+(test (list-ref '(a b c d) 2) 'c)+(test (list-ref (cons 1 2) 0) 1) ; !!+(test (list-ref ''foo 0) 'quote)+(test (list-ref '((1 2) (3 4)) 1) '(3 4))+(test (list-ref (list-ref (list (list 1 2) (list 3 4)) 1) 1) 4)+(test (let ((x (list 1 2 3))) (list-ref x (list-ref x 1))) 3)+; (list-ref '(1 2 . 3) 0) -- why is this acceptable?++;(for-each+; (lambda (name op1 op2)+;   (for-each+;    (lambda (lst)+;      (let ((val1 (catch #t (lambda () (op1 lst)) (lambda args 'error)))+;	    (val2 (catch #t (lambda () (op2 lst)) (lambda args 'error))))+;	(if (not (equal? val1 val2))+;	    (begin+;	      (display "(") (display name) (display " ") (display lst) (display ")) returned ") (display val1) (display " ") (display val2) (newline)))))+;    lists))+; (list 'list-ref:0 'list-ref:1 'list-ref:2 'list-ref:3)+; (list car cadr caddr cadddr)+; (list (lambda (l) (list-ref l 0)) (lambda (l) (list-ref l 1)) (lambda (l) (list-ref l 2)) (lambda (l) (list-ref l 3))))++(for-each+ (lambda (arg)+   (test (list-ref (list 1 arg) 1) arg))+ (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1))))++;(test (let ((x '(1 . 2))) (set-cdr! x x) (list-ref x 0)) 1)+;(test (let ((x '(1 . 2))) (set-cdr! x x) (list-ref x 1)) 1)+;(test (let ((x '(1 . 2))) (set-cdr! x x) (list-ref x 100)) 1)++++(test (let ((tree1 (list 1 (list 1 2) (list (list 1 2 3)) (list (list (list 1 2 3 4)))))) tree1) '(1 (1 2) ((1 2 3)) (((1 2 3 4)))))+(test (let ((tree2 (list "one" (list "one" "two") (list (list "one" "two" "three"))))) tree2) '("one" ("one" "two") (("one" "two" "three"))))+(test (let ((tree1 (list 1 (list 1 2) (list 1 2 3) (list 1 2 3 4)))) tree1) '(1 (1 2) (1 2 3) (1 2 3 4)))+(test (let ((tree1 (list 1 (list 1 2))) (tree2 (list 1 (list 1 2)))) tree2) '(1 (1 2)))+(test (let ((tree1 (list 1 (list 1 2))) (tree2 (list 1 (list 1 2)))) (eqv? tree1 tree2)) #f)+(test (let ((tree1 (list ''a (list ''b ''c))) (tree2 (list ''a (list ''b ''c)))) tree2) '('a ('b 'c)))+(test (let ((lst (list 1 (list 2 3)))) lst) '(1 (2 3)))+(test (let* ((lst (list 1 (list 2 3))) (slst lst)) slst) '(1 (2 3)))+(test (list 1) '(1))+(test (let ((a 1)) (list a 2)) '(1 2))+(test (let ((a 1)) (list 'a '2)) '(a 2))+(test (let ((a 1)) (list 'a 2)) '(a 2))+(test (list) '())+(test (let ((a (list 1 2))) a) '(1 2))+(test (let ((a (list 1 2))) (list 3 4 'a (car (cons 'b 'c)) (+ 6 -2))) '(3 4 a b 4))+(test (list) '())+;(test (length (list quote do map call/cc lambda define if begin set! let let* cond and or for-each)) 15)+(test (length (list quote do map lambda if begin set! let let* cond and or for-each)) 13)+++(test (list-tail '(1 2 3) 0) '(1 2 3))+(test (list-tail '(1 2 3) 2) '(3))+(test (list-tail '(1 2 3) 3) '())+(test (list-tail '(1 2 3 . 4) 2) '(3 . 4))+(test (list-tail '(1 2 3 . 4) 3) 4)+(test (let ((x (list 1 2 3))) (eq? (list-tail x 2) (cddr x))) #t)+(test (list-tail '() 0) '())+(test (list-tail (list 1 2) 2) '())+(test (list-tail (cons 1 2) 0) '(1 . 2))+(test (list-tail (cons 1 2) 1) 2)+(test (list-tail ''foo 1) '(foo))+(test (list-tail '((1 2) (3 4)) 1) '((3 4)))+(test (list-tail (list-tail (list-tail '(1 2 3 4) 1) 1) 1) '(4))++;(let ((x '(1 . 2))) (set-cdr! x x) (test (list-tail x 0) x))+;(let ((x '(1 . 2))) (set-cdr! x x) (test (list-tail x 1) (cdr x)))+;(let ((x '(1 . 2))) (set-cdr! x x) (test (list-tail x 100) x))++;(for-each+; (lambda (name op1 op2)+;   (for-each+;    (lambda (lst)+;      (let ((val1 (catch #t (lambda () (op1 lst)) (lambda args 'error)))+;	    (val2 (catch #t (lambda () (op2 lst)) (lambda args 'error))))+;	(if (not (equal? val1 val2))+;	    (begin+;	      (display "(") (display name) (display " ") (display lst) (display ")) returned ") (display val1) (display " ") (display val2) (newline)))))+;    lists))+; (list 'list-tail:0 'list-tail:1 'list-tail:2 'list-tail:3 'list-tail:4)+; (list (lambda (l) l) cdr cddr cdddr cddddr)+; (list (lambda (l) (list-tail l 0)) (lambda (l) (list-tail l 1)) (lambda (l) (list-tail l 2)) (lambda (l) (list-tail l 3)) (lambda (l) (list-tail l 4))))++++(let ((e '((a 1) (b 2) (c 3))))+  (test (assq 'a e) '(a 1))+  (test (assq 'b e) '(b 2))+  (test (assq 'd e) #f))+(test (assq (list 'a) '(((a)) ((b)) ((c))))  #f)++(let ((xcons (cons 1 2))+      (xvect (vector 1 2))+      (xlambda (lambda () 1))+      (xstr "abs"))+  (let ((e (list (list #t 1) (list #f 2) (list 'a 3) (list xcons 4) (list xvect 5) (list xlambda 6) (list xstr 7) (list car 8))))+    (test (assq #t e) (list #t 1))+    (test (assq #f e) (list #f 2))+    (test (assq 'a e) (list 'a 3))+    (test (assq xcons e) (list xcons 4))+    (test (assq xvect e) (list xvect 5))+    (test (assq xlambda e) (list xlambda 6))+    (test (assq xstr e) (list xstr 7))+    (test (assq car e) (list car 8))))++(let ((e '((1+i 1) (3.0 2) (5/3 3))))+  (test (assq 1+i e) #f)+  (test (assq 3.0 e) #f)+  (test (assq 5/3 e) #f))++++(let ((e '((a 1) (b 2) (c 3))))+  (test (assv 'a e) '(a 1))+  (test (assv 'b e) '(b 2))+  (test (assv 'd e) #f))+(test (assv (list 'a) '(((a)) ((b)) ((c))))  #f)++(let ((xcons (cons 1 2))+      (xvect (vector 1 2))+      (xlambda (lambda () 1))+      (xstr "abs"))+  (let ((e (list (list #t 1) (list #f 2) (list 'a 3) (list xcons 4) (list xvect 5) (list xlambda 6) (list xstr 7) (list car 8))))+    (test (assv #t e) (list #t 1))+    (test (assv #f e) (list #f 2))+    (test (assv 'a e) (list 'a 3))+    (test (assv xcons e) (list xcons 4))+    (test (assv xvect e) (list xvect 5))+    (test (assv xlambda e) (list xlambda 6))+    (test (assv xstr e) (list xstr 7))+    (test (assv car e) (list car 8))))++(let ((e '((1+i 1) (3.0 2) (5/3 3) (#\a 4) ("hiho" 5))))+  (test (assv 1+i e) '(1+i 1))+  (test (assv 3.0 e) '(3.0 2))+  (test (assv 5/3 e) '(5/3 3))+  (test (assv #\a e) '(#\a 4))+  (test (assv "hiho" e) #f))++(let ((e '(((a) 1) (#(a) 2) ("c" 3))))+  (test (assv '(a) e) #f)+  (test (assv '#(a) e) #f)+  (test (assv (string #\c) e) #f))++;(let ((lst '((2 . a) (3 . b))))+;  (set-cdr! (assv 3 lst) 'c)+;  (test lst '((2 . a) (3 . c))))+++(let ((e '((a 1) (b 2) (c 3))))+  (test (assoc 'a e) '(a 1))+  (test (assoc 'b e) '(b 2))+  (test (assoc 'd e) #f))+(test (assoc (list 'a) '(((a)) ((b)) ((c))))  '((a)))++(let ((xcons (cons 1 2))+      (xvect (vector 1 2))+      (xlambda (lambda () 1))+      (xstr "abs"))+  (let ((e (list (list #t 1) (list #f 2) (list 'a 3) (list xcons 4) (list xvect 5) (list xlambda 6) (list xstr 7) (list car 8))))+    (test (assoc #t e) (list #t 1))+    (test (assoc #f e) (list #f 2))+    (test (assoc 'a e) (list 'a 3))+    (test (assoc xcons e) (list xcons 4))+    (test (assoc xvect e) (list xvect 5))+    (test (assoc xlambda e) (list xlambda 6))+    (test (assoc xstr e) (list xstr 7))+    (test (assoc car e) (list car 8))))++(let ((e '((1+i 1) (3.0 2) (5/3 3) (#\a 4) ("hiho" 5))))+  (test (assoc 1+i e) '(1+i 1))+  (test (assoc 3.0 e) '(3.0 2))+  (test (assoc 5/3 e) '(5/3 3))+  (test (assoc #\a e) '(#\a 4))+  (test (assoc "hiho" e) '("hiho" 5)))++(let ((e '(((a) 1) (#(a) 2) ("c" 3))))+  (test (assoc '(a) e) '((a) 1))+  (test (assoc '#(a) e) '(#(a) 2))+  (test (assoc (string #\c) e) '("c" 3)))++(test (assoc 'a '((b c) (a u) (a i))) '(a u))+(test (assoc 'a '((b c) ((a) u) (a i))) '(a i))+(test (assoc (list 'a) '(((a)) ((b)) ((c))))  '((a)))+(test (assoc 5 '((2 3) (5 7) (11 13))) '(5 7))+++(test (append '(a b c) '()) '(a b c))+(test (append '() '(a b c)) '(a b c))+(test (append '(a b) '(c d)) '(a b c d))+(test (append '(a b) 'c) '(a b . c))+(test (equal? (append (list 'a 'b 'c) (list 'd 'e 'f) '() '(g)) '(a b c d e f g)) #t)+(test (append (list 'a 'b 'c) (list 'd 'e 'f) '() (list 'g)) '(a b c d e f g))+(test (append (list 'a 'b 'c) 'd) '(a b c . d))+(test (append '() '()) '())+(test (append '() (list 'a 'b 'c)) '(a b c))+(test (append) '())+(test (append 'a) 'a)+(test (append '(x) '(y))  '(x y))+(test (append '(a) '(b c d)) '(a b c d))+(test (append '(a (b)) '((c)))  '(a (b) (c)))+(test (append '(a b) '(c . d))  '(a b c . d))+(test (append '() 'a)  'a)+(test (append '(a b) (append (append '(c)) '(e) 'f)) '(a b c e . f))+(test (append ''foo 'foo) '(quote foo . foo))+(test (append '() (cons 1 2)) '(1 . 2))+(test (append '() '() '()) '())+(test (append (cons 1 2)) '(1 . 2))++(test (append #f) #f)+(test (append '() #f) #f)+(test (append '(1 2) #f) '(1 2 . #f))+(test (append '() '() #f) #f)+(test (append '() '(1 2) #f) '(1 2 . #f))+(test (append '(1 2) '() #f) '(1 2 . #f))+(test (append '(1 2) '(3 4) #f) '(1 2 3 4 . #f))+(test (append '() '() '() #f) #f)+(test (append '(1 2) '(3 4) '(5 6) #f) '(1 2 3 4 5 6 . #f))+++(test (memq 'a '(a b c)) '(a b c))+(test (memq 'b '(a b c)) '(b c))+(test (memq 'a '(b c d)) #f)+(test (memq (list 'a) '(b (a) c))  #f)+(test (memq 'a '(b a c a d a)) '(a c a d a))+(let ((v (vector 'a))) (test (memq v (list 'a 1.2 v "hi")) (list v "hi")))+++(test (memv 101 '(100 101 102)) '(101 102))+(test (memv 3.4 '(1.2 2.3 3.4 4.5)) '(3.4 4.5))+(test (memv 3.4 '(1.3 2.5 3.7 4.9)) #f)+(let ((ls (list 'a 'b 'c)))+  (set-car! (memv 'b ls) 'z)+  (test ls '(a z c)))+++(test (member (list 'a) '(b (a) c)) '((a) c))+(test (member "b" '("a" "c" "b")) '("b"))+(test (member 1 '(3 2 1 4)) '(1 4))+(test (member car (list abs car modulo)) (list car modulo))+(test (member do (list quote map do)) (list do))+(test (member 5/2 (list 1/3 2/4 5/2)) '(5/2))++++++;;; --------------------------------------------------------------------------------+;;; VECTORS+;;; --------------------------------------------------------------------------------++(test (vector? (make-vector 6)) #t)+(test (vector? (make-vector 6 #\a)) #t)+(test (vector? (make-vector 0)) #t)+;; (test (vector? #*1011) #f)+(test (vector? '#(0 (2 2 2 2) "Anna")) #t)+(test (vector? '#()) #t)+(test (vector? '#("hi")) #t)+(test (vector? (vector 1)) #t)+(test (let ((v (vector 1 2 3))) (vector? v)) #t)++(for-each+ (lambda (arg)+   (test (vector? arg) #f))+ (list #\a 1 '() (list 1) '(1 . 2) #f "hi" 'a-symbol abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))+++(test (let ((v (make-vector 3 #f))) (and (vector? v) (= (vector-length v) 3) (eq? (vector-ref v 1) #f))) #t)+(test (let ((v (make-vector 1 1))) (and (vector? v) (= (vector-length v) 1) (vector-ref v 0))) 1)+(test (let ((v (make-vector 0 1))) (and (vector? v) (= (vector-length v) 0))) #t)+(test (do ((vec (make-vector 5)) (i 0 (+ i 1))) ((= i 5) vec) (vector-set! vec i i)) '#(0 1 2 3 4))+(test (let ((v (make-vector 5))) (for-each (lambda (i) (vector-set! v i (* i i))) '(0 1 2 3 4)) v) '#(0 1 4 9 16))+(test (make-vector 2 'hi) '#(hi hi))+(test (make-vector 0) '#())+(test (make-vector 0 'hi) '#())+(test (make-vector 3 (make-vector 1 'hi)) '#(#(hi) #(hi) #(hi)))+(test (make-vector 3 '#(hi)) '#(#(hi) #(hi) #(hi)))+(test (make-vector 3 (list)) '#(() () ()))+(test (make-vector 3 (make-vector 1 (make-vector 1 'hi))) '#(#(#(hi)) #(#(hi)) #(#(hi))))++(for-each+ (lambda (arg)+   (test (vector-ref (make-vector 1 arg) 0) arg))+ (list #\a 1 '() (list 1) '(1 . 2) #f "hi" 'a-symbol abs 3.14 3/4 1.0+1.0i #t (vector 1 2 3) (lambda (a) (+ a 1))))++(test (vector 1 2 3) '#(1 2 3))+(test (vector 1 '(2) 3) '#(1 (2) 3))+(test (vector) '#())+(test (vector (vector (vector))) '#(#(#())))+(test (vector (vector) (vector) (vector)) '#(#() #() #()))+(test (vector (list)) '#(()))+(test '#(1 #\a "hi" hi) (vector 1 #\a "hi" 'hi))+(test (let ((v (make-vector 4 "hi")))+	(vector-set! v 0 1)+	(vector-set! v 1 #\a)+	(vector-set! v 3 'hi)+	v)+      '#(1 #\a "hi" hi))+(let ((x 34))+  (test (vector x 'x) '#(34 x)))++(for-each+ (lambda (arg)+   (test (vector-ref (vector arg) 0) arg))+ (list #\a 1 '() (list 1) '(1 . 2) #f "hi" 'a-symbol abs 3.14 3/4 1.0+1.0i #t (vector 1 2 3) (lambda (a) (+ a 1))))++++(test (vector->list '#(0)) (list 0))+(test (vector->list (vector)) '())+(test (vector->list '#(a b c)) '(a b c))+(test (vector->list '#(#(0) #(1))) '(#(0) #(1)))+(test (vector? (list-ref (let ((v (vector 1 2))) (vector-set! v 1 v) (vector->list v)) 1)) #t)++(test (list->vector '()) '#())+(test (list->vector '(a b c)) '#(a b c))+(test (list->vector (list (list 1 2) (list 3 4))) '#((1 2) (3 4)))+(test (list->vector ''foo) '#(quote foo))+(test (list->vector (list)) '#())+(test (list->vector (list 1)) '#(1))+(test (list->vector (list (list))) '#(()))+(test (list->vector (list 1 #\a "hi" 'hi)) '#(1 #\a "hi" hi))++(for-each+ (lambda (arg)+   (if (list? arg)+       (test (vector->list (list->vector arg)) arg)))+ lists)++(test (list->vector (vector->list (vector))) '#())+(test (list->vector (vector->list (vector 1))) '#(1))+(test (vector->list (list->vector (list))) '())+(test (vector->list (list->vector (list 1))) '(1))++++(test (vector-length (vector)) 0)+(test (vector-length (vector 1)) 1)+(test (vector-length (make-vector 128)) 128)+(test (vector-length '#(a b c d e f)) 6)+(test (vector-length '#()) 0)+(test (vector-length (vector #\a (list 1 2) (vector 1 2))) 3)+(test (vector-length '#(#(#(hi)) #(#(hi)) #(#(hi)))) 3)+(test (vector-length (vector 1 2 3 4)) 4)+(test (vector-length (let ((v (vector 1 2))) (vector-set! v 1 v) v)) 2)+(test (vector-length (let ((v (vector 1 2))) (vector-set! v 1 v) (vector-ref v 1))) 2)+++(test (vector-ref '#(1 1 2 3 5 8 13 21) 5) 8)+(test (vector-ref '#(1 1 2 3 5 8 13 21) (let ((i (round (* 2 (acos -1))))) (if (inexact? i) (inexact->exact i)  i))) 13)+(test (let ((v (make-vector 1 0))) (vector-ref v 0)) 0)+(test (let ((v (vector 1 (list 2) (make-vector 3 #\a)))) (vector-ref v 1)) (list 2))+(test (let ((v (vector 1 (list 2) (make-vector 3 #\a)))) (vector-ref v 2)) '#(#\a #\a #\a))+(test (let ((v (vector 1 (list 2) (make-vector 3 #\a)))) (vector-ref (vector-ref v 2) 1)) #\a)+(test (vector-ref '#(a b c) 1) 'b)+(test (vector-ref '#(()) 0) '())+(test (vector-ref '#(#()) 0) '#())+(test (vector-ref (vector-ref (vector-ref '#(1 (2) #(3 (4) #(5))) 2) 2) 0) 5)+(test (let ((v (vector 1 2))) (vector-set! v 1 v) (eq? (vector-ref v 1) v)) #t)+++(test (let ((vec (vector 0 '(2 2 2 2) "Anna"))) (vector-set! vec 1 '("Sue" "Sue")) vec) '#(0 ("Sue" "Sue") "Anna"))+(test (let ((v (vector 1 2 3))) (vector-set! v 1 32) v) '#(1 32 3))+(let ((v (make-vector 8 #f)))+  (for-each+   (lambda (arg)+     (vector-set! v 1 arg)+     (test (vector-ref v 1) arg))+   (list #\a 1 '() (list 1) '(1 . 2) #f "hi" 'a-symbol abs 3.14 3/4 1.0+1.0i #t (vector 1 2 3) (lambda (a) (+ a 1)))))+(test (let ((v (vector 1 2 3))) (vector-set! v 1 0) v) '#(1 0 3))+(test (let ((v (vector #f))) (vector-set! v 0 (vector)) v) '#(#()))+(test (let ((v (vector 1 (list 2) (vector 1 2 3)))) (vector-set! (vector-ref v 2) 0 21) v) '#(1 (2) #(21 2 3)))++++(test (let ((v (vector 1 2 3))) (vector-fill! v 0) v) '#(0 0 0))+(test (let ((v (vector))) (vector-fill! v #f) v) '#())+(let ((v (make-vector 8 #f)))+  (for-each+   (lambda (arg)+     (vector-fill! v arg)+     (test (vector-ref v 1) arg))+   (list #\a 1 '() (list 1) '(1 . 2) #f "hi" 'a-symbol abs 3.14 3/4 1.0+1.0i #t (vector 1 2 3) (lambda (a) (+ a 1)))))++;(let ((str "hi") (v (make-vector 3))) (vector-fill! v str) (string-set! (vector-ref v 0) 1 #\a) str) -> mutable string error+;(let ((lst (list 1 2)) (v (make-vector 3))) (vector-fill! v lst) (list-set! (vector-ref v 0) 1 #\a) lst) -> '(1 #\a)+++;(if (provided? 'multidimensional-vectors)+;    (let ((v1 (make-vector 3 1)))+;      (num-test (v1 1) 1)+;      (set! (v1 1) 2)+;      (num-test (v1 1) 2)+;      (let ((i0 0)+;	    (i2 2))+;	(num-test (v1 i0) 1)+;	(num-test (vector-ref v1 i2) 1)+;	(set! (v1 i0) 0)+;	(num-test (v1 0) 0)+;	(set! (v1 i0) i2)+;	(num-test (v1 i0) i2))+;      (test (vector-dimensions v1) '(3))+;      (set! v1 (make-vector '(3 2)))+;      (test (vector-dimensions v1) '(3 2))+;      (vector-set! v1 1 1 0)+;      (num-test (vector-ref v1 1 1) 0)+;      (let ((i0 1)+;	    (i1 1)+;	    (i2 32))+;	(set! (v1 i0 i1) i2)+;	(num-test (vector-ref v1 1 1) 32)+;	(num-test (v1 i0 i1) i2)+;	(vector-set! v1 0 1 3)+;	(num-test (v1 0 1) 3)+;	(num-test (v1 1 1) 32))+;      (set! v1 (make-vector '(2 4 3) 1))+;      (test (vector-dimensions v1) '(2 4 3))+;      (num-test (vector-ref v1 1 1 1) 1)+;      (vector-set! v1 0 0 0 32)+;      (num-test (v1 0 0 0) 32)+;      (set! (v1 0 1 1) 3)+;      (num-test (v1 0 1 1) 3)))+++(set! lists '())++++;;; --------------------------------------------------------------------------------+;;; PORTS+;;; --------------------------------------------------------------------------------++(define start-input-port (current-input-port))+(define start-output-port (current-output-port))++(test (input-port? (current-input-port)) #t)++(for-each+ (lambda (arg)+   (if (input-port? arg)+       (begin+	 (display "(input-port? ") (display arg) (display ") returned #t?") (newline))))+ (list "hi" #f (integer->char 65) 1 (list 1 2) '#t '3 (make-vector 3) 3.14 3/4 1.0+1.0i #\f))++(test (call-with-input-file "r5rstest.scm" input-port?) #t)+(if (not (eq? start-input-port (current-input-port)))+    (begin (display "call-with-input-file did not restore current-input-port? ") (display start-input-port) (display " ") (display (current-input-port)) (newline)))++(test (let ((this-file (open-input-file "r5rstest.scm"))) (let ((res (input-port? this-file))) (close-input-port this-file) res)) #t)+(if (not (eq? start-input-port (current-input-port)))+    (begin (display "open-input-file clobbered current-input-port? ") (display start-input-port) (display " ") (display (current-input-port)) (newline)))++(test (output-port? (current-output-port)) #t)+(write-char #\space (current-output-port))+(write " " (current-output-port))+(newline (current-output-port))+++(for-each+ (lambda (arg)+   (if (output-port? arg)+       (begin+	 (display "(output-port? ") (display arg) (display ") returned #t?") (newline))))+ (list "hi" #f (integer->char 65) 1 (list 1 2) '#t '3 (make-vector 3) 3.14 3/4 1.0+1.0i #\f))++(test (call-with-output-file "tmp1.r5rs" output-port?) #t)+(if (not (eq? start-output-port (current-output-port)))+    (begin (display "call-with-output-file did not restore current-output-port? ") (display start-output-port) (display " ") (display (current-output-port)) (newline)))++(test (let ((this-file (open-output-file "tmp1.r5rs"))) (let ((res (output-port? this-file))) (close-output-port this-file) res)) #t)+(if (not (eq? start-output-port (current-output-port)))+    (begin (display "open-output-file clobbered current-output-port? ") (display start-output-port) (display " ") (display (current-output-port)) (newline)))++(for-each+ (lambda (arg)+   (if (eof-object? arg)+       (begin+	 (display "(eof-object? ") (display arg) (display ") returned #t?") (newline))))+ (list "hi" -1 #\a 1 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #f #t (lambda (a) (+ a 1))))++(call-with-output-file "tmp1.r5rs" (lambda (p) (display "3.14" p)))+(test (call-with-input-file "tmp1.r5rs" (lambda (p) (read p) (let ((val (read p))) (eof-object? val)))) #t)+++(test (call-with-input-file "tmp1.r5rs" (lambda (p) (read-char p))) #\3)+(test (call-with-input-file "tmp1.r5rs" (lambda (p) (peek-char p))) #\3)+(test (call-with-input-file "tmp1.r5rs" (lambda (p) (peek-char p) (read-char p))) #\3)+(test (call-with-input-file "tmp1.r5rs" (lambda (p) (list->string (list (read-char p) (read-char p) (read-char p) (read-char p))))) "3.14")+(test (call-with-input-file "tmp1.r5rs" (lambda (p) (list->string (list (read-char p) (peek-char p) (read-char p) (read-char p) (peek-char p) (read-char p))))) "3..144")++(for-each+ (lambda (arg)+   (call-with-output-file "tmp1.r5rs" (lambda (p) (write arg p)))+   (test (call-with-input-file "tmp1.r5rs" (lambda (p) (read p))) arg))+ (list "hi" -1 #\a 1 'a-symbol (make-vector 3 0) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) (cons 1 2)))++;;; r4rstest+(let* ((write-test-obj '(#t #f a () 9739 -3 . #((test) "te \" \" st" "" test #() b c)))+       (load-test-obj (list 'define 'foo (list 'quote write-test-obj))))++  (define (check-test-file name)+    (let ((val (call-with-input-file+		   name+		 (lambda (test-file)+		   (test (read test-file) load-test-obj)+		   (test (eof-object? (peek-char test-file)) #t)+		   (test (eof-object? (read-char test-file)) #t)+		   (input-port? test-file)))))+      (if (not (eq? val #t))+	  (begin (display "input-port? in call-with-input-file? returned ") (display val) (newline)))))++  (test (call-with-output-file+	    "tmp1.r5rs"+	  (lambda (test-file)+	    (write-char #\; test-file)+	    (display #\; test-file)+	    (display ";" test-file)+	    (write write-test-obj test-file)+	    (newline test-file)+	    (write load-test-obj test-file)+	    (output-port? test-file))) #t)+  (check-test-file "tmp1.r5rs")++  (let ((test-file (open-output-file "tmp2.r5rs")))+    (write-char #\; test-file)+    (display #\; test-file)+    (display ";" test-file)+    (write write-test-obj test-file)+    (newline test-file)+    (write load-test-obj test-file)+    (test (output-port? test-file) #t)+    (close-output-port test-file)+    (check-test-file "tmp2.r5rs")))+++(call-with-output-file "tmp1.r5rs" (lambda (p) (display "3.14" p)))+;(test (with-input-from-file "tmp1.r5rs" (lambda () (read))) 3.14)+(if (not (eq? start-input-port (current-input-port)))+    (begin (display "with-input-from-file did not restore current-input-port? ") (display start-input-port) (display " ") (display (current-input-port)) (newline)))++;(test (with-input-from-file "tmp1.r5rs" (lambda () (eq? (current-input-port) start-input-port))) #f)++;(test (with-output-to-file "tmp1.r5rs" (lambda () (eq? (current-output-port) start-output-port))) #f)+(if (not (eq? start-output-port (current-output-port)))+    (begin (display "with-output-to-file did not restore current-output-port? ") (display start-output-port) (display " ") (display (current-output-port)) (newline)))+++;(let ((newly-found-sonnet-probably-by-shakespeare+;        "This is the story, a sad tale but true         Of a programmer who had far too little to do.        One day as he sat in his hut swilling stew,         He cried \"CLM takes forever, it's stuck in a slough!,        Its C code is slow, too slow by a few.        Why, with just a small effort, say one line or two,        It could outpace a no-op, you could scarcely say 'boo'\"!        So he sat in his kitchen and worked like a dog.        He typed and he typed 'til his mind was a fog.         Now 6000 lines later, what wonders we see!          CLM is much faster, and faster still it will be!        In fact, for most cases, C beats the DSP!          But bummed is our coder; he grumbles at night.          That DSP code took him a year to write.          He was paid many dollars, and spent them with glee,        But his employer might mutter, this result were he to see."))+;  (call-with-output-file "tmp1.r5rs"+;    (lambda (p)+;      (write newly-found-sonnet-probably-by-shakespeare p)))+;  (let ((sonnet (with-input-from-file "tmp1.r5rs"+;		  (lambda ()+;		    (read)))))+;    (if (or (not (string? sonnet))+;	    (not (string=? sonnet newly-found-sonnet-probably-by-shakespeare)))+;	(begin (display "write/read long string returned: ") (display sonnet) (newline))))+;+;  (let ((file (open-output-file "tmp1.r5rs")))+;    (let ((len (string-length newly-found-sonnet-probably-by-shakespeare)))+;      (write-char #\" file)+;      (do ((i 0 (+ i 1)))+;	  ((= i len))+;	(let ((chr (string-ref newly-found-sonnet-probably-by-shakespeare i)))+;	  (if (char=? chr #\")+;	      (write-char #\\ file))+;	  (write-char chr file)))+;      (write-char #\" file)+;      (close-output-port file)))+;  (let ((file (open-input-file "tmp1.r5rs")))+;    (let ((sonnet (read file)))+;      (close-input-port file)+;      (if (or (not (string? sonnet))+;	      (not (string=? sonnet newly-found-sonnet-probably-by-shakespeare)))+;	  (begin (display "write-char/read long string returned: ") (display sonnet) (newline))))))++(let ((file (open-output-file "tmp1.r5rs")))+  (for-each+   (lambda (arg)+     (write arg file)+     (write-char #\space file))+   (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2)))+  (close-output-port file))+(let ((file (open-input-file "tmp1.r5rs")))+  (for-each+   (lambda (arg)+     (let ((val (read file)))+       (if (not (equal? val arg))+	   (begin (display "read/write ") (display arg) (display " returned ") (display val) (newline)))))+   (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2)))+  (close-input-port file))++;(with-output-to-file "tmp1.r5rs"+;  (lambda ()+;    (write lists)))+;(let ((val (with-input-from-file "tmp1.r5rs"+;	     (lambda ()+;	       (read)))))+;  (if (not (equal? val lists))+;      (begin (display "read/write lists returned ") (display val) (newline))))++;(let ((badfile "tmp1.r5rs"))+;  (let ((p (open-output-file "tmp1.r5rs")))+;    (close-output-port p))+;  (load "tmp1.r5rs"))++++;;; --------------------------------------------------------------------------------+;;; CONTROL OPS+;;; --------------------------------------------------------------------------------++;(define control-ops (list lambda define quote if begin set! let let* letrec cond case and or do+;			  call/cc eval apply for-each map values call-with-values dynamic-wind+;			  quasiquote))+(define control-ops (list lambda quote if begin set! let let* letrec cond case and or do+			  eval apply for-each map+			  quasiquote))+(for-each+ (lambda (op)+   (if (not (eq? op op))+       (begin (display op) (display " not eq? to itself?") (newline))))+ control-ops)++(for-each+ (lambda (op)+   (if (not (eqv? op op))+       (begin (display op) (display " not eqv? to itself?") (newline))))+ control-ops)++(for-each+ (lambda (op)+   (if (not (equal? op op))+       (begin (display op) (display " not equal? to itself?") (newline))))+ control-ops)++(define question-ops (list boolean? eof-object? string?+		           number? integer? real? rational? complex? char?+			   list? vector? pair? null?))++(for-each+ (lambda (ques)+   (for-each+    (lambda (op)+      (if (ques op)+	  (begin (display ques) (display " ") (display op) (display " returned #t?") (newline))))+    control-ops))+ question-ops)+++(for-each+ (lambda (s)+   (if (not (symbol? s))+       (begin (display "(symbol? ") (display s) (display " returned #f?") (newline))))+ '(+ - ... !.. $.+ %.- &.! *.: /:. <-. =. >. ?. ~. _. ^.))++++;;; -------- if --------++(test ((if #f + *) 3 4) 12)+(test (if (> 3 2) 'yes 'no) 'yes)+(test (if (> 2 3) 'yes 'no) 'no)+(test (if (> 3 2) (- 3 2) (+ 3 2)) 1)+(test (if (> 3 2) 1) 1)+(test (if '() 1 2) 1)+(test (if 't 1 2) 1)+(test (if #t 1 2) 1)+(test (if '#() 1 2) 1)+(test (if 1 2 3) 2)+(test (if 0 2 3) 2)+(test (if (list) 2 3) 2)+(test (if "" 2 3) 2)++(test (let ((a #t) (b #f) (c #t) (d #f)) (if (if (if (if d d c) d b) d a) 'a 'd)) 'a)+(test (let ((a #t) (b #f) (c #t) (d #f)) (if a (if b (if c (if d d c) c) 'b) 'a)) 'b)+;(test (let ((a #t) (b #f) (c #t) (d #f)) (((if a if 'gad) c if 'gad) (not d) 'a 'gad)) 'a)+(test (let ((a #t) (b #f) (c #t) (d #f)) (if b (if a (if d 'gad) 'gad) (if d 'gad 'a))) 'a)++(let ((a #t))+  (for-each+   (lambda (arg)+     (test (if a arg 'gad) arg))+   (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2))))++(let ((a #t))+  (for-each+   (lambda (arg)+     (test (if (not a) 'gad arg) arg))+   (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2))))++(test (let ((ctr 0) (a #t)) (if a (let ((b ctr)) (set! ctr (+ ctr 1)) (list b ctr)) (let ((c ctr)) (set! ctr (+ ctr 100)) (list c ctr)))) (list 0 1))++(test (if if if if) if)+;(test (((if if if) if if) if if 'gad) if)+(test (if if (if if if) if) if)+;(test (let ((car if)) (car #t 0 1)) 0)+;(test ((car (list if)) #t 0 1) 0)+(test (symbol->string 'if) "if")+(test (if (and if (if if if)) if 'gad) if)+;(test (let ((if #t)) (or if)) #t)+;(test (let ((if +)) (if 1 2 3)) 6)+(test (let ((ctr 0)) (if (let () (set! ctr (+ ctr 1)) (= ctr 1)) 0 1)) 0)+(test (let ((ctr 0)) (if (let () (set! ctr (+ ctr 1)) (if (= ctr 1) (> 3 2) (< 3 2))) 0 1)) 0)+(test (        if (> 3 2) 1 2) 1)+(test (let ((alist (list (list map 1) (list car 2) (list if 3) (list do 4)))) (assoc if alist)) (list if 3))+(test (let ((alist (list (list map 1) (list car 2) (list if 3) (list do 4)))) (assv if alist)) (list if 3))+(test (let ((alist (list (list map 1) (list car 2) (list if 3) (list do 4)))) (assq if alist)) (list if 3))+(test (let ((alist (list map car if do))) (member if alist)) (list if do))+(test (let ((alist (list map car if do))) (memv if alist)) (list if do))+(test (let ((alist (list map car if do))) (memq if alist)) (list if do))+;(test ((vector-ref (vector if) 0) #t 1 2) 1)+;(test ((vector-ref (make-vector 1 if) 0) #t 1 2) 1)+(test ((if #t + -) 3 4) 7)+(test (list (if 0 1 2)) (list 1))+;(test ((car (list if map)) #f 1 2) 2)+(test (let ((ctr 0)) (if (= ctr 0) (let () (set! ctr (+ ctr 1)) (if (= ctr 1) 2 3)) (let () (set! ctr (+ ctr 1)) (if (= ctr 1) 4 5)))) 2)+(test (let ((x (cons 1 2))) (set-cdr! x x) (if x 1 2)) 1)+(test (let ((ctr 0)) (if (let ((ctr 123)) (set! ctr (+ ctr 1)) (= ctr 124)) (let () (set! ctr (+ ctr 100)) ctr) (let () (set! ctr (+ ctr 1000)) ctr)) ctr) 100)+(test (if (let ((if 3)) (> 2 if)) 4 5) 5)++;(test (test-eval '(if (> 3 2) 1 2)) 1)++;(test (let ((ctr 0)) (call/cc (lambda (exit) (if (> 3 2) (let () (exit ctr) (set! ctr 100) ctr) #f)))) 0)+;(test (let ((ctr 0)) (call/cc (lambda (exit) (if (< 3 2) #f (let () (exit ctr) (set! ctr 100) ctr))))) 0)+;(test (let ((ctr 0)) (call/cc (lambda (exit) (if (let () (exit ctr) (set! ctr 100) ctr) 123 321)))) 0)+;(test (let ((ctr 0)) (if (> 3 2) (call/cc (lambda (exit) (set! ctr (+ ctr 1)) (exit ctr))) #f) ctr) 1)+++++;;; -------- quote --------++(test (quote a) 'a)+(test 'a (quote a))+(test '1 1)+(test '(+ 2 3) '(+ 2 3))+(test '"hi" "hi")+(test '#\a #\a)+(test '#f #f)+(test '#t #t)+(test '#b1 1)+(test '() '())+(test (+ '1 '2) 3)+(test (+ '1 '2) '3)+(test (+ ' 1 '   2) '    3)+(test (char? '#\a) #t)+(test (string? '"hi") #t)+(test (boolean? '#t) #t)+(test (if '#f 2 3) 3)+(test (if '#t 2 3) 2)+(test (vector? '#()) #t)+(test (char? (quote #\a)) #t)+(test (string? (quote "hi")) #t)+(test (boolean? (quote #t)) #t)+(test (if (quote #f) 2 3) 3)+(test (if (quote #t) 2 3) 2)+(test (vector? (quote #())) #t)+(test (+ (quote 1) (quote 2)) (quote 3))+(test (list? (quote ())) #t)+(test (pair? (quote (1 . 2))) #t)+(test (+ '1.0 '2.0) 3.0)+(test (+ '1/2 '3/2) 2)+(test (+ '1.0+1.0i '-2.0) -1.0+1.0i)+(test (let ((hi 2)) (equal? hi 'hi)) #f)+(test ''1 (quote (quote 1)))+(test ''a (quote (quote a)))+(test (symbol? '#f) #f)+(test ''quote (quote (quote quote)))+(test (+ (cadr ''3) (cadadr '''4) (cadr (cadr (cadr ''''5)))) 12)++;(test (eq? '() ()) #t) ; not sure about this -- Gauche, SCM, stklos say #t; Guile says error; clisp, cmucl, and sbcl say T+++++;;; -------- for-each --------++(test (let ((v (make-vector 5))) (for-each (lambda (i) (vector-set! v i (* i i))) '(0 1 2 3 4)) v) '#(0 1 4 9 16))+(test (let ((ctr 0) (v (make-vector 5))) (for-each (lambda (i) (vector-set! v ctr (* i i)) (set! ctr (+ ctr 1))) '(0 1 2 3 4)) v) '#(0 1 4 9 16))+(for-each (lambda (x) (display "for-each should not have called this")) '())+(test (let ((ctr 0)) (for-each (lambda (x y) (if (= x y) (set! ctr (+ ctr 1)))) '(1 2 3 4 5 6) '(2 3 3 4 7 6)) ctr) 3)+(test (let ((ctr 0)) (for-each (lambda (x y z) (set! ctr (+ ctr x y z))) '(0 1) '(2 3) '(4 5)) ctr) 15)+(test (let ((ctr 0)) (for-each (lambda (x y z) (set! ctr (+ ctr x y z))) '(1) '(3) '(5)) ctr) 9)+(test (let ((ctr 0)) (for-each (lambda (x y z) (set! ctr (+ ctr x y z))) '() '() '()) ctr) 0)+(test (let () (for-each abs '(1 2)) 1) 1)+(test (let ((ctr 0)) (for-each (lambda (a) (for-each (lambda (b) (set! ctr (+ ctr 1))) '(0 1))) '(2 3 4)) ctr) 6)+(test (let ((sum 0)) (for-each (lambda args (set! sum (+ sum (apply + args)))) '(0 1 2) '(2 1 0) '(3 4 5) '(5 4 3) '(6 7 8) '(8 7 6)) sum) 72)+(test (let ((sum 0)) (for-each (lambda (a b . args) (set! sum (+ sum a b (apply + args)))) '(0 1 2) '(2 1 0) '(3 4 5) '(5 4 3) '(6 7 8) '(8 7 6)) sum) 72)+(test (let ((sum 0)) (for-each (lambda (a b . args) (set! sum (+ sum a b (apply + args)))) '(0 1 2) '(2 1 0)) sum) 6)+(test (let () (for-each + '(0 1 2) '(2 1 0)) 0) 0)+(test (let ((d 0))+	(for-each (let ((a 0))+		    (for-each (lambda (b) (set! a (+ a b))) (list 1 2))+		    (lambda (c) (set! d (+ d c a))))+		  (list 3 4 5))+	d)+      21)+(test (let ((d 0))+	(for-each (lambda (c)+		    (let ((a 0))+		      (for-each (lambda (b) (set! a (+ a b))) (list 1 2))+		      (set! d (+ d a c))))+		  (list 3 4 5))+	d)+      21)++;(test (let ((ctr 0))+;	(let ((val (call/cc+;		    (lambda (exit)+;		      (for-each (lambda (a)+;				  (if (> a 3) (exit a))+;				  (set! ctr (+ ctr 1)))+;				(list 0 1 2 3 4 5))))))+;	  (list ctr val)))+;      (list 4 4))+;+;(test (call-with-current-continuation+;       (lambda (exit)+;	 (for-each+;	  (lambda (x)+;	    (if (negative? x) (exit x)))+;	  '(54 0 37 -3 245 19))+;	 #t))+;      -3)+;+;(test (let ((ctr 0)+;	    (cont #f)+;	    (lst '()))+;	(let ((val (call/cc+;		    (lambda (exit)+;		      (for-each (lambda (a)+;				  (if (and (not cont) (= a 2))+;				      (exit a))+;				  (if (and cont (= a 5))+;				      (exit a))+;				  (call/cc (lambda (c) (set! cont c)))+;				  (set! lst (cons ctr lst))+;				  (set! ctr (+ ctr 1)))+;				(list 0 1 2 3 4 5))))))+;	  (if (< val 5)+;	      (cont))+;	  (list ctr val lst)))+;      (list 5 5 (list 4 3 2 1 0)))++(test (let ((lst '()))+	(for-each (lambda (a) (set! lst (cons a lst)))+		  (let ((lst '()))+		    (for-each (lambda (b) (set! lst (cons b lst)))+			      (list 1 2 3))+		    lst))+	lst)+      (list 1 2 3))++;;; this is an infinite loop?+; (let ((cont #f)) (call/cc (lambda (x) (set! cont x))) (for-each cont (list 1 2 3)))+;(test (call/cc (lambda (x) (for-each x (list 1 2 3)))) 1) ; map also gives 1 ... perhaps not actually legal?+++++;;; -------- map --------++(test (map cadr '((a b) (d e) (g h))) '(b e h))+(test (map (lambda (n) (expt n n)) '(1 2 3 4 5)) '(1 4 27 256 3125))+(test (map + '(1 2 3) '(4 5 6)) '(5 7 9))++(test (apply vector (map (lambda (i) (* i i)) '(0 1 2 3 4))) '#(0 1 4 9 16))+(map (lambda (x) (display "map should not have called this")) '())+(test (let ((ctr 0)) (map (lambda (x y) (if (= x y) (set! ctr (+ ctr 1))) ctr) '(1 2 3 4 5 6) '(2 3 3 4 7 6))) (list 0 0 1 2 2 3))+(test (let ((ctr 0)) (map (lambda (x y z) (set! ctr (+ ctr x y z)) ctr) '(0 1) '(2 3) '(4 5))) (list 6 15))+(test (let ((ctr 0)) (map (lambda (x y z) (set! ctr (+ ctr x y z)) ctr) '(1) '(3) '(5))) (list 9))+(test (let ((ctr 0)) (map (lambda (x y z) (set! ctr (+ ctr x y z)) ctr) '() '() '())) '())+(test (map (lambda (a b) (+ a b)) (list 1 2) (list 1 2)) (list 2 4))+(test (map abs '(1 -2)) (list 1 2))+(test (map + '(0 1 2) '(2 1 0) '(3 4 5) '(5 4 3) '(6 7 8) '(8 7 6)) (list 24 24 24))+(test (map (lambda (a) (cons a (map (lambda (b) (+ b 1)) (list 0 1 2)))) (list 3 4 5)) '((3 1 2 3) (4 1 2 3) (5 1 2 3)))+(test (map (lambda (a) (+ a 1)) (map (lambda (b) (+ b 1)) (map (lambda (c) (+ c 1)) (list 0 1 2)))) '(3 4 5))+(test (map (lambda args (apply + args)) '(0 1 2) '(3 4 5) '(6 7 8) '(9 10 11) '(12 13 14)) '(30 35 40))+(test (map (lambda (a b . args) (+ a b (apply + args))) '(0 1 2) '(3 4 5) '(6 7 8) '(9 10 11) '(12 13 14)) '(30 35 40))+(test (map (lambda (a b . args) (+ a b (apply + args))) '(0 1 2) '(3 4 5)) '(3 5 7))++(test (let ((d 0))+	(map (let ((a 0))+	       (map (lambda (b) (set! a (+ a b))) (list 1 2))+	       (lambda (c) (set! d (+ d c a)) d))+	     (list 3 4 5)))+      (list 6 13 21))+(test (let ((d 0))+	(map (lambda (c)+	       (let ((a 0))+		 (map (lambda (b) (set! a (+ a b))) (list 1 2))+		 (set! d (+ d a c))+		 d))+	     (list 3 4 5)))+      (list 6 13 21))++;(test (let ((ctr 0))+;	(let ((val (call/cc+;		    (lambda (exit)+;		      (map (lambda (a)+;			     (if (> a 3) (exit a))+;			     (set! ctr (+ ctr 1))+;			     ctr)+;			   (list 0 1 2 3 4 5))))))+;	  (list ctr val)))+;      (list 4 4))+;+;(test (call-with-current-continuation+;       (lambda (exit)+;	 (map+;	  (lambda (x)+;	    (if (negative? x) (exit x))+;	    x)+;	  '(54 0 37 -3 245 19))))+;      -3)+;+;(test (let ((ctr 0)+;	    (cont #f)+;	    (lst '()))+;	(let ((val (call/cc+;		    (lambda (exit)+;		      (map (lambda (a)+;			     (if (and (not cont) (= a 2))+;				 (exit a))+;			     (if (and cont (= a 5))+;				 (exit a))+;			     (call/cc (lambda (c) (set! cont c)))+;			     (set! lst (cons ctr lst))+;			     (set! ctr (+ ctr 1))+;			     ctr)+;			   (list 0 1 2 3 4 5))))))+;	  (if (< val 5)+;	      (cont))+;	  (list ctr val lst)))+;      (list 5 5 (list 4 3 2 1 0)))++(test (map (lambda (a) a) (map (lambda (b) b) (list 1 2 3))) (list 1 2 3))+++++;;; --------- do --------++(test (do () (#t 1)) 1)+(for-each+ (lambda (arg)+   (test (do () (#t arg)) arg))+ (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2)))++(for-each+ (lambda (arg)+   (test (do ((i arg)) (#t i)) arg))+ (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2)))++(test (do ((i 0 (+ i 1))) ((= i 3) #f)) #f)+(test (do ((i 0 (+ i 1))) ((= i 3) i)) 3)+(test (do ((vec (make-vector 5)) (i 0 (+ i 1))) ((= i 5) vec) (vector-set! vec i i)) '#(0 1 2 3 4))+(test (let ((x '(1 3 5 7 9))) (do ((x x (cdr x)) (sum 0 (+ sum (car x))))  ((null? x) sum))) 25)+(test (do ((i 4 (- i 1)) (a 1 (* a i))) ((zero? i) a)) 24)++;(test (do () (() ()) ()) '()) ; ?? -- is '() the same as ()? -- scheme bboard sez not necessarily+(test (do () ('() '())) '())++(test (let ((x 0) (y 0)) (set! y (do () (#t (set! x 32) 123))) (list x y)) (list 32 123))+(test (let ((i 32)) (do ((i 0 (+ i 1)) (j i (+ j 1))) ((> j 33) i))) 2)+(test (let ((i 0)) (do () ((> i 1)) (set! i (+ i 1))) i) 2)+(test (let ((i 0) (j 0)) (do ((k #\a)) (#t i) (set! i (char->integer k)) (set! j (+ j i)))) 0)+(test (let ((i 0) (j 0)) (do ((k #\a)) ((> i 1) j) (set! i (char->integer k)) (set! j (+ j i)))) (char->integer #\a))+(test (let ((x 0)) (do ((i 0 (+ i 2)) (j 1 (* j 2))) ((= i 4) x) (set! x (+ x i j)))) 5)+(test (let ((sum 0)) (do ((lst '(1 2 3 4) (cdr lst))) ((null? lst) sum) (set! sum (+ sum (car lst))))) 10)+(test (do ((i 0 (+ 1 i))) ((= i 4) (do ((i 0 (+ i 2))) ((= i 10) i)))) 10)+(test (let ((i 0)) (do ((i 1 (+ i 1))) ((= i 3) i))) 3)+(test (let ((j 0)) (do ((i 0 (+ i 1))) ((= i 3) (+ i j)) (do ((j 0 (+ j i 1))) ((> j 3) j)))) 3)+(test (let ((add1 (lambda (a) (+ a 1)))) (do ((i 0 (add1 i))) ((= i 10) (add1 i)))) 11)+(test (do ((i 0 (do ((j 0 (+ j 1))) ((= j i) (+ i 1))))) ((= i 3) i)) 3)+(test (do ((i 0 (do ((i 0 (+ i 1))) ((= i 3) i)))) ((= i 3) i)) 3)+(test (let ((i 123)) (do ((i 0 (+ i 1)) (j i (+ j i))) ((> j 200) i))) 13)+(test (do ((i 0 (+ i 1))) ((> i 3) i) (set! i (* i 10))) 11)+(test (do ((i 123) (j 0 (+ j i))) ((= j 246) i)) 123)+(test (do ((i 123 i) (j 0 (+ j i))) ((= j 246) i)) 123)+(test (do ((i 0 i)) (i i)) 0)+(test (do ((i 1 i)) (i i (+ i i) (+ i i i))) 3)+(test (do ((i 1)) (#t 1) 123) 1)+(test (do ((i 0 (+ i j)) (j 0 (+ j 1))) (#t 1)) 1)+(test (do ((i 0 j) (j 0 (+ j 1))) ((= j 3) i)) 2) ; uh, lessee... lexical scoping...+(test (do ((i 1 j) (j 0 k) (k 0 m) (m 0 (+ i j k))) ((> m 10) (list i j k m))) (list 4 5 8 11))+(test (do ((do 1 (+ do do))) ((> do 3) do)) 4)+(test (do ((do 1 do) (j do do)) (do do)) 1)+(test (do ((do do do)) (do do)) do)+(test (do ((do do do)) (do do do)) do) ; ok ok!+(test (let ((i 10) (j 11) (k 12)) (do ((i i j) (j j k) (k k m) (m (+ i j k) (+ i j k))) ((> m 100) (list i j k m)))) (list 33 56 78 122))+(test (do ((i 0 (let () (set! j 3) (+ i 1))) (j 0 (+ j 1))) ((= i 3) j)) 4)+(test (let ((i 0)) (do () ((= i 3) (* i 2)) (set! i (+ i 1)))) 6)+(num-test (do ((i 0 (- i 1))) ((= i -3) i)) -3)+(num-test (do ((i 1/2 (+ i 1/2))) ((> i 2) i)) 5/2)+(num-test (do ((i 0.0 (+ i 0.1))) ((>= i 0.9999) i)) 1.0)+(num-test (do ((i 0 (- i 1/2))) ((< i -2) i)) -5/2)+(num-test (do ((i 0+i (+ i 0+i))) ((> (magnitude i) 2) i)) 0+3i)++(if with-bignums+    (begin+      (num-test (do ((i 24444516448431392447461 (+ i 1))+		     (j 0 (+ j 1)))+		    ((>= i 24444516448431392447471) j))+		10)+      (num-test (do ((i 0 (+ i 24444516448431392447461))+		     (j 0 (+ j 1)))+		    ((>= i 244445164484313924474610) j))+		10)+      (num-test (do ((i 4096 (* i 2))+		     (j 0 (+ j 1)))+		    ((= i 4722366482869645213696) j))+		60)))++(num-test (do ((x (list 1 2 3) (cdr x)) (j -1)) ((null? x) j) (set! j (car x))) 3)++(test (let ((x 0))+	(do ((i 0 (+ i 1)))+	    ((= i (do ((j 0 (+ j 1))) ((= j 2) (+ j 1)))))+	  (set! x (+ x i)))+	x)+      3)+(test (let ((x 0))+	(do ((i 0 (+ i (do ((j 0 (+ j 1))) ((= j 2) 1)))))+	    ((= i 3) x)+	  (set! x (+ x i))))+      3)+(test (let ((x 0))+	(do ((i 0 (+ i (do ((j 0 (+ j 1))) ((= j 2) 1)))))+	    ((= i 3) (do ((j 0 (+ j 1))) ((= j 5) x) (set! x j)))+	  (set! x (+ x i))))+      4)++;(test (call/cc (lambda (exit) (do ((i 0 (+ i 1))) ((= i 100) i) (if (= i 2) (exit 321))))) 321)+;(test (call/cc (lambda (exit) (do ((i 0 (if (= i 3) (exit 321) (+ i 1)))) ((= i 100) i)))) 321)+;(test (call/cc (lambda (exit) (do ((i 0 (+ i 1))) ((= i 10) (exit 321))))) 321)+;(test (call/cc (lambda (exit) (do ((i 0 (+ i 1))) ((= i 10) i) (if (= i -2) (exit 321))))) 10)+;(test (do ((x 0 (+ x 1)) (y 0 (call/cc (lambda (c) c)))) ((> x 5) x) #f) 6)+(test (let ((happy #f)) (do ((i 0 (+ i 1))) (happy happy) (if (> i 3) (set! happy i)))) 4)++(test (+ (do ((i 0 (+ i 1))) ((= i 3) i)) (do ((j 0 (+ j 1))) ((= j 4) j))) 7)+(test (let ((do 1) (map 2) (for-each 3) (quote 4)) (+ do map for-each quote)) 10)++;(test (let ((cont #f)+;	    (j 0)+;	    (k 0))+;	(call/cc (lambda (exit)+;		   (do ((i 0 (+ i 1)))+;		       ((= i 100) i)+;		     (set! j i)+;		     (call/cc (lambda (r) (set! cont r)))+;		     (if (= j 2) (exit))+;		     (set! k i))))+;	(if (= j 2)+;	    (begin+;	      (set! j 3)+;	      (cont))+;	    (list j k)))+;      (list 99 99))++;(test (call/cc (lambda (r) (do () (#f) (r 1)))) 1)+(test (let ((hi (lambda (x) (+ x 1)))) (do ((i 0 (hi i))) ((= i 3) i))) 3)+(test (do ((i 0 (+ i 1))) (list 1) ((= i 3) #t)) 1) ; a typo originally -- Guile and Gauche are happy with it++++;;; -------- set! --------++(test (let ((a 1)) (set! a 2) a) 2)+(for-each+ (lambda (arg)+   (test (let ((a 0)) (set! a arg) a) arg))+ (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2)))++;(test (let ((a 1)) (call/cc (lambda (r) (set! a (let () (if (= a 1) (r 123)) 321)))) a) 1)+(test (let ((a (lambda (b) (+ b 1)))) (set! a (lambda (b) (+ b 2))) (a 3)) 5)+(test (let ((a (lambda (x) (set! x 3) x))) (a 1)) 3)++++;;; -------- or --------++(test (or (= 2 2) (> 2 1)) #t)+(test (or (= 2 2) (< 2 1)) #t)+(test (or #f #f #f) #f)+(test (or) #f)+(test (or (memq 'b '(a b c)) (+ 3 0)) '(b c))+(test (or 3 9) 3)+(test (or #f 3 asdf) 3) ; "evaluation stops immediately"+(test (or 3 (/ 1 0) (display "or is about to exit!") (exit)) 3)++(for-each+ (lambda (arg)+   (test (or arg) arg))+ (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++(test (call-with-input-file "r5rstest.scm"+	(lambda (p)+	  (let ((loc 0))+	    (let loop ((val (read p)))+	      (or (eof-object? val)+		  (> loc 10000) ; try to avoid the read-error stuff+		  (begin+		    (set! loc (+ 1 loc))+		    (loop (read p)))))+	    (> loc 10000))))+      #t)++(test (or (and (or (> 3 2) (> 3 4)) (> 2 3)) 4) 4)+(test (or or) or)+(test (or (or (or))) #f)+(test (or (or (or) (and))) #t)+(test (let ((a 1)) (or (let () (set! a 2) #f) (= a 1) (let () (set! a 3) #f) (and (= a 3) a) (let () (set! a 4) #f) a)) 3)+(test (or (let ((or #t)) or)) #t)+(test (or '#f '()) '())+;(test (call/cc (lambda (r) (or #f (> 3 2) (r 123) 321))) #t)+;(test (call/cc (lambda (r) (or #f (< 3 2) (r 123) 321))) 123)+(test (+ (or #f (not (null? '())) 3) (or (zero? 1) 2)) 5)+(test (or 0) 0)+(test (if (or) 1 2) 2)++++;;; -------- and --------++(test (and (= 2 2) (> 2 1)) #t)+(test (and (= 2 2) (< 2 1)) #f)+(test (and 1 2 'c '(f g)) '(f g))+(test (and) #t)+(test (and 3) 3)+(test (and (memq 'b '(a b c)) (+ 3 0)) 3)+(test (and 3 9) 9)+(test (and #f 3 asdf) #f) ; "evaluation stops immediately"+(test (and 3 (zero? 1) (/ 1 0) (display "and is about to exit!") (exit)) #f)+(test (if (and) 1 2) 1)+(test (if (+) 1 2) 1)+(test (if (*) 1 2) 1)++(for-each+ (lambda (arg)+   (test (and arg) arg))+ (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++(test (call-with-input-file "r5rstest.scm"+	(lambda (p)+	  (let ((loc 0))+	    (let loop ((val (read p)))+	      (and (not (eof-object? val))+		   (< loc 10000)+		   (begin+		     (set! loc (+ 1 loc))+		     (loop (read p)))))+	    (>= loc 10000))))+      #t)++(test (and (or (and (> 3 2) (> 3 4)) (> 2 3)) 4) #f)+(test (and and) and)+(test (and (and (and))) #t)+(test (and (and (and (and (or))))) #f)+(test (let ((a 1)) (and (let () (set! a 2) #t) (= a 1) (let () (set! a 3) #f) (and (= a 3) a) (let () (set! a 4) #f) a)) #f)+(test (and (let ((and #t)) and)) #t)+(test (and '#t '()) '())+;(test (call/cc (lambda (r) (and #t (> 3 2) (r 123) 321))) 123)+;(test (call/cc (lambda (r) (and #t (< 3 2) (r 123) 321))) #f)+(test (+ (and (null? '()) 3) (and (zero? 0) 2)) 5)+++++;;; -------- cond --------++(test (cond ('a)) 'a)+(test (cond (#f 'a) ('b)) 'b)+(test (cond (#t 'a) (#t 'b)) 'a)+(test (cond ((> 3 2) 'greater) ((< 3 2) 'less)) 'greater)+(test (cond ((> 3 3) 'greater) ((< 3 3) 'less)  (else 'equal)) 'equal)+(test (cond ((assv 'b '((a 1) (b 2))) => cadr)  (else #f)) 2)+(test (cond (#f 2) (else 5)) 5)+(test (cond (1 2) (else 5)) 2)+(test (cond (1 => (lambda (x) (+ x 2))) (else 8)) 3)+(test (cond ((+ 1 2))) 3)+(test (cond ((zero? 1) 123) ((= 1 1) 321)) 321)+(test (cond ('() 1)) 1)+;(test (cond (1 2) '()) 2)+(test (cond (1 2 3)) 3)+(test (cond ((= 1 2) 3) ((+ 3 4))) 7)+(test (cond ((= 1 1) (abs -1) (+ 2 3) (* 10 2)) (else 123)) 20)+(test (let ((a 1)) (cond ((= a 1) (set! a 2) (+ a 3)))) 5)+(test (let ((a 1)) (cond ((= a 2) (+ a 2)) (else (set! a 3) (+ a 3)))) 6)+(test (cond ((= 1 1))) #t)+(test (cond ((= 1 2) #f) (#t)) #t)+(test (cond ((+ 1 2))) 3)+(test (cond ((cons 1 2))) '(1 . 2))+(test (cond (#f #t) ((string-append "hi" "ho"))) "hiho")+(test (cond ('() 3) (#t 4)) 3)+(test (cond ((list) 3) (#t 4)) 3)+;;; (cond (1 1) (asdf 3)) -- should this be an error?++(for-each+ (lambda (arg)+   (test (cond ((or arg) => (lambda (x) x))) arg))+ (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))+++(test (cond ((+ 1 2) => (lambda (x) (+ 1 x)))) 4)+(test (cond ((cons 1 2) => car)) 1)+; (cond ((values 1 2) => +)) -- seems like it ought to work+;(test (cond ((values -1) => abs)) 1)++(test (cond (else 1)) 1)+;(test (call/cc (lambda (r) (cond ((r 4) 3) (else 1)))) 4)+(test (cond ((cond (#t 1)))) 1)++(for-each+ (lambda (arg)+   (test (cond (#t arg)) arg))+ (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++(for-each+ (lambda (arg)+   (test (cond (arg)) arg))+ (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++(for-each+ (lambda (arg)+   (test (cond (#f 1) (else arg)) arg))+ (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++(for-each+ (lambda (arg)+   (test (cond (arg => (lambda (x) x))) arg))+ (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++(test (let ((=> 3) (cond 4)) (+ => cond)) 7)+(test (cond (cond 'cond)) 'cond)++;(test (and (defined? 'else) (boolean? else)) #f)++++;;; -------- case --------++(test (case (* 2 3) ((2 3 5 7) 'prime) ((1 4 6 8 9) 'composite))  'composite)+(test (case (car '(c d)) ((a e i o u) 'vowel) ((w y) 'semivowel) (else 'consonant)) 'consonant)+(test (case 3.1 ((1.3 2.4) 1) ((4.1 3.1 5.4) 2) (else 3)) 2)+(test (case 3/2 ((3/4 1/2) 1) ((3/2) 2) (else 3)) 2)+(test (case 3 ((1) 1 2 3) ((2) 2 3 4) ((3) 3 4 5)) 5)+(test (case 1+i ((1) 1) ((1/2) 1/2) ((1.0) 1.0) ((1+i) 1+i)) 1+i)+(test (case 'abs ((car cdr) 1) ((+ cond) 2) ((abs) 3) (else 4)) 3)+(test (case #\a ((#\b) 1) ((#\a) 2) ((#\c) 3)) 2)+(test (case (boolean? 1) ((#t) 2) ((#f) 1) (else 0)) 1)+(test (case 1 ((1 2 3) (case 2 ((1 2 3) 3)))) 3)+(test (case 1 ((1 2) 1) ((3.14 2/3) 2)) 1)+(test (case 1 ((1 2) 1) ((#\a) 2)) 1)+(test (case 1 ((1 2) 1) ((#\a) 2) ((car cdr) 3) ((#f #t) 4)) 1)+(test (case #f ((1 2) 1) ((#\a) 2) ((car cdr) 3) ((#f #t) 4)) 4)+(test (case 1 ((#t) 2) ((#f) 1) (else 0)) 0)+(test (let ((x 1)) (case x ((x) "hi") (else "ho"))) "ho")+(test (let ((x 1)) (case x ((1) "hi") (else "ho"))) "hi")+(test (let ((x 1)) (case x (('x) "hi") (else "ho"))) "ho")+(test (let ((x 1)) (case 'x ((x) "hi") (else "ho"))) "hi")++(test (let ((x 1)) (case (+ 1 x) ((0 "hi" #f) 3/4) ((#\a 1+3i '(1 . 2)) "3") ((-1 'hi 2 2.0) #\f))) #\f)+(test (case (case 1 ((0 2) 3) (else 2)) ((0 1) 2) ((4 2) 3) (else 45)) 3)+(test (case 3/4 ((0 1.0 5/6) 1) (("hi" 'hi 3/4) 2) (else 3)) 2)+(test (case (case (+ 1 2) (else 3)) ((3) (case (+ 2 2) ((2 3) 32) ((4) 33) ((5) 0)))) 33)+(test (let ((x 1)) (case x ((0) (set! x 12)) ((2) (set! x 32))) x) 1)++(test (case 1 (else #f)) #f)+(test (case 1 ((1 2) (let ((case 3)) (+ case 1))) ((3 4) 0)) 4)++(for-each+ (lambda (arg)+   (test (case 1 ((0) 'gad) ((1 2 3) arg) (else 'gad)) arg))+ (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++(for-each+ (lambda (arg)+   (test (case arg ((0) 'gad) ((1 2 3) arg) (else 'gad)) 'gad))+ (list "hi" -1 #\a 0 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++;(test (call/cc (lambda (r) (case 1 ((1) (r 123) #t) (else #f)))) 123)+;(test (call/cc (lambda (r) (case 1 ((0) 0) (else (r 123) #f)))) 123)++(test (case '() ((1) 1) ('() 2)) 2)+(test (case (list) ((1) 1) ('() 2)) 2)+(test (case '() ((1) 1) ((()) 2)) 2)+(test (case (list) ((1) 1) ((()) 2)) 2)++++;;; -------- lambda --------++(test (procedure? (lambda (x) x)) #t)+(test ((lambda (x) (+ x x)) 4) 8)+(test (let ((reverse-subtract (lambda (x y) (- y x)))) (reverse-subtract 7 10)) 3)+(test (let ((add4 (let ((x 4)) (lambda (y) (+ x y))))) (add4 6)) 10)+(test ((lambda x x) 3 4 5 6) (list 3 4 5 6))+(test ((lambda (x y . z) z) 3 4 5 6) (list 5 6))+(test ((lambda (a b c d e f) (+ a b c d e f)) 1 2 3 4 5 6) 21)+(test (let ((foo (lambda () 9))) (+ (foo) 1)) 10)+(test (let ((a 1)) (let ((f (lambda (x) (set! a x) a))) (let ((c (f 123))) (list c a)))) (list 123 123))+(test (let ((a 1) (b (lambda (a) a))) (b 3)) 3)+(test (let ((ctr 0)) (letrec ((f (lambda (x) (if (> x 0) (begin (set! ctr (+ ctr 1)) (f (- x 1))) 0)))) (f 10) ctr)) 10)+(test (let ((f (lambda (x) (car x)))) (f '(4 5 6))) 4)+(test ((lambda () ((lambda (x y) ((lambda (z) (* (car z) (cdr z))) (cons x y))) 3 4))) 12)+(test (let ((ctr 0)) (define (f) (set! ctr (+ ctr 1)) ctr) (let ((x (f))) (let ((y (f))) (list x y ctr)))) (list 1 2 2))++(test (let ((x 5)) (define foo (lambda (y) (bar1 x y))) (define bar1 (lambda (a b) (+ (* a b) a))) (foo (+ x 3))) 45)+(test (let ((x 5)) (letrec ((foo (lambda (y) (bar2 x y))) (bar2 (lambda (a b) (+ (* a b) a)))) (foo (+ x 3)))) 45)+(num-test (let () (define compose (lambda (f g) (lambda args (f (apply g args))))) ((compose sqrt *) 12 75))  30.0)+(test (let ((f (lambda () (lambda (x y) (+ x y))))) ((f) 1 2)) 3)+(test ((lambda (x) (define y 4) (+ x y)) 1) 5)+(test ((lambda () (define (y x) (+ x 1)) (y 1))) 2)+(test ((lambda (x) 123 (let ((a (+ x 1))) a)) 2) 3)+(test ((lambda (x) "documentation" (let ((a (+ x 1))) a)) 2) 3)+(test ((lambda (x) (x 1)) (lambda (y) (+ y 1))) 2)+(test (let ((a 1)) (let ((b (lambda (x) (define y 1) (define z 2) (define a 3) (+ x y z a)))) (b a))) 7)+(test ((lambda (f x) (f x x)) + 11) 22)+(test ((lambda () (+ 2 3))) 5)++(for-each+ (lambda (arg)+   (test ((lambda (x) x) arg) arg))+ (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++;(let ((list-length+       ;(lambda (obj)+	 ;(call-with-current-continuation+	  ;(lambda (return)+	    ;(letrec ((r (lambda (obj) (cond ((null? obj) 0)+					    ;((pair? obj) (+ (r (cdr obj)) 1))+					    ;(else (return #f))))))+	      ;(r obj)))))))+  ;(test (list-length '(1 2 3 4)) 4)+  ;(test (list-length '(a b . c)) #f))++(test (let ((samples (vector 0 1 2 3 4 5 6 7 8 9 10)))+	(let ((make-scaler+	       (lambda (start end)+		 (letrec ((ctr start)+			  (us (lambda (them)+				(vector-set! samples ctr (* 2 (vector-ref samples ctr)))+				(set! ctr (+ ctr 2))+				(if (<= ctr end)+				    (them us)))))+		   us))))+	  ((make-scaler 0 11)+	   (make-scaler 1 11)))+	samples)+      (vector 0 2 4 6 8 10 12 14 16 18 20))++(test ((lambda (x . y) y) 1 2 '(3 . 4)) '(2 (3 . 4)))+(test ((lambda (x . y) y) 1) '())+(test ((lambda x x) '()) '(()))+(test ((lambda x x)) '())        ; ??+(test ((lambda (x) x) '()) '())+(test (let ((lambda 4)) (+ lambda 1)) 5)+(test ((lambda (x) (+ x ((lambda (x) (+ x 1)) 2))) 3) 6)+(test ((lambda (x) (define y 1) (+ x y)) 2) 3)+(test ((lambda (a) "this is a doc string" a) 1) 1)+;;; ideally ((lambda (a) "hiho" (define x 1) x) 1) -> 1 but I'm not sure it's r5rs-ish+++(test ((lambda lambda lambda) 'x) '(x))+;(test ((lambda (begin) (begin 1 2 3)) (lambda lambda lambda)) '(1 2 3))++(test (let ((funcs (make-vector 3 #f)))+	(do ((i 0 (+ i 1)))+	    ((= i 3))+	  (vector-set! funcs i (lambda () (+ i 1))))+	(+ ((vector-ref funcs 0))+	   ((vector-ref funcs 1))+	   ((vector-ref funcs 2))))+      6)++(test (let ((i 1))+	(let ((func1 (lambda () i)))+	  (let ((i 2))+	    (let ((func2 (lambda () i)))+	      (+ (func1) (func2))))))+      3)++(test (let ((funcs (make-vector 3 #f)))+	(map+	 (lambda (i)+	   (vector-set! funcs i (lambda () (+ i 1))))+	 (list 0 1 2))+	(+ ((vector-ref funcs 0))+	   ((vector-ref funcs 1))+	   ((vector-ref funcs 2))))+      6)++(test (let ((func #f))+	(define (func1 x)+	  (set! func (lambda () (+ x 1))))+	(func1 1)+	(+ (func)+	   (let ()+	     (func1 2)+	     (func))))+      5)++(test (((lambda (x) (lambda () (+ x 1))) 32)) 33)++(test (let ((func #f))+	(define (func1 x)+	  (set! func (lambda () (string-append x "-"))))+	(func1 "hi")+	(string-append (func)+		       (let ()+			 (func1 "ho")+			 (func))))+      "hi-ho-")++(test (let ((func1 #f)+	    (func2 #f))+	(let ((x 1))+	  (set! func1 (lambda () x))+	  (set! func2 (lambda (y) (set! x y) y)))+	(+ (func1)+	   (let ()+	     (func2 32)+	     (func1))))+      33)++(test (let ((funcs (make-vector 3)))+	(let ((hi (lambda (a) (vector-set! funcs (- a 1) (lambda () a)))))+	  (hi 1) (hi 2) (hi 3)+	  (+ ((vector-ref funcs 0))+	     ((vector-ref funcs 1))+	     ((vector-ref funcs 2)))))+      6)++(test (let ((hi (lambda (a) (+ a 1)))+	    (ho (lambda (a) (a 32))))+	(+ (hi (hi (hi 1)))+	   (ho hi)))+      37)++(test ((if (> 3 2) + -) 3 2) 5)+(test (let ((op +)) (op 3 2)) 5)+(test (((lambda () +)) 3 2) 5)+(test ((car (cons + -)) 3 2) 5)+(test ((do ((i 0 (+ i 1))) ((= i 3) +) ) 3 2) 5)+(test (((lambda (x) x) (lambda (x) x)) 3) 3)+(test ((((lambda (x) x) (lambda (x) x)) (lambda (x) x)) 3) 3)+(test (((lambda (x) (lambda (y) x)) 3) 4) 3)+(test (((lambda (x) (lambda (x) x)) 3) 4) 4)+(test (let ((x 32)) (((lambda (x) (lambda (y) x)) 3) x)) 3)+;(test ((call/cc (lambda (return) (return +))) 3 2) 5)+;(test ((call-with-values (lambda () (values +)) (lambda (x) x)) 3 2) 5)+(test ((case '+ ((+) +)) 3 2) 5)+(test ((case '+ ((-) -) (else +)) 3 2) 5)+;(test ((call/cc (lambda (return) (dynamic-wind (lambda () #f) (lambda () (return +)) (lambda () #f)))) 3 2) 5)+;(test (+ 1 ((call/cc (lambda (return) (dynamic-wind (lambda () #f) (lambda () (return +)) (lambda () #f)))) 3 2) 2) 8)++++;;; -------- begin --------++(test (let () (begin) #f) #f)+(test (let () (begin (begin (begin (begin)))) #f) #f)+(test (let () (begin (define x 2) (define y 1)) (+ x y)) 3)+(test (let () (begin (define x 0)) (begin (set! x 5) (+ x 1)))  6)+(test (let () (begin (define first car)) (first '(1 2))) 1)+(test (let () (begin (define x 3)) (begin (set! x 4) (+ x x))) 8)++(if (equal? (begin 1) 1)+    (begin+      (test (let () (begin (define x 0)) (set! x (begin (begin 5))) (begin ((begin +) (begin x) (begin (begin 1))))) 6)++      (test (let ((x 5))+	      (begin (begin (begin)+			    (begin (begin (begin) (define foo (lambda (y) (bar3 x y)))+					  (begin)))+			    (begin))+		     (begin)+		     (begin)+		     (begin (define bar3 (lambda (a b) (+ (* a b) a))))+		     (begin))+	      (begin)+	      (begin (foo (+ x 3))))+	    45)++      (for-each+       (lambda (arg)+	 (test (begin arg) arg))+       (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++      (test (if (= 1 1) (begin 2) (begin 3)) 2)+      ))++(test (let ((begin 3)) (+ begin 1)) 4)+(test ((lambda (x) (begin (set! x 1) (let ((a x)) (+ a 1)))) 2) 2)+;;; apparently these can be considered errors or not (guile says error, stklos and gauche do not)+;(test (begin (define x 0) (+ x 1)) 1)+;(test ((lambda () (begin (define x 0) (+ x 1)))) 1)+;(test (let ((f (lambda () (begin (define x 0) (+ x 1))))) (f)) 1)++(test ((lambda () (begin (define x 0)) (+ x 1))) 1)+(test (let ((f (lambda () (begin (define x 0)) (+ x 1)))) (f)) 1)+(test (let ((x 32)) (begin (define x 3)) x) 3)+(test ((lambda (x) (begin (define x 3)) x) 32) 3)+(test (let* ((x 32) (y x)) (define x 3) y) 32)++;(test (let ((z 0)) (begin (define x 32)) (begin (define y x)) (set! z y) z) 32) ; so begin is like let*? -- guile uses letrec here = error+;(test (let ((z 0)) (begin (define x 32) (define y x)) (set! z y) z) 32)         ; similarly here+;;; I can't find anything in r5rs.html that mandates letrec here, or that says it's in error+++++;;; -------- apply --------++(test (apply (lambda (a b) (+ a b)) (list 3 4)) 7)+(test (apply + 10 (list 3 4)) 17)+(test (apply list '()) '())+(test (apply + '(1 2)) 3)+(test (apply - '(1 2)) -1)+(test (apply max 3 5 '(2 7 3)) 7)+(test (apply cons '((+ 2 3) 4)) '((+ 2 3) . 4))+(test (apply + '()) 0)+(test (apply + (list 3 4)) 7)+(test (apply + '()) 0)+(test (apply + 2 '(3)) 5)+(test (apply + 2 3 '()) 5)+(test (apply + '(2 3)) 5)+(test (apply list 1 '(2 3)) (list 1 2 3))+(test (apply apply (list list 1 2 '(3))) (list 1 2 3))+(test (vector? (apply make-vector '(1))) #t)+(test (apply make-vector '(1 1)) '#(1))+(test (let* ((x '(1 2 3)) (y (apply list x))) (not (eq? x y))) #t) ; is this standard?+(test (apply min '(1 2 3 5 4 0 9)) 0)+(test (apply min 1 2 4 3 '(4 0 9)) 0)+(test (apply vector 1 2 '(3)) '#(1 2 3))+(test (apply (lambda (x . y) x) (list 1 2 3)) 1)+(test (apply * (list 2 (apply + 1 2 '(3)))) 12)+(test (apply (if (> 3 2) + -) '(3 2)) 5)++(for-each+ (lambda (arg)+   (test (apply (lambda (x) x) (list arg)) arg))+ (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++(test (apply cadadr (list '''4)) 4)+(test (apply string-ref "hi" '(0)) #\h)+(test (let ((x (string-copy "hi"))) (apply string-set! x 0 '(#\c)) x) "ci")+(test (apply apply (list + '(3  2))) 5)+(test (apply apply apply apply (list (list (list + '(3  2))))) 5)+(test (apply + 1 2 (list 3 4)) 10)++++;;; -------- define --------+;;;+;;; trying to avoid top-level definitions here++(let ()+  (define x 2)+  (test (+ x 1) 3)+  (set! x 4)+  (test (+ x 1) 5)+  (let ()+    (define (tprint x) #t)+    (test (tprint 56) #t)+    (let ()+      (define first car)+      (test (first '(1 2)) 1)+      (let ()+	(define foo (lambda () (define x 5) x))+	(test (foo) 5)+	(let ()+	  (define (foo x) ((lambda () (define x 5) x)) x)+	  (test (foo 88) 88))))))+++(test (letrec ((foo (lambda (arg) (or arg (and (procedure? foo) (foo 99)))))) (define bar4 (foo #f)) (foo #f)) 99)+(test (letrec ((foo 77) (bar5 #f) (retfoo (lambda () foo))) (define baz (retfoo)) (retfoo)) 77)++;(test (let () (define .. 1) ..) 1)++(test (let () (define (hi a) (+ a 1)) (hi 2)) 3)+(test (let () (define (hi a . b) (+ a (cadr b) 1)) (hi 2 3 4)) 7)+(test (let () (define (hi) 1) (hi)) 1)+(test (let () (define (hi . a) (apply + a)) (hi 1 2 3)) 6)++(for-each+ (lambda (arg)+   (test (let () (define x arg) x) arg))+ (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++(test ((lambda (x) (define (hi a) (+ a 1)) (hi x)) 1) 2)+(test (let ((x 2)) (define f (lambda (y) (+ y x))) (f 3)) 5)+(begin (define r5rstest-plus (lambda (x y) (+ x y))) (define r5rstest-x 32))+(test (r5rstest-plus r5rstest-x 3) 35)++++++;;; -------- values, call-with-values --------++;(test (call-with-values (lambda () (values 1 2 3)) +) 6)+;(test (call-with-values (lambda () (values 4 5)) (lambda (a b) b))  5)+;(test (call-with-values (lambda () (values 4 5)) (lambda (a b) (+ a b))) 9)+;(test (call-with-values * -) -1) ; right...+;(test (values 1) 1)+;(test (call-with-values (lambda () (values 1 2 3 4)) list) (list 1 2 3 4))+;(test (+ (values 1) (values 2)) 3)+;(test (+ (values '1) (values '2)) 3)+;(test (if (values #t) 1 2) 1)+;(test (if (values '#t) 1 2) 1)+;(test (values 1 2 3) (values 1 2 3))+;;(test (call-with-values (lambda () (values)) list) '())+;(test (call-with-values (lambda () 4) (lambda (x) x)) 4)+;(test (let () (values 1 2 3) 4) 4)+;(test (apply + (values '())) 0)+;+;(for-each+; (lambda (arg)+;   (test (values arg) arg))+; (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))+;+;(for-each+; (lambda (arg)+;   (test (call-with-values (lambda () (values arg arg)) (lambda (a b) b)) arg))+; (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))+;+;(test (call-with-values (lambda () (values "hi" 1 3/2 'a)) (lambda (a b c d) (+ b c))) 5/2)+;;(test (call-with-values values (lambda arg arg)) '())+;(test (string-ref (values "hi") 1) #\i)+;+;(test (letrec ((split (lambda (ls)+;			(if (or (null? ls) (null? (cdr ls)))+;			    (values ls '())+;			    (call-with-values+;				(lambda () (split (cddr ls)))+;			      (lambda (odds evens)+;				(values (cons (car ls) odds)+;					(cons (cadr ls) evens))))))))+;	(split '(a b c d e f)))+;      (values '(a c e) '(b d f)))+;+;;(test (call-with-values (lambda () (call/cc (lambda (k) (k 2 3)))) (lambda (x y) (list x y))) '(2 3))+;                         ;;; s7: (lambda (x y) (list x y)): not enough arguments: (2)+;+;(test (let ((values 3)) (+ 2 values)) 5)+;(test (apply values (list 1 2)) (values 1 2))+;(test (let ((a (values 1 2))) a) (values 1 2))+;(test (let ((a (values 1))) a) 1)+;+;(test (call-with-values (lambda () 2) (lambda (x) x)) 2)++++;;; -------- let, let*, letrec --------++(test (let ((x 2) (y 3)) (* x y)) 6)+(test (let ((x 32)) (let ((x 3) (y x)) y)) 32)+(test (let ((x 32)) (let* ((x 3) (y x)) y)) 3)+(test (let ((x 2) (y 3)) (let ((x 7) (z (+ x y))) (* z x))) 35)+(test (let ((x 2) (y 3)) (let* ((x 7)  (z (+ x y))) (* z x))) 70)+(test (letrec ((even? (lambda (n)  (if (zero? n) #t (odd? (- n 1))))) (odd? (lambda (n)  (if (zero? n) #f (even? (- n 1)))))) (even? 88))  #t)+(test (let loop ((numbers '(3 -2 1 6 -5))+		 (nonneg '())+		 (neg '()))+	(cond ((null? numbers)+	       (list nonneg neg))+	      ((>= (car numbers) 0)+	       (loop (cdr numbers) (cons (car numbers) nonneg)  neg))+	      ((< (car numbers) 0)+	       (loop (cdr numbers) nonneg (cons (car numbers) neg)))))+      '((6 1 3) (-5 -2)))++(test (let ((x 3)) (define x 5) x) 5)+(test (let* () (define x 8) x) 8)+(test (letrec () (define x 9) x) 9)+(test (letrec ((x 3)) (define x 10) x) 10)+(test (let foo () 1) 1)+(test (let ((f -)) (let f ((n (f 1))) n)) -1)+(test (let () 1 2 3 4) 4)++(test (let ((x 1)) (let ((x 32) (y x)) y)) 1)+(test (let ((x 1)) (letrec ((y (if #f x 1)) (x 32)) 1)) 1)+(test (let ((x 1)) (letrec ((y (lambda () (+ 1 x))) (x 32)) (y))) 33) ; good grief! -- (let ((x 1)) (letrec ((y (* 0 x)) (x 32)) y))+(test (let* ((x 1) (f (letrec ((y (lambda () (+ 1 x))) (x 32)) y))) (f)) 33)+(test (letrec ((x 1) (y (let ((x 2)) x))) (+ x y)) 3)+(test (letrec ((f (lambda () (+ x 3))) (x 2)) (f)) 5)+(test (let* ((x 1) (x 2)) x) 2)+(test (let* ((x 1) (y x)) y) 1)+(test (let ((x 1)) (let ((x 32) (y x)) (+ x y))) 33)+(test (let ((x 1)) (let* ((x 32) (y x)) (+ x y))) 64)+(test (let ((x 'a) (y '(b c))) (cons x y)) '(a b c))+(test (let ((x 0) (y 1)) (let ((x y) (y x)) (list x y))) (list 1 0))+(test (let ((x 0) (y 1)) (let* ((x y) (y x)) (list x y))) (list 1 1))+(test (letrec ((sum (lambda (x) (if (zero? x) 0 (+ x (sum (- x 1))))))) (sum 5)) 15)+(test (let ((divisors (lambda (n) (let f ((i 2)) (cond ((>= i n) '()) ((integer? (/ n i)) (cons i (f (+ i 1)))) (else (f (+ i 1)))))))) (divisors 32)) '(2 4 8 16))+(test (let ((a -1)) (let loop () (if (not (positive? a)) (begin (set! a (+ a 1)) (loop)))) a) 1)+;(test (let* ((let 3) (x let)) (+ x let)) 6) ; Commented out for Haschoo: since let* uses let in its definition, this can't work+(test (let () (let () (let () '()))) '())+(test (let ((x 1)) (let ((y 0)) (begin (let ((x (* 2 x))) (set! y x))) y)) 2)+(test (let* ((x 1) (x (+ x 1)) (x (+ x 2))) x) 4)+; (test (let ((.. 2) (.... 4) (..... +)) (..... .. ....)) 6)++(for-each+ (lambda (arg)+   (test (let ((x arg)) x) arg))+ (list "hi" -1 #\a "" '() '#() (current-output-port) 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t abs (list 1 2 3) '(1 . 2)))++(test (let ((x 1)) (= 1 (let ((y 2)) (set! x y) x)) (+ x 1)) 3)+(test (let ((x 1)) (let ((xx (lambda (a) (set! x a) a))) (= 1 (xx 2))) (+ x 1)) 3)+++;(let ((initial-chars "aA!$%&*/:<=>?^_~")+;      (subsequent-chars "9aA!$%&*+-./:<=>?@^_~")+;      (ctr 0))+;  (display (format #f "(let ("))+;  (do ((i 0 (+ i 1)))+;      ((= i (string-length initial-chars)))+;    (display (format #f "(~A ~D) " (string (string-ref initial-chars i)) ctr))+;    (set! ctr (+ ctr 1)))+;+;  (do ((i 0 (+ i 1)))+;      ((= i (string-length initial-chars)))+;    (do ((k 0 (+ k 1)))+;	((= k (string-length subsequent-chars)))+;      (display (format #f "(~A ~D) " (string (string-ref initial-chars i) (string-ref subsequent-chars k)) ctr))+;      (set! ctr (+ ctr 1))))+;+;  (display (format #f ")~%  (+ "))+;  (do ((i 0 (+ i 1)))+;      ((= i (string-length initial-chars)))+;    (display (format #f "~A " (string (string-ref initial-chars i)))))+;+;  (do ((i 0 (+ i 1)))+;      ((= i (string-length initial-chars)))+;    (do ((k 0 (+ k 1)))+;	((= k (string-length subsequent-chars)))+;      (display (format #f "~A " (string (string-ref initial-chars i) (string-ref subsequent-chars k))))))+;+;  (display (format #f "))~%")))++;(num-test (let ((a 0) (A 1) (! 2) ($ 3) (% 4) (& 5) (* 6) (/ 7) (: 8) (< 9) (= 10) (> 11) (? 12) (^ 13) (_ 14) (~ 15) (a9 16) (aa 17) (aA 18) (a! 19) (a$ 20) (a% 21) (a& 22) (a* 23) (a+ 24) (a- 25) (a. 26) (a/ 27) (a: 28) (a< 29) (a= 30) (a> 31) (a? 32) (a@ 33) (a^ 34) (a_ 35) (a~ 36) (A9 37) (Aa 38) (AA 39) (A! 40) (A$ 41) (A% 42) (A& 43) (A* 44) (A+ 45) (A- 46) (A. 47) (A/ 48) (A: 49) (A< 50) (A= 51) (A> 52) (A? 53) (A@ 54) (A^ 55) (A_ 56) (A~ 57) (!9 58) (!a 59) (!A 60) (!! 61) (!$ 62) (!% 63) (!& 64) (!* 65) (!+ 66) (!- 67) (!. 68) (!/ 69) (!: 70) (!< 71) (!= 72) (!> 73) (!? 74) (!@ 75) (!^ 76) (!_ 77) (!~ 78) ($9 79) ($a 80) ($A 81) ($! 82) ($$ 83) ($% 84) ($& 85) ($* 86) ($+ 87) ($- 88) ($. 89) ($/ 90) ($: 91) ($< 92) ($= 93) ($> 94) ($? 95) ($@ 96) ($^ 97) ($_ 98) ($~ 99) (%9 100) (%a 101) (%A 102) (%! 103) (%$ 104) (%% 105) (%& 106) (%* 107) (%+ 108) (%- 109) (%. 110) (%/ 111) (%: 112) (%< 113) (%= 114) (%> 115) (%? 116) (%@ 117) (%^ 118) (%_ 119) (%~ 120) (&9 121) (&a 122) (&A 123) (&! 124) (&$ 125) (&% 126) (&& 127) (&* 128) (&+ 129) (&- 130) (&. 131) (&/ 132) (&: 133) (&< 134) (&= 135) (&> 136) (&? 137) (&@ 138) (&^ 139) (&_ 140) (&~ 141) (*9 142) (*a 143) (*A 144) (*! 145) (*$ 146) (*% 147) (*& 148) (** 149) (*+ 150) (*- 151) (*. 152) (*/ 153) (*: 154) (*< 155) (*= 156) (*> 157) (*? 158) (*@ 159) (*^ 160) (*_ 161) (*~ 162) (/9 163) (/a 164) (/A 165) (/! 166) (/$ 167) (/% 168) (/& 169) (/* 170) (/+ 171) (/- 172) (/. 173) (// 174) (/: 175) (/< 176) (/= 177) (/> 178) (/? 179) (/@ 180) (/^ 181) (/_ 182) (/~ 183) (:9 184) (:a 185) (:A 186) (:! 187) (:$ 188) (:% 189) (:& 190) (:* 191) (:+ 192) (:- 193) (:. 194) (:/ 195) (:: 196) (:< 197) (:= 198) (:> 199) (:? 200) (:@ 201) (:^ 202) (:_ 203) (:~ 204) (<9 205) (<a 206) (<A 207) (<! 208) (<$ 209) (<% 210) (<& 211) (<* 212) (<+ 213) (<- 214) (<. 215) (</ 216) (<: 217) (<< 218) (<= 219) (<> 220) (<? 221) (<@ 222) (<^ 223) (<_ 224) (<~ 225) (=9 226) (=a 227) (=A 228) (=! 229) (=$ 230) (=% 231) (=& 232) (=* 233) (=+ 234) (=- 235) (=. 236) (=/ 237) (=: 238) (=< 239) (== 240) (=> 241) (=? 242) (=@ 243) (=^ 244) (=_ 245) (=~ 246) (>9 247) (>a 248) (>A 249) (>! 250) (>$ 251) (>% 252) (>& 253) (>* 254) (>+ 255) (>- 256) (>. 257) (>/ 258) (>: 259) (>< 260) (>= 261) (>> 262) (>? 263) (>@ 264) (>^ 265) (>_ 266) (>~ 267) (?9 268) (?a 269) (?A 270) (?! 271) (?$ 272) (?% 273) (?& 274) (?* 275) (?+ 276) (?- 277) (?. 278) (?/ 279) (?: 280) (?< 281) (?= 282) (?> 283) (?? 284) (?@ 285) (?^ 286) (?_ 287) (?~ 288) (^9 289) (^a 290) (^A 291) (^! 292) (^$ 293) (^% 294) (^& 295) (^* 296) (^+ 297) (^- 298) (^. 299) (^/ 300) (^: 301) (^< 302) (^= 303) (^> 304) (^? 305) (^@ 306) (^^ 307) (^_ 308) (^~ 309) (_9 310) (_a 311) (_A 312) (_! 313) (_$ 314) (_% 315) (_& 316) (_* 317) (_+ 318) (_- 319) (_. 320) (_/ 321) (_: 322) (_< 323) (_= 324) (_> 325) (_? 326) (_@ 327) (_^ 328) (__ 329) (_~ 330) (~9 331) (~a 332) (~A 333) (~! 334) (~$ 335) (~% 336) (~& 337) (~* 338) (~+ 339) (~- 340) (~. 341) (~/ 342) (~: 343) (~< 344) (~= 345) (~> 346) (~? 347) (~@ 348) (~^ 349) (~_ 350) (~~ 351) )+;  (+ a A ! $ % & * / : < = > ? ^ _ ~ a9 aa aA a! a$ a% a& a* a+ a- a. a/ a: a< a= a> a? a@ a^ a_ a~ A9 Aa AA A! A$ A% A& A* A+ A- A. A/ A: A< A= A> A? A@ A^ A_ A~ !9 !a !A !! !$ !% !& !* !+ !- !. !/ !: !< != !> !? !@ !^ !_ !~ $9 $a $A $! $$ $% $& $* $+ $- $. $/ $: $< $= $> $? $@ $^ $_ $~ %9 %a %A %! %$ %% %& %* %+ %- %. %/ %: %< %= %> %? %@ %^ %_ %~ &9 &a &A &! &$ &% && &* &+ &- &. &/ &: &< &= &> &? &@ &^ &_ &~ *9 *a *A *! *$ *% *& ** *+ *- *. */ *: *< *= *> *? *@ *^ *_ *~ /9 /a /A /! /$ /% /& /* /+ /- /. // /: /< /= /> /? /@ /^ /_ /~ :9 :a :A :! :$ :% :& :* :+ :- :. :/ :: :< := :> :? :@ :^ :_ :~ <9 <a <A <! <$ <% <& <* <+ <- <. </ <: << <= <> <? <@ <^ <_ <~ =9 =a =A =! =$ =% =& =* =+ =- =. =/ =: =< == => =? =@ =^ =_ =~ >9 >a >A >! >$ >% >& >* >+ >- >. >/ >: >< >= >> >? >@ >^ >_ >~ ?9 ?a ?A ?! ?$ ?% ?& ?* ?+ ?- ?. ?/ ?: ?< ?= ?> ?? ?@ ?^ ?_ ?~ ^9 ^a ^A ^! ^$ ^% ^& ^* ^+ ^- ^. ^/ ^: ^< ^= ^> ^? ^@ ^^ ^_ ^~ _9 _a _A _! _$ _% _& _* _+ _- _. _/ _: _< _= _> _? _@ _^ __ _~ ~9 ~a ~A ~! ~$ ~% ~& ~* ~+ ~- ~. ~/ ~: ~< ~= ~> ~? ~@ ~^ ~_ ~~ ))+;	  61776)++(test (let ()(+ (let ((x 0) (y 1) (z 2) )(+ x y (let ((x 3) )(+ x (let ()(+ (let ()+        (+ (let ((x 0) (y 1) (z 2) )(+ x y z (let ((x 3) )(+ x (let ((x 4) (y 5) (z 6) )+        (+ x y z (let ()(+ (let ((x 7) )(+ x (let ()(+ (let ((x 8) (y 9) )+        (+ x (let ((x 10) (y 11) (z 12) )(+ x  ))))))))))))))))))))))))))+      50)+(test  (let* ((x 0) (y x) )(+ x y (let ()(+ (let ((x 2) )(+ x (let ()(+ (let ((x 4) )+          (+ x (let ((x 5) )(+ x (let ((x 6) (y x) (z y) )(+ x (let ((x 7) (y x) )+          (+ x (let ((x 8) (y x) )(+ x y (let ((x 9) (y x) (z y) )(+ x ))))))))))))))))))))+       48)+(test (let* ((x 0) (y x) )(+ x y (let* ()(+ (let* ((x 2) )(+ x (let* ()(+ (let* ((x 4) )+        (+ x (let* ((x 5) )(+ x (let* ((x 6) (y x) (z y) )(+ x (let* ((x 7) (y x) )+        (+ x (let* ((x 8) (y x) )(+ x y (let* ((x 9) (y x) (z y) )(+ x ))))))))))))))))))))+      49)+++++;;; -------- call/cc --------+;;;+;;; some of these were originally from Al Petrovsky, Scott G Miller, Matthias Radestock, J H Brown, Dorai Sitaram,+;;;   and probably others.++;(let* ((next-leaf-generator (lambda (obj eot)+;			     (letrec ((return #f)+;				      (cont (lambda (x)+;					      (recur obj)+;					      (set! cont (lambda (x) (return eot)))+;					      (cont #f)))+;				      (recur (lambda (obj)+;					       (if (pair? obj)+;						   (for-each recur obj)+;						   (call-with-current-continuation+;						    (lambda (c)+;						      (set! cont c)+;						      (return obj)))))))+;			       (lambda () (call-with-current-continuation+;					   (lambda (ret) (set! return ret) (cont #f)))))))+;      (leaf-eq? (lambda (x y)+;		  (let* ((eot (list 'eot))+;			 (xf (next-leaf-generator x eot))+;			 (yf (next-leaf-generator y eot)))+;		    (letrec ((loop (lambda (x y)+;				     (cond ((not (eq? x y)) #f)+;					   ((eq? eot x) #t)+;					   (else (loop (xf) (yf)))))))+;		      (loop (xf) (yf)))))))+;+;  (test (leaf-eq? '(a (b (c))) '((a) b c)) #t)+;  (test (leaf-eq? '(a (b (c))) '((a) b c d)) #f))+;+;(test (let ((r #f)+;	    (a #f)+;	    (b #f)+;	    (c #f)+;	    (i 0))+;	(let ()+;	  (set! r (+ 1 (+ 2 (+ 3 (call/cc (lambda (k) (set! a k) 4))))+;		     (+ 5 (+ 6 (call/cc (lambda (k) (set! b k) 7))))))+;	  (if (not c)+;	      (set! c a))+;	  (set! i (+ i 1))+;	  (case i+;	    ((1) (a 5))+;	    ((2) (b 8))+;	    ((3) (a 6))+;	    ((4) (c 4)))+;	  r))+;      28)+;+;(test (let ((r #f)+;	    (a #f)+;	    (b #f)+;	    (c #f)+;	    (i 0))+;	(let ()+;	  (set! r (+ 1 (+ 2 (+ 3 (call/cc (lambda (k) (set! a k) 4))))+;		     (+ 5 (+ 6 (call/cc (lambda (k) (set! b k) 7))))))+;	  (if (not c)+;	      (set! c a))+;	  (set! i (+ i 1))+;	  (case i+;	    ((1) (b 8))+;	    ((2) (a 5))+;	    ((3) (b 7))+;	    ((4) (c 4)))+;	  r))+;      28)+;+; (test (let ((k1 #f)+;	     (k2 #f)+;	     (k3 #f)+;	     (state 0))+;	 (define (identity x) x)+;	 (define (fn)+;	   ((identity (if (= state 0)+;			  (call/cc (lambda (k) (set! k1 k) +))+;			  +))+;	    (identity (if (= state 0)+;			  (call/cc (lambda (k) (set! k2 k) 1))+;			  1))+;	    (identity (if (= state 0)+;			  (call/cc (lambda (k) (set! k3 k) 2))+;			  2))))+;	 (define (check states)+;	   (set! state 0)+;	   (let* ((res '())+;		  (r (fn)))+;	     (set! res (cons r res))+;	     (if (null? states)+;		 res+;		 (begin (set! state (car states))+;			(set! states (cdr states))+;			(case state+;			  ((1) (k3 4))+;			  ((2) (k2 2))+;			  ((3) (k1 -)))))))+;	 (map check '((1 2 3) (1 3 2) (2 1 3) (2 3 1) (3 1 2) (3 2 1))))+;       '((-1 4 5 3) (4 -1 5 3) (-1 5 4 3) (5 -1 4 3) (4 5 -1 3) (5 4 -1 3)))+;+;(test (let ((x '())+;	    (y 0))+;	(call/cc+;	 (lambda (escape)+;	   (let* ((yin ((lambda (foo)+;			  (set! x (cons y x))+;			  (if (= y 10)+;			      (escape x)+;			      (begin+;				(set! y 0)+;				foo)))+;			(call/cc (lambda (bar) bar))))+;		  (yang ((lambda (foo)+;			   (set! y (+ y 1))+;			   foo)+;			 (call/cc (lambda (baz) baz)))))+;	     (yin yang)))))+;      '(10 9 8 7 6 5 4 3 2 1 0))+;+;(test (let ((c #f))+;	(let ((r '()))+;	  (let ((w (let ((v 1))+;		     (set! v (+ (call-with-current-continuation+;				 (lambda (c0) (set! c c0) v))+;				v))+;		     (set! r (cons v r))+;		     v)))+;	    (if (<= w 1024) (c w) r))))+;      '(2048 1024 512 256 128 64 32 16 8 4 2))+;+;(test (let ((cc #f)+;	    (r '()))+;	(let ((s (list 1 2 3 4 (call/cc (lambda (c) (set! cc c) 5)) 6 7 8)))+;	  (if (null? r)+;	      (begin (set! r s) (cc -1))+;	      (list r s))))+;      '((1 2 3 4 5 6 7 8) (1 2 3 4 -1 6 7 8)))+;+;(test (call/cc (lambda (c) (0 (c 1)))) 1)+;(test (call/cc (lambda (k) (k "foo"))) "foo")+;(test (call/cc (lambda (k) "foo")) "foo")+;(test (call/cc (lambda (k) (k "foo") "oops")) "foo")+;+;(test (let ((listindex (lambda (e l)+;			 (call/cc (lambda (not_found)+;				    (letrec ((loop+;					      (lambda (l)+;						(cond+;						 ((null? l) (not_found #f))+;						 ((equal? e (car l)) 0)+;						 (else (+ 1 (loop (cdr l))))))))+;				      (loop l)))))))+;	(listindex 1 '(0 3 2 4 8)))+;      #f)+;+;(test (let ((product (lambda (li)+;		       (call/cc (lambda (break)+;				  (let loop ((l li))+;				    (cond+;				     ((null? l) 1)+;				     ((= (car l) 0) (break 0))+;				     (else (* (car l) (loop (cdr l)))))))))))+;	(product '(1 2 3 0 4 5 6)))+;      0)+;+;(test (let ((lst '()))+;	((call/cc+;	  (lambda (goto)+;	    (letrec ((start (lambda () (set! lst (cons "start" lst)) (goto next)))+;		     (next  (lambda () (set! lst (cons "next" lst))  (goto last)))+;		     (last  (lambda () (set! lst (cons "last" lst)) (reverse lst))))+;	      start)))))+;      '("start" "next" "last"))+;+;(test (let ((cont #f))+;	(letrec ((x (call-with-current-continuation (lambda (c) (set! cont c) 0)))+;		 (y (call-with-current-continuation (lambda (c) (set! cont c) 0))))+;	  (if cont+;	      (let ((c cont))+;		(set! cont #f)+;		(set! x 1)+;		(set! y 1)+;		(c 0))+;	      (+ x y))))+;      0)+;+;(test (letrec ((x (call/cc list))+;	       (y (call/cc list)))+;	(cond ((procedure? x) (x (pair? y)))+;	      ((procedure? y) (y (pair? x))))+;	(let ((x (car x)) (y (car y)))+;	  (and (call/cc x) (call/cc y) (call/cc x))))+;      #t)+;+;(test (letrec ((x (call-with-current-continuation+;		   (lambda (c)+;		     (list #t c)))))+;	(if (car x)+;	    ((cadr x) (list #f (lambda () x)))+;	    (eq? x ((cadr x)))))+;      #t)+;+;(test (call/cc (lambda (c) (0 (c 1)))) 1)+;+;(test (let ((member (lambda (x ls)+;		      (call/cc+;		       (lambda (break)+;			 (do ((ls ls (cdr ls)))+;			     ((null? ls) #f)+;			   (if (equal? x (car ls))+;			       (break ls))))))))+;	(list (member 'd '(a b c))+;	      (member 'b '(a b c))))+;      '(#f (b c)))+;+;(test (+ 2 (call/cc (lambda (k) (* 5 (k 4))))) 6)+;+;(test (let ((x (call/cc (lambda (k) k))))+;	(x (lambda (y) "hi")))+;      "hi")+;+;(test (((call/cc (lambda (k) k)) (lambda (x) x)) "hi") "hi")+;+;(test (let ((return #f)+;	    (lst '()))+;	(let ((val (+ 1 (call/cc+;			 (lambda (cont)+;			   (set! return cont)+;			   1)))))+;	  (set! lst (cons val lst)))+;	(if (= (length lst) 1)+;	    (return 10)+;	    (if (= (length lst) 2)+;		(return 20)))+;	(reverse lst))+;      '(2 11 21))+;+;(test (let ((r1 #f)+;	    (r2 #f)+;	    (lst '()))+;	(define (somefunc x y)+;	  (+ (* 2 (expt x 2)) (* 3 y) 1))+;	(let ((val (somefunc (call/cc+;			      (lambda (c1)+;				(set! r1 c1)+;				(c1 1)))+;			     (call/cc+;			      (lambda (c2)+;				(set! r2 c2)+;				(c2 1))))))+;	  (set! lst (cons val lst)))+;	(if (= (length lst) 1)+;	    (r1 2)+;	    (if (= (length lst) 2)+;		(r2 3)))+;	(reverse lst))+;      '(6 12 18))+;+;(let ((tree->generator+;       (lambda (tree)+;	 (let ((caller '*))+;	   (letrec+;	       ((generate-leaves+;		 (lambda ()+;		   (let loop ((tree tree))+;		     (cond ((null? tree) 'skip)+;			   ((pair? tree)+;			    (loop (car tree))+;			    (loop (cdr tree)))+;			   (else+;			    (call/cc+;			     (lambda (rest-of-tree)+;			       (set! generate-leaves+;				     (lambda ()+;				       (rest-of-tree 'resume)))+;			       (caller tree))))))+;		   (caller '()))))+;	     (lambda ()+;	       (call/cc+;		(lambda (k)+;		  (set! caller k)+;		  (generate-leaves)))))))))+;  (let ((same-fringe?+;	 (lambda (tree1 tree2)+;	   (let ((gen1 (tree->generator tree1))+;		 (gen2 (tree->generator tree2)))+;	     (let loop ()+;	       (let ((leaf1 (gen1))+;		     (leaf2 (gen2)))+;		 (if (eqv? leaf1 leaf2)+;		     (if (null? leaf1) #t (loop))+;		     #f)))))))+;+;    (test (same-fringe? '(1 (2 3)) '((1 2) 3)) #t)+;    (test (same-fringe? '(1 2 3) '(1 (3 2))) #f)))+;+;+;(for-each+; (lambda (arg)+;   (test (let ((ctr 0))+;	   (let ((val (call/cc (lambda (exit)+;				 (do ((i 0 (+ i 1)))+;				     ((= i 10) 'gad)+;				   (set! ctr (+ ctr 1))+;				   (if (= i 1)+;				       (exit arg)))))))+;	     (and (equal? val arg)+;		  (= ctr 2))))+;	 #t))+; (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))+;+;(for-each+; (lambda (arg)+;   (test (let ((ctr 0))+;	   (let ((val (call/cc (lambda (exit)+;				 (do ((i 0 (+ i 1)))+;				     ((= i 10) arg)+;				   (set! ctr (+ ctr 1))+;				   (if (= i 11)+;				       (exit 'gad)))))))+;	     (and (equal? val arg)+;		  (= ctr 10))))+;	 #t))+; (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))+;+;(test (let ((c #f)+;	    (r (string-copy "testing-hiho")))+;	(let ((v (call/cc (lambda (c0) (set! c c0) (list #\a 0)))))+;	  (let ((chr (car v))+;		(index (cadr v)))+;	    (string-set! r index chr)+;	    (set! index (+ index 1))+;	    (if (<= index 8)+;		(c (list (integer->char (+ 1 (char->integer chr))) index))+;		r))))+;      "abcdefghiiho")+;+;(test (let ((x 0)+;	    (again #f))+;	(call/cc (lambda (r) (set! again r)))+;	(set! x (+ x 1))+;	(if (< x 3) (again))+;	x)+;      3)+;+;(test (let* ((x 0)+;	     (again #f)+;	     (func (lambda (r) (set! again r))))+;	(call/cc func)+;	(set! x (+ x 1))+;	(if (< x 3) (again))+;	x)+;      3)+;+;(test (let* ((x 0)+;	     (again #f))+;	(call/cc (let ()+;		   (lambda (r) (set! again r))))+;	(set! x (+ x 1))+;	(if (< x 3) (again))+;	x)+;      3)+;+;(test (call/cc procedure?) #t)+;(test (procedure? (call/cc (lambda (a) a))) #t)+;+;(for-each+; (lambda (arg)+;   (test (call/cc (lambda (a) arg)) arg))+; (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))+;+;(let ((a (call/cc (lambda (a) a))))+;  (test (eq? a a) #t)+;  (test (eqv? a a) #t)+;  (test (equal? a a) #t)+;  (for-each+;   (lambda (ques)+;     (if (ques a)+;	 (begin (display ques) (display " ") (display a) (display " returned #t?") (newline))))+;   question-ops))+;+;(test (let ((conts (make-vector 4 #f)))+;	(let ((lst '()))+;	  (set! lst (cons (+ (call/cc (lambda (a) (vector-set! conts 0 a) 0))+;			     (call/cc (lambda (a) (vector-set! conts 1 a) 0))+;			     (call/cc (lambda (a) (vector-set! conts 2 a) 0))+;			     (call/cc (lambda (a) (vector-set! conts 3 a) 0)))+;			  lst))+;	  (let ((len (length lst)))+;	    (if (< len 4)+;		((vector-ref conts (- len 1)) (+ len 1))+;		(reverse lst)))))+;      '(0 2 5 9))+;+;(test (let ((conts '()))+;	(let ((lst '()))+;	  (set! lst (cons (+ (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) 1))+;			     (* (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) 1))+;				(+ (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) 1))+;				   (* (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) 1)) 2))))+;			  lst))+;	  (let ((len (length lst)))+;	    (if (<= len 4)+;		((list-ref conts (- len 1)) (+ len 1))+;		(reverse lst)))))+;      ; (+ 1 (* 1 (+ 1 (* 1 2)))) to start+;      ; (+ 1 ...          2     )+;      ; (+ 1 ...     3    [1]   )+;      ; (+ 1 ...4    [1]        )+;      ; (+ 5   [1]              )+;      '(4 6 6 13 8))+;+;(test (let ((conts (make-vector 4 #f)))+;	(let ((lst '()))+;	  (set! lst (cons (+ (call/cc (lambda (a) (if (not (vector-ref conts 0)) (vector-set! conts 0 a)) 0))+;			     (call/cc (lambda (a) (if (not (vector-ref conts 1)) (vector-set! conts 1 a)) 0))+;			     (call/cc (lambda (a) (if (not (vector-ref conts 2)) (vector-set! conts 2 a)) 0))+;			     (call/cc (lambda (a) (if (not (vector-ref conts 3)) (vector-set! conts 3 a)) 0)))+;			  lst))+;	  (let ((len (length lst)))+;	    (if (< len 4)+;		((vector-ref conts (- len 1)) (+ len 1))+;		(reverse lst)))))+;      '(0 2 3 4))+;+;(test (let ((conts '()))+;	(let ((lst '()))+;	  (set! lst (cons (+ (if (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) #f)) 1 0)+;			     (* (if (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) #f)) 2 1)+;				(+ (if (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) #f)) 1 0)+;				   (* (if (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) #f)) 2 1) 2))))+;			  lst))+;	  (let ((len (length lst)))+;	    (if (<= len 4)+;		((list-ref conts (- len 1)) #t)+;		(reverse lst)))))+;      ; (+ 0 (* 1 (+ 0 (* 1 2)))) to start+;      ; (+ 0 ...          2     )+;      ; (+ 0 ...     1   [1]    )+;      ; (+ 0 ...2   [0]         )+;      ; (+ 1   [1]              )+;      '(2 4 3 4 3))+;+;(test (let ((call/cc 2)) (+ call/cc 1)) 3)+;+;+;(let ((r5rs-ratify (lambda (ux err)+;		     (if (= ux 0.0)+;			 0+;			 (let ((tt 1)+;			       (a1 0)+;			       (b2 0)+;			       (a2 1)+;			       (b1 1)+;			       (a 0)+;			       (b 0)+;			       (ctr 0)+;			       (x (/ 1 ux)))+;			   (call-with-current-continuation+;			    (lambda (return)+;			      (do ()+;				  (#f)+;				(set! a (+ (* a1 tt) a2))+;				(set! b (+ (* tt b1) b2))+;					;(display (format #f "~A ~A~%" a (- b a)))+;				(if (or (<= (abs (- ux (/ a b))) err)+;					(> ctr 1000))+;				    (return (/ a b)))+;				(set! ctr (+ 1 ctr))+;				(if (= x tt) (return))+;				(set! x (/ 1 (- x tt)))+;				(set! tt (inexact->exact (floor x)))+;				(set! a2 a1)+;				(set! b2 b1)+;				(set! a1 a)+;				(set! b1 b)))))))))+;+;  (test (r5rs-ratify (/ (log 2.0) (log 3.0)) 1/10000000) 665/1054)+;  (if (positive? 2147483648)+;      (test (r5rs-ratify (/ (log 2.0) (log 3.0)) 1/100000000000) 190537/301994)))+;+;(for-each+; (lambda (arg)+;   (test (let ((ctr 0))+;	   (let ((val (call/cc+;		       (lambda (exit)+;			 (for-each (lambda (a)+;				     (if (equal? a arg) (exit arg))+;				     (set! ctr (+ ctr 1)))+;				   (list 0 1 2 3 arg 5))))))+;	     (list ctr val)))+;	 (list 4 arg)))+; (list "hi" -1 #\a 11 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t '(1 . 2)))+;+;(test (+ 2 (call/cc (lambda (rtn) (+ 1 (let () (begin (define x (+ 1 (rtn 3)))) x))))) 5)+;+;+;+;+;;;; -------- dynamic-wind --------+;+;(test (let ((ctr1 0)+;	    (ctr2 0)+;	    (ctr3 0))+;	(let ((ctr4 (dynamic-wind+;			(lambda () (set! ctr1 (+ ctr1 1)))+;			(lambda () (set! ctr2 (+ ctr2 1)) ctr2)+;			(lambda () (set! ctr3 (+ ctr3 1))))))+;	  (= ctr1 ctr2 ctr3 ctr4 1)))+;      #t)+;+;(test (let ((ctr1 0)+;	    (ctr2 0)+;	    (ctr3 0))+;	(let ((ctr4 (call/cc (lambda (exit)+;			       (dynamic-wind+;				   (lambda () (set! ctr1 (+ ctr1 1)))+;				   (lambda () (exit ctr2) (set! ctr2 (+ ctr2 1)) ctr2)+;				   (lambda () (set! ctr3 (+ ctr3 1)) 123))))))+;	  (and (= ctr1 ctr3 1)+;	       (= ctr2 ctr4 0))))+;      #t)+;+;(test (let ((ctr1 0)+;	    (ctr2 0)+;	    (ctr3 0))+;	(let ((ctr4 (call/cc (lambda (exit)+;			       (dynamic-wind+;				   (lambda () (exit ctr1) (set! ctr1 (+ ctr1 1)))+;				   (lambda () (set! ctr2 (+ ctr2 1)) ctr2)+;				   (lambda () (set! ctr3 (+ ctr3 1))))))))+;	  (= ctr1 ctr2 ctr3 ctr4 0)))+;      #t)+;+;(test (let ((ctr1 0)+;	    (ctr2 0)+;	    (ctr3 0))+;	(let ((ctr4 (call/cc (lambda (exit)+;			       (dynamic-wind+;				   (lambda () (set! ctr1 (+ ctr1 1)))+;				   (lambda () (set! ctr2 (+ ctr2 1)) ctr2)+;				   (lambda () (exit ctr3) (set! ctr3 (+ ctr3 1))))))))+;	  (and (= ctr1 ctr2 1)+;	       (= ctr3 ctr4 0))))+;      #t)+;+;(test (let ((path '())+;	    (c #f))+;	(let ((add (lambda (s)+;		     (set! path (cons s path)))))+;	  (dynamic-wind+;	      (lambda () (add 'connect))+;	      (lambda () (add (call-with-current-continuation+;			       (lambda (c0) (set! c c0) 'talk1))))+;	      (lambda () (add 'disconnect)))+;	  (if (< (length path) 4)+;	      (c 'talk2)+;	      (reverse path))))+;      '(connect talk1 disconnect  connect talk2 disconnect))+;+;+;(for-each+; (lambda (arg)+;   (test (dynamic-wind (lambda () #f) (lambda () arg) (lambda () #f)) arg))+; (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))+;+;(test (dynamic-wind (lambda () #f) (lambda () #f) (lambda () #f)) #f)+;+;(test (let ((identity (lambda (a) a)))+;        (let ((x '())+;              (c #f))+;          (dynamic-wind+;	      (lambda () (set! x (cons 'a x)))+;	      (lambda ()+;		(dynamic-wind+;		    (lambda () (set! x (cons 'b x)))+;		    (lambda ()+;		      (dynamic-wind+;			  (lambda () (set! x (cons 'c x)))+;			  (lambda () (set! c (call/cc identity)))+;			  (lambda () (set! x (cons 'd x)))))+;		    (lambda () (set! x (cons 'e x))))+;		(dynamic-wind+;		    (lambda () (set! x (cons 'f x)))+;		    (lambda () (if c (c #f)))+;		    (lambda () (set! x (cons 'g x)))))+;	      (lambda () (set! x (cons 'h x))))+;          (reverse x)))+;      '(a b c d e f g b c d e f g h))+;+;(test (dynamic-wind+;	  (lambda () #f)+;	  (lambda () (values 'a 'b 'c))+;	  (lambda () #f))+;      (values 'a 'b 'c))+;+;(test (let ((dynamic-wind 1)) (+ dynamic-wind 2)) 3)+;+;(test (let ((ctr1 0)+;	    (ctr2 0)+;	    (ctr3 0))+;	(let ((val (dynamic-wind+;		       (lambda () #f)+;		       (lambda ()+;			 (set! ctr1 1)+;			 (call/cc+;			  (lambda (exit)+;			    (exit 123)+;			    (set! ctr2 2)+;			    321)))+;		       (lambda ()+;			 (set! ctr3 3)))))+;	  (and (= ctr1 1) (= ctr2 0) (= ctr3 3) (= val 123))))+;      #t)+;+;(test (let ((ctr1 0))+;	(let ((val (dynamic-wind+;		       (let ((a 1))+;			 (lambda ()+;			   (set! ctr1 a)))+;		       (let ((a 10))+;			 (lambda ()+;			   (set! ctr1 (+ ctr1 a))+;			   ctr1))+;		       (let ((a 100))+;			 (lambda ()+;			   (set! ctr1 (+ ctr1 a)))))))+;	  (and (= ctr1 111) (= val 11))))+;      #t)+;+;(test (let ((ctr1 0))+;	(let ((val (+ 3 (dynamic-wind+;			    (let ((a 1))+;			      (lambda ()+;				(set! ctr1 a)))+;			    (let ((a 10))+;			      (lambda ()+;				(set! ctr1 (+ ctr1 a))+;				ctr1))+;			    (let ((a 100))+;			      (lambda ()+;				(set! ctr1 (+ ctr1 a)))))+;		      1000)))+;	  (and (= ctr1 111) (= val 1014))))+;      #t)+;+;(test (let ((n 0))+;	(call-with-current-continuation+;	 (lambda (k)+;	   (dynamic-wind+;	       (lambda ()+;		 (set! n (+ n 1))+;		 (k))+;	       (lambda ()+;		 (set! n (+ n 2)))+;	       (lambda ()+;		 (set! n (+ n 4))))))+;	n)+;      1)+;+;(test (let ((n 0))+;	(call-with-current-continuation+;	 (lambda (k)+;	   (dynamic-wind+;	       (lambda () #f)+;	       (lambda ()+;		 (dynamic-wind+;		     (lambda () #f)+;		     (lambda ()+;		       (set! n (+ n 1))+;		       (k))+;		     (lambda ()+;		       (set! n (+ n 2))+;		       ;(k)+;		       )))+;	       (lambda ()+;		 (set! n (+ n 4))))))+;	n)+;      7)+;+;(test (let ((n 0))+;	(call-with-current-continuation+;	 (lambda (k)+;	   (dynamic-wind+;	       (lambda () #f)+;	       (lambda ()+;		 (dynamic-wind+;		     (lambda () #f)+;		     (lambda ()+;		       (dynamic-wind+;			   (lambda () #f)+;			   (lambda ()+;			     (set! n (+ n 1))+;			     (k))+;			   (lambda ()+;			     (if (= n 1)+;				 (set! n (+ n 2))))))+;		     (lambda ()+;		       (if (= n 3)+;			   (set! n (+ n 4))))))+;	       (lambda ()+;		 (if (= n 7)+;		     (set! n (+ n 8)))))))+;	n)+;      15)++++;;; -------- delay and force --------++(if with-delay+    (begin++      (test (let ((stream-car (lambda (s) (car (force s))))+		  (stream-cdr (lambda (s) (cdr (force s))))+		  (counters (let next ((n 1)) (delay (cons n (next (+ n 1)))))))+	      (let* ((val1 (stream-car counters))+		     (val2 (stream-car (stream-cdr counters))))+		(letrec ((stream-add (lambda (s1 s2)+				       (delay (cons+					       (+ (stream-car s1) (stream-car s2))+					       (stream-add (stream-cdr s1) (stream-cdr s2)))))))+		  (let ((even-counters (stream-add counters counters)))+		    (let* ((val3 (stream-car even-counters))+			   (val4 (stream-car (stream-cdr even-counters))))+		      (list val1 val2 val3 val4))))))+	    (list 1 2 2 4))++      (test (force (delay (+ 1 2))) 3)+      (test (let ((p (delay (+ 1 2)))) (list (force p) (force p))) (list 3 3))+      (test (letrec ((a-stream (letrec ((next (lambda (n)+						(cons n (delay (next (+ n 1)))))))+				 (next 0)))+		     (head car)+		     (tail (lambda (stream) (force (cdr stream)))))+	      (head (tail (tail a-stream))))+	    2)++      (letrec ((count 0)+	       (p (delay (begin (set! count (+ count 1))+				(if (> count x)+				    count+				    (force p)))))+	       (x 5))+	(test (force p) 6)+	(set! x 10)+	(test (force p) 6))++;      (test (let ((generate (lambda (use-it)+;                              (let loop ((i 0))+;                                (if (< i 10) (begin (use-it i) (loop (+ i 1)))))))+;                  (generator->lazy-list (lambda (generator)+;                                          (delay+;                                            (call/cc (lambda (k-main)+;                                                       (generator+;                                                        (lambda (e)+;                                                          (call/cc (lambda (k-reenter)+;                                                                     (k-main (cons e+;                                                                                   (delay+;                                                                                     (call/cc (lambda (k-new-main)+;                                                                                                (set! k-main k-new-main)+;                                                                                                (k-reenter #f))))))))))+;                                                       (k-main '()))))))+;                  (fnull? (lambda (x) (null? (force x))))+;                  (fcar (lambda (x) (car (force x))))+;                  (fcdr (lambda (x) (cdr (force x)))))+;              (letrec ((lazy-list->list (lambda (lz)+;                                          (if (fnull? lz) '()+;                                              (cons (fcar lz) (lazy-list->list (fcdr lz)))))))+;                (lazy-list->list (generator->lazy-list generate))))+;            '(0 1 2 3 4 5 6 7 8 9))++      (test (let* ((x 1)+		   (p (delay (+ x 1))))+	      (force p)+	      (set! x (+ x 1))+	      (force p))+	    2)++      (test (let* ((x 1)+		   (p #f))+	      (let* ((x 2))+		(set! p (delay (+ x 1))))+	      (force p))+	    3)++      (test (letrec ((count 0)+		     (x 5)+		     (p (delay (begin (set! count (+ count 1))+				      (if (> count x)+					  count+					  (force p))))))+	      (force p)+	      (set! x 10)+	      (force p))+	    6)++      (test (let ((count 0))+	      (define s (delay (begin (set! count (+ count 1)) 1)))+	      (+ (force s) (force s))+	      count)+	    1)++      (test (let ()+	      (define f+		(let ((first? #t))+		  (delay+		    (if first?+			(begin+			  (set! first? #f)+			  (force f))+			'second))))+	      (force f))+	    'second)++      (test (let ()+	      (define q+		(let ((count 5))+		  (define (get-count) count)+		  (define p (delay (if (<= count 0)+				       count+				       (begin (set! count (- count 1))+					      (force p)+					      (set! count (+ count 2))+					      count))))+		  (list get-count p)))+	      (let* ((get-count (car q))+		     (p (cadr q))+		     (a (get-count))+		     (b (force p))+		     (c (get-count)))+		(list a b c)))+	    (list 5 0 10))++      (for-each+       (lambda (arg)+	 (test (force (delay arg)) arg))+       (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++      ))+++;;; -------- quasiquote --------++(test `(1 2 3) '(1 2 3))+(test `() '())+(test `(list ,(+ 1 2) 4)  '(list 3 4))+(test `(1 ,@(list 1 2) 4) '(1 1 2 4))+(test `#(1 ,@(list 1 2) 4) '#(1 1 2 4))+(test `(a ,(+ 1 2) ,@(map abs '(4 -5 6)) b) '(a 3 4 5 6 b))+(if (eqv? 2 (sqrt 4))+    (test `#(10 5 ,(sqrt 4) ,@(map sqrt '(16 9)) 8) '#(10 5 2 4 3 8))) ; inexactness foolishness+(test `(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f) '(a `(b ,(+ 1 2) ,(foo 4 d) e) f))+(test (let ((name1 'x) (name2 'y)) `(a `(b ,,name1 ,',name2 d) e)) '(a `(b ,x ,'y d) e))+(test `(,@'() . foo) 'foo)+(test `(1 2 ,(* 9 9) 3 4) '(1 2 81 3 4))+(test `(1 ,(+ 1 1) 3) '(1 2 3))+;#; `(,(+ 1 2)) -> infinite loop?+(test `(,'a . ,'b) (cons 'a 'b))++;; from gauche+(let ((quasi0 99)+      (quasi1 101)+      (quasi2 '(a b))+      (quasi3 '(c d)))+  (test `,quasi0 99)+  (test `,quasi1 101)+  (test `(,(cons 1 2)) '((1 . 2)))+  (test `(,(cons 1 2) 3) '((1 . 2) 3))+  (test `(,quasi0 3) '(99 3))+  (test `(3 ,quasi0) '(3 99))+  (test `(,(+ quasi0 1) 3) '(100 3))+  (test `(3 ,(+ quasi0 1)) '(3 100))+  (test `(,quasi1 3) '(101 3))+  (test `(3 ,quasi1) '(3 101))+  (test `(,(+ quasi1 1) 3) '(102 3))+  (test `(3 ,(+ quasi1 1)) '(3 102))+  (test `(1 ,@(list 2 3) 4) '(1 2 3 4))+  (test `(1 2 ,@(list 3 4)) '(1 2 3 4))+  (test `(,@quasi2 ,@quasi3) '(a b c d))+  (test `(1 2 . ,(list 3 4)) '(1 2 3 4))+  (test `(,@quasi2 . ,quasi3) '(a b c d))+  (test `#(,(cons 1 2) 3) '#((1 . 2) 3))+  (test `#(,quasi0 3) '#(99 3))+  (test `#(,(+ quasi0 1) 3) '#(100 3))+  (test `#(3 ,quasi1) '#(3 101))+  (test `#(3 ,(+ quasi1 1)) '#(3 102))+  (test `#(1 ,@(list 2 3) 4) '#(1 2 3 4))+  (test `#(1 2 ,@(list 3 4)) '#(1 2 3 4))+  (test `#(,@quasi2 ,@quasi3) '#(a b c d))+  (test `#(,@quasi2 ,quasi3) '#(a b (c d)))+  (test `#(,quasi2  ,@quasi3) '#((a b) c d))+  (test `#() '#())+  (test `#(,@(list)) '#())+  (test `(,@(list 1 2) ,@(list 1 2)) '(1 2 1 2))+  (test `(,@(list 1 2) a ,@(list 1 2)) '(1 2 a 1 2))+  (test `(a ,@(list 1 2) ,@(list 1 2)) '(a 1 2 1 2))+  (test `(,@(list 1 2) ,@(list 1 2) a) '(1 2 1 2 a))+  (test `(,@(list 1 2) ,@(list 1 2) a b) '(1 2 1 2 a b))+  (test `(,@(list 1 2) ,@(list 1 2) . a) '(1 2 1 2 . a))+  (test `(,@(list 1 2) ,@(list 1 2) . ,(cons 1 2)) '(1 2 1 2 1 . 2))+  (test `(,@(list 1 2) ,@(list 1 2) . ,quasi2) '(1 2 1 2 a b))+  (test `(,@(list 1 2) ,@(list 1 2) a . ,(cons 1 2)) '(1 2 1 2 a 1 . 2))+  (test `(,@(list 1 2) ,@(list 1 2) a . ,quasi3) '(1 2 1 2 a c d))+  (test `#(,@(list 1 2) ,@(list 1 2)) '#(1 2 1 2))+  (test `#(,@(list 1 2) a ,@(list 1 2)) '#(1 2 a 1 2))+  (test `#(a ,@(list 1 2) ,@(list 1 2)) '#(a 1 2 1 2))+  (test `#(,@(list 1 2) ,@(list 1 2) a) '#(1 2 1 2 a))+  (test `#(,@(list 1 2) ,@(list 1 2) a b) '#(1 2 1 2 a b))+  (test `(1 `(1 ,2 ,,(+ 1 2)) 1) '(1 `(1 ,2 ,3) 1))+  (test `(1 `(1 ,,quasi0 ,,quasi1) 1) '(1 `(1 ,99 ,101) 1))+  (test `(1 `(1 ,@2 ,@,(list 1 2))) '(1 `(1 ,@2 ,@(1 2))))+  (test `(1 `(1 ,@,quasi2 ,@,quasi3)) '(1 `(1 ,@(a b) ,@(c d))))+  (test `(1 `(1 ,(,@quasi2 x) ,(y ,@quasi3))) '(1 `(1 ,(a b x) ,(y c d))))+  (test `#(1 `(1 ,2 ,,(+ 1 2)) 1) '#(1 `(1 ,2 ,3) 1))+  (test `#(1 `(1 ,,quasi0 ,,quasi1) 1) '#(1 `(1 ,99 ,101) 1))+  (test `#(1 `(1 ,@2 ,@,(list 1 2))) '#(1 `(1 ,@2 ,@(1 2))))+  (test `#(1 `(1 ,@,quasi2 ,@,quasi3)) '#(1 `(1 ,@(a b) ,@(c d))))+  (test `#(1 `(1 ,(,@quasi2 x) ,(y ,@quasi3))) '#(1 `(1 ,(a b x) ,(y c d))))+  (test `(1 `#(1 ,(,@quasi2 x) ,(y ,@quasi3))) '(1 `#(1 ,(a b x) ,(y c d)))))++(test (let ((hi (lambda (a) `(+ 1 ,a))))+	(hi 2))+      '(+ 1 2))++(test (let ((hi (lambda (a) `(+ 1 ,@a))))+	(hi (list 2 3)))+      '(+ 1 2 3))++(test (let ((hi (lambda (a) `(let ((b ,a)) ,(+ 1 a)))))+	(hi 3))+      '(let ((b 3)) 4))++(test (let ((x '(a b c)))+	`(x ,x ,@x foo ,(cadr x) bar ,(cdr x) baz ,@(cdr x)))+      '(x (a b c) a b c foo b bar (b c) baz b c))++(test (let ((x '(a b c)))+	`(,(car `(,x))))+      '((a b c)))++(test (let ((x '(a b c)))+	`(,@(car `(,x))))+      '(a b c))++(test (let ((x '(a b c)))+	`(,(car `(,@x))))+      '(a))++(test (let ((x '(a b c)))+	(cadadr ``,,x))+      '(a b c))++(test (let ((x '(a b c)))+	`,(car `,x))+      'a)++(test (let ((x '(2 3)))+	`(1 ,@x 4))+      '(1 2 3 4))++(test (let ((x '(2 3)))+	`#(9 ,@x 9))+      '#(9 2 3 9))++(test `#(1 ,(/ 12 2)) '#(1 6))+(test ((lambda () `#(1 ,(/ 12 2)))) '#(1 6))++(test (let ((x '(2 3)))+	`(1 ,@(map (lambda (a) (+ a 1)) x)))+      '(1 3 4))++;;; these are from the scheme bboard+(test (let ((x '(1 2 3))) `(0 . ,x)) '(0 1 2 3))+(test (let ((x '(1 2 3))) `(0 ,x)) '(0 (1 2 3)))+(test (let ((x '(1 2 3))) `#(0 ,x)) '#(0 (1 2 3)))+;(test (let ((x '(1 2 3))) `#(0 . ,x)) '#(0 1 2 3))+++++;;; -------- syntax-rules --------++(if with-syntax-rules+    (begin++      (test (let-syntax ((foo+			  (syntax-rules ()+			    ((_ expr) (+ expr 1)))))+	      (let ((+ *))+		(foo 3)))+	    4)++      (test (let-syntax ((foo (syntax-rules ()+				((_ var) (define var 1)))))+	      (let ((x 2))+		(begin (define foo +))+		(cond (else (foo x)))+		x))+	    2)++      (test (let ((x 1))+	      (let-syntax+		  ((foo (syntax-rules ()+			  ((_ y) (let-syntax+				     ((bar (syntax-rules ()+					     ((_) (let ((x 2)) y)))))+				   (bar))))))+		(foo x)))+	    1)+      ))++;;; --------------------------------------------------------------------------------+;;; NUMBERS+;;; --------------------------------------------------------------------------------+++;; -------- sin+(num-test (sin 0) 0.0)+(num-test (sin 1) 0.84147098480790)+(num-test (sin -1) -0.84147098480790)+(num-test (sin 2) 0.90929742682568)+(num-test (sin -2) -0.90929742682568)+(num-test (sin 0/1) 0.0)+(num-test (sin 0/2) 0.0)+(num-test (sin 0/3) 0.0)+(num-test (sin 0/10) 0.0)+(num-test (sin 0/1234) 0.0)+(num-test (sin 0/1234000000) 0.0)+(num-test (sin 0/500029) 0.0)+(num-test (sin 0/362880) 0.0)+(num-test (sin 1/1) 0.84147098480790)+(num-test (sin -1/1) -0.84147098480790)+(num-test (sin 1/2) 0.47942553860420)+(num-test (sin -1/2) -0.47942553860420)+(num-test (sin 1/3) 0.32719469679615)+(num-test (sin -1/3) -0.32719469679615)+(num-test (sin 1/10) 0.09983341664683)+(num-test (sin -1/10) -0.09983341664683)+(num-test (sin 1/1234) 0.00081037268278)+(num-test (sin -1/1234) -0.00081037268278)+(num-test (sin 1/1234000000) 0.00000000081037)+(num-test (sin -1/1234000000) -0.00000000081037)+(num-test (sin 1/500029) 0.00000199988401)+(num-test (sin -1/500029) -0.00000199988401)+(num-test (sin 1/362880) 0.00000275573192)+(num-test (sin -1/362880) -0.00000275573192)+(num-test (sin 2/1) 0.90929742682568)+(num-test (sin -2/1) -0.90929742682568)+(num-test (sin 2/2) 0.84147098480790)+(num-test (sin -2/2) -0.84147098480790)+(num-test (sin 2/3) 0.61836980306974)+(num-test (sin -2/3) -0.61836980306974)+(num-test (sin 2/10) 0.19866933079506)+(num-test (sin -2/10) -0.19866933079506)+(num-test (sin 2/1234) 0.00162074483338)+(num-test (sin -2/1234) -0.00162074483338)+(num-test (sin 2/1234000000) 0.00000000162075)+(num-test (sin -2/1234000000) -0.00000000162075)+(num-test (sin 2/500029) 0.00000399976801)+(num-test (sin -2/500029) -0.00000399976801)+(num-test (sin 2/362880) 0.00000551146384)+(num-test (sin -2/362880) -0.00000551146384)+(num-test (sin 3/2) 0.99749498660405)+(num-test (sin -3/2) -0.99749498660405)+(num-test (sin 3/3) 0.84147098480790)+(num-test (sin -3/3) -0.84147098480790)+(num-test (sin 3/10) 0.29552020666134)+(num-test (sin -3/10) -0.29552020666134)+(num-test (sin 3/1234) 0.00243111591964)+(num-test (sin -3/1234) -0.00243111591964)+(num-test (sin 3/1234000000) 0.00000000243112)+(num-test (sin -3/1234000000) -0.00000000243112)+(num-test (sin 3/500029) 0.00000599965202)+(num-test (sin -3/500029) -0.00000599965202)+(num-test (sin 3/362880) 0.00000826719577)+(num-test (sin -3/362880) -0.00000826719577)+(num-test (sin 10/10) 0.84147098480790)+(num-test (sin -10/10) -0.84147098480790)+(num-test (sin 10/1234) 0.00810363901920)+(num-test (sin -10/1234) -0.00810363901920)+(num-test (sin 10/1234000000) 0.00000000810373)+(num-test (sin -10/1234000000) -0.00000000810373)+(num-test (sin 10/500029) 0.00001999884007)+(num-test (sin -10/500029) -0.00001999884007)+(num-test (sin 10/362880) 0.00002755731922)+(num-test (sin -10/362880) -0.00002755731922)+(num-test (sin 1234/1234) 0.84147098480790)+(num-test (sin -1234/1234) -0.84147098480790)+(num-test (sin 1234/1234000000) 0.00000100000000)+(num-test (sin -1234/1234000000) -0.00000100000000)+(num-test (sin 1234/500029) 0.00246785435930)+(num-test (sin -1234/500029) -0.00246785435930)+(num-test (sin 1234/362880) 0.00340056663826)+(num-test (sin -1234/362880) -0.00340056663826)+(num-test (sin 1234000000/1234000000) 0.84147098480790)+(num-test (sin -1234000000/1234000000) -0.84147098480790)+(num-test (sin 500029/1234000000) 0.00040520987546)+(num-test (sin -500029/1234000000) -0.00040520987546)+(num-test (sin 500029/500029) 0.84147098480790)+(num-test (sin -500029/500029) -0.84147098480790)+(num-test (sin 500029/362880) 0.98146191370834)+(num-test (sin -500029/362880) -0.98146191370834)+(num-test (sin 362880/1234000000) 0.00029406806707)+(num-test (sin -362880/1234000000) -0.00029406806707)+(num-test (sin 362880/500029) 0.66367262572318)+(num-test (sin -362880/500029) -0.66367262572318)+(num-test (sin 362880/362880) 0.84147098480790)+(num-test (sin -362880/362880) -0.84147098480790)+(num-test (sin 0.0) 0.0)+(num-test (sin 0.00000001) 0.00000001)+(num-test (sin -0.00000001) -0.00000001)+(num-test (sin 1.0) 0.84147098480790)+(num-test (sin -1.0) -0.84147098480790)+(num-test (sin 0.0+0.0i) 0.0)+(num-test (sin -0.0+0.0i) 0.0)+(num-test (sin 0.0-0.0i) 0.0)+(num-test (sin -0.0-0.0i) -0.0)+(num-test (sin 0.0+0.00000001i) 0.0+0.00000001i)+(num-test (sin -0.0+0.00000001i) 0.0+0.00000001i)+(num-test (sin 0.0-0.00000001i) 0.0-0.00000001i)+(num-test (sin -0.0-0.00000001i) -0.0-0.00000001i)+(num-test (sin 0.0+1.0i) 0.0+1.17520119364380i)+(num-test (sin -0.0+1.0i) 0.0+1.17520119364380i)+(num-test (sin 0.0-1.0i) 0.0-1.17520119364380i)+(num-test (sin -0.0-1.0i) -0.0-1.17520119364380i)+(num-test (sin 0.0+3.14159265358979i) 0.0+11.54873935725775i)+(num-test (sin -0.0+3.14159265358979i) 0.0+11.54873935725775i)+(num-test (sin 0.0-3.14159265358979i) 0.0-11.54873935725775i)+(num-test (sin -0.0-3.14159265358979i) -0.0-11.54873935725775i)+(num-test (sin 0.0+2.71828182845905i) 0.0+7.54413710281697i)+(num-test (sin -0.0+2.71828182845905i) 0.0+7.54413710281697i)+(num-test (sin 0.0-2.71828182845905i) 0.0-7.54413710281697i)+(num-test (sin -0.0-2.71828182845905i) -0.0-7.54413710281697i)+(num-test (sin 0.00000001+0.0i) 0.00000001)+(num-test (sin -0.00000001+0.0i) -0.00000001)+(num-test (sin 0.00000001-0.0i) 0.00000001)+(num-test (sin -0.00000001-0.0i) -0.00000001)+(num-test (sin 0.00000001+0.00000001i) 0.00000001+0.00000001i)+(num-test (sin -0.00000001+0.00000001i) -0.00000001+0.00000001i)+(num-test (sin 0.00000001-0.00000001i) 0.00000001-0.00000001i)+(num-test (sin -0.00000001-0.00000001i) -0.00000001-0.00000001i)+(num-test (sin 0.00000001+1.0i) 0.00000001543081+1.17520119364380i)+(num-test (sin -0.00000001+1.0i) -0.00000001543081+1.17520119364380i)+(num-test (sin 0.00000001-1.0i) 0.00000001543081-1.17520119364380i)+(num-test (sin -0.00000001-1.0i) -0.00000001543081-1.17520119364380i)+(num-test (sin 0.00000001+3.14159265358979i) 0.00000011591953+11.54873935725775i)+(num-test (sin -0.00000001+3.14159265358979i) -0.00000011591953+11.54873935725775i)+(num-test (sin 0.00000001-3.14159265358979i) 0.00000011591953-11.54873935725775i)+(num-test (sin -0.00000001-3.14159265358979i) -0.00000011591953-11.54873935725775i)+(num-test (sin 0.00000001+2.71828182845905i) 0.00000007610125+7.54413710281697i)+(num-test (sin -0.00000001+2.71828182845905i) -0.00000007610125+7.54413710281697i)+(num-test (sin 0.00000001-2.71828182845905i) 0.00000007610125-7.54413710281697i)+(num-test (sin -0.00000001-2.71828182845905i) -0.00000007610125-7.54413710281697i)+(num-test (sin 1.0+0.0i) 0.84147098480790)+(num-test (sin -1.0+0.0i) -0.84147098480790)+(num-test (sin 1.0-0.0i) 0.84147098480790)+(num-test (sin -1.0-0.0i) -0.84147098480790)+(num-test (sin 1.0+0.00000001i) 0.84147098480790+0.00000000540302i)+(num-test (sin -1.0+0.00000001i) -0.84147098480790+0.00000000540302i)+(num-test (sin 1.0-0.00000001i) 0.84147098480790-0.00000000540302i)+(num-test (sin -1.0-0.00000001i) -0.84147098480790-0.00000000540302i)+(num-test (sin 1.0+1.0i) 1.29845758141598+0.63496391478474i)+(num-test (sin -1.0+1.0i) -1.29845758141598+0.63496391478474i)+(num-test (sin 1.0-1.0i) 1.29845758141598-0.63496391478474i)+(num-test (sin -1.0-1.0i) -1.29845758141598-0.63496391478474i)+(num-test (sin 1.0+3.14159265358979i) 9.75429233860021+6.23981050459650i)+(num-test (sin -1.0+3.14159265358979i) -9.75429233860021+6.23981050459650i)+(num-test (sin 1.0-3.14159265358979i) 9.75429233860021-6.23981050459650i)+(num-test (sin -1.0-3.14159265358979i) -9.75429233860021-6.23981050459650i)+(num-test (sin 1.0+2.71828182845905i) 6.40369949494148+4.07611467243740i)+(num-test (sin -1.0+2.71828182845905i) -6.40369949494148+4.07611467243740i)+(num-test (sin 1.0-2.71828182845905i) 6.40369949494148-4.07611467243740i)+(num-test (sin -1.0-2.71828182845905i) -6.40369949494148-4.07611467243740i)+(num-test (sin 10/3) -0.1905679628754527)+(num-test (sin 1234/3) 0.213644699569724)+(num-test (sin 1234/10) -0.7693905459455223)+(num-test (sin 1234000000/3) 9.98585468017658e-1)+(num-test (sin 1234000000/500029) -0.9907886154453116)+(num-test (sin 1234000000/362880) .9798963032808383)+(num-test (sin 500029/2) 0.270047165973401)+(num-test (sin 500029/3) 7.610322596690986e-1)+(num-test (sin 500029/10) .9665258739436294)+(num-test (sin 500029/1234) .05553717596791147)+(num-test (sin 362880/1234) -0.9463147870254296)+(num-test (sin our-pi) -6.982889851335445E-15)+(num-test (sin 2.71828182845905) .4107812905029501)+(num-test (sin 3.14159265358979+0.0i) -6.982889851335445E-15)+(num-test (sin 3.14159265358979+0.00000001i) -6.982889851335445E-15-1.0E-8i)+(num-test (sin 3.14159265358979+1.0i) -1.077516210464362E-14-1.175201193643801i)+(num-test (sin 3.14159265358979+3.14159265358979i) -8.094533288479446E-14-11.54873935725783i)+(num-test (sin 3.14159265358979+2.71828182845905i) -5.314066559815525E-14-7.54413710281663i)+(num-test (sin 2.71828182845905+0.0i) .4107812905029501)+(num-test (sin 2.71828182845905+0.00000001i) .4107812905029501-9.117339147869465E-9i)+(num-test (sin 2.71828182845905+1.0i) .6338686545195173-1.071470784943156i)+(num-test (sin 2.71828182845905+3.14159265358979i) 4.761757525968664-10.52937734504676i)+(num-test (sin 2.71828182845905+2.71828182845905i) 3.126097025348496-6.878245654440458i)+(num-test (sin 1234.0+0.00000001i) .6019276547624973-7.985506235875843E-9i)+(num-test (sin 1234.0+3.14159265358979i) 6.977517249251167-9.222253015388718i)+(num-test (sin 1234.0+2.71828182845905i) 4.58074477716391-6.024375387884452i)+(num-test (sin 1234000000.0+0.00000001i) -0.9872932128398908+1.5890913089022285E-9i)+(num-test (sin 1234000000.0+3.14159265358979i) -11.44465679247962+1.835200134139553i)+(num-test (sin 1234000000.0+2.71828182845905i) -7.513424898263172+1.198832270325275i)+(num-test (sin 1234.0+12.0i) 48983.30495194942-64983.97008730317i)+(num-test (sin -3.45266983001243932001e-04+0.0e+00i) -3.4526697614140534807e-4+0.0i)+(num-test (sin 3.45266983001243932001e-04+0.0e+00i) 3.4526697614140534807e-4+0.0i)+(num-test (sin -3.45266983001243932001e-04+1.19209289550781250e-07i) -3.4526697614140780134e-4+1.1920928244535424533e-7i)+(num-test (sin -3.45266983001243932001e-04-1.19209289550781250e-07i) -3.4526697614140780134e-4-1.1920928244535424533e-7i)+(num-test (sin 3.45266983001243932001e-04+1.19209289550781250e-07i) 3.4526697614140780134e-4+1.1920928244535424533e-7i)+(num-test (sin 3.45266983001243932001e-04-1.19209289550781250e-07i) 3.4526697614140780134e-4-1.1920928244535424533e-7i)+(num-test (sin -3.45266983001243932001e-04+5.0e-01i) -3.8933200722534065172e-4+5.2109527443404709209e-1i)+(num-test (sin -3.45266983001243932001e-04-5.0e-01i) -3.8933200722534065172e-4-5.2109527443404709209e-1i)+(num-test (sin 3.45266983001243932001e-04+5.0e-01i) 3.8933200722534065172e-4+5.2109527443404709209e-1i)+(num-test (sin 3.45266983001243932001e-04-5.0e-01i) 3.8933200722534065172e-4-5.2109527443404709209e-1i)+(num-test (sin -3.45266983001243932001e-04+1.0e+00i) -5.3277478472501939236e-4+1.1752011235963524660e0i)+(num-test (sin -3.45266983001243932001e-04-1.0e+00i) -5.3277478472501939236e-4-1.1752011235963524660e0i)+(num-test (sin 3.45266983001243932001e-04+1.0e+00i) 5.3277478472501939236e-4+1.1752011235963524660e0i)+(num-test (sin 3.45266983001243932001e-04-1.0e+00i) 5.3277478472501939236e-4-1.1752011235963524660e0i)+(num-test (sin -3.45266983001243932001e-04+2.0e+00i) -1.2989619299126701883e-3+3.6268601916692946556e0i)+(num-test (sin -3.45266983001243932001e-04-2.0e+00i) -1.2989619299126701883e-3-3.6268601916692946556e0i)+(num-test (sin 3.45266983001243932001e-04+2.0e+00i) 1.2989619299126701883e-3+3.6268601916692946556e0i)+(num-test (sin 3.45266983001243932001e-04-2.0e+00i) 1.2989619299126701883e-3-3.6268601916692946556e0i)+(num-test (sin 1.57045105981189525579e+00+0.0e+00i) 9.9999994039535581669e-1+0.0i)+(num-test (sin -1.57045105981189525579e+00+0.0e+00i) -9.9999994039535581669e-1+0.0i)+(num-test (sin 1.57045105981189525579e+00+1.19209289550781250e-07i) 9.9999994039536292211e-1+4.1159030931177815679e-11i)+(num-test (sin 1.57045105981189525579e+00-1.19209289550781250e-07i) 9.9999994039536292211e-1-4.1159030931177815679e-11i)+(num-test (sin -1.57045105981189525579e+00+1.19209289550781250e-07i) -9.9999994039536292211e-1+4.1159030931177815679e-11i)+(num-test (sin -1.57045105981189525579e+00-1.19209289550781250e-07i) -9.9999994039536292211e-1-4.1159030931177815679e-11i)+(num-test (sin 1.57045105981189525579e+00+5.0e-01i) 1.1276258979946363572e0+1.7991700040937027667e-4i)+(num-test (sin 1.57045105981189525579e+00-5.0e-01i) 1.1276258979946363572e0-1.7991700040937027667e-4i)+(num-test (sin -1.57045105981189525579e+00+5.0e-01i) -1.1276258979946363572e0+1.7991700040937027667e-4i)+(num-test (sin -1.57045105981189525579e+00-5.0e-01i) -1.1276258979946363572e0-1.7991700040937027667e-4i)+(num-test (sin 1.57045105981189525579e+00+1.0e+00i) 1.5430805428404715942e0+4.0575816248730593018e-4i)+(num-test (sin 1.57045105981189525579e+00-1.0e+00i) 1.5430805428404715942e0-4.0575816248730593018e-4i)+(num-test (sin -1.57045105981189525579e+00+1.0e+00i) -1.5430805428404715942e0+4.0575816248730593018e-4i)+(num-test (sin -1.57045105981189525579e+00-1.0e+00i) -1.5430805428404715942e0-4.0575816248730593018e-4i)+(num-test (sin 1.57045105981189525579e+00+2.0e+00i) 3.7621954668392959445e0+1.2522351259047577385e-3i)+(num-test (sin 1.57045105981189525579e+00-2.0e+00i) 3.7621954668392959445e0-1.2522351259047577385e-3i)+(num-test (sin -1.57045105981189525579e+00+2.0e+00i) -3.7621954668392959445e0+1.2522351259047577385e-3i)+(num-test (sin -1.57045105981189525579e+00-2.0e+00i) -3.7621954668392959445e0-1.2522351259047577385e-3i)+(num-test (sin 1.57114159377789786021e+00+0.0e+00i) 9.9999994039535581673e-1+0.0i)+(num-test (sin -1.57114159377789786021e+00+0.0e+00i) -9.9999994039535581673e-1+0.0i)+(num-test (sin 1.57114159377789786021e+00+1.19209289550781250e-07i) 9.9999994039536292216e-1-4.1159030931163216752e-11i)+(num-test (sin 1.57114159377789786021e+00-1.19209289550781250e-07i) 9.9999994039536292216e-1+4.1159030931163216752e-11i)+(num-test (sin -1.57114159377789786021e+00+1.19209289550781250e-07i) -9.9999994039536292216e-1-4.1159030931163216752e-11i)+(num-test (sin -1.57114159377789786021e+00-1.19209289550781250e-07i) -9.9999994039536292216e-1+4.1159030931163216752e-11i)+(num-test (sin 1.57114159377789786021e+00+5.0e-01i) 1.1276258979946363573e0-1.7991700040930646090e-4i)+(num-test (sin 1.57114159377789786021e+00-5.0e-01i) 1.1276258979946363573e0+1.7991700040930646090e-4i)+(num-test (sin -1.57114159377789786021e+00+5.0e-01i) -1.1276258979946363573e0-1.7991700040930646090e-4i)+(num-test (sin -1.57114159377789786021e+00-5.0e-01i) -1.1276258979946363573e0+1.7991700040930646090e-4i)+(num-test (sin 1.57114159377789786021e+00+1.0e+00i) 1.5430805428404715942e0-4.0575816248716200955e-4i)+(num-test (sin 1.57114159377789786021e+00-1.0e+00i) 1.5430805428404715942e0+4.0575816248716200955e-4i)+(num-test (sin -1.57114159377789786021e+00+1.0e+00i) -1.5430805428404715942e0-4.0575816248716200955e-4i)+(num-test (sin -1.57114159377789786021e+00-1.0e+00i) -1.5430805428404715942e0+4.0575816248716200955e-4i)+(num-test (sin 1.57114159377789786021e+00+2.0e+00i) 3.7621954668392959447e0-1.2522351259043135762e-3i)+(num-test (sin 1.57114159377789786021e+00-2.0e+00i) 3.7621954668392959447e0+1.2522351259043135762e-3i)+(num-test (sin -1.57114159377789786021e+00+2.0e+00i) -3.7621954668392959447e0-1.2522351259043135762e-3i)+(num-test (sin -1.57114159377789786021e+00-2.0e+00i) -3.7621954668392959447e0+1.2522351259043135762e-3i)+(num-test (sin 3.14124738660679181379e+00+0.0e+00i) 3.4526697614158608860e-4+0.0i)+(num-test (sin -3.14124738660679181379e+00+0.0e+00i) -3.4526697614158608860e-4+0.0i)+(num-test (sin 3.14124738660679181379e+00+1.19209289550781250e-07i) 3.4526697614158854187e-4-1.1920928244535424532e-7i)+(num-test (sin 3.14124738660679181379e+00-1.19209289550781250e-07i) 3.4526697614158854187e-4+1.1920928244535424532e-7i)+(num-test (sin -3.14124738660679181379e+00+1.19209289550781250e-07i) -3.4526697614158854187e-4-1.1920928244535424532e-7i)+(num-test (sin -3.14124738660679181379e+00-1.19209289550781250e-07i) -3.4526697614158854187e-4+1.1920928244535424532e-7i)+(num-test (sin 3.14124738660679181379e+00+5.0e-01i) 3.8933200722554445944e-4-5.2109527443404709206e-1i)+(num-test (sin 3.14124738660679181379e+00-5.0e-01i) 3.8933200722554445944e-4+5.2109527443404709206e-1i)+(num-test (sin -3.14124738660679181379e+00+5.0e-01i) -3.8933200722554445944e-4-5.2109527443404709206e-1i)+(num-test (sin -3.14124738660679181379e+00-5.0e-01i) -3.8933200722554445944e-4+5.2109527443404709206e-1i)+(num-test (sin 3.14124738660679181379e+00+1.0e+00i) 5.3277478472529828958e-4-1.1752011235963524659e0i)+(num-test (sin 3.14124738660679181379e+00-1.0e+00i) 5.3277478472529828958e-4+1.1752011235963524659e0i)+(num-test (sin -3.14124738660679181379e+00+1.0e+00i) -5.3277478472529828958e-4-1.1752011235963524659e0i)+(num-test (sin -3.14124738660679181379e+00-1.0e+00i) -5.3277478472529828958e-4+1.1752011235963524659e0i)+(num-test (sin 3.14124738660679181379e+00+2.0e+00i) 1.2989619299133501696e-3-3.6268601916692946553e0i)+(num-test (sin 3.14124738660679181379e+00-2.0e+00i) 1.2989619299133501696e-3+3.6268601916692946553e0i)+(num-test (sin -3.14124738660679181379e+00+2.0e+00i) -1.2989619299133501696e-3-3.6268601916692946553e0i)+(num-test (sin -3.14124738660679181379e+00-2.0e+00i) -1.2989619299133501696e-3+3.6268601916692946553e0i)+(num-test (sin 3.14193792057279441821e+00+0.0e+00i) -3.4526697614134115926e-4+0.0i)+(num-test (sin -3.14193792057279441821e+00+0.0e+00i) 3.4526697614134115926e-4+0.0i)+(num-test (sin 3.14193792057279441821e+00+1.19209289550781250e-07i) -3.4526697614134361253e-4-1.1920928244535424533e-7i)+(num-test (sin 3.14193792057279441821e+00-1.19209289550781250e-07i) -3.4526697614134361253e-4+1.1920928244535424533e-7i)+(num-test (sin -3.14193792057279441821e+00+1.19209289550781250e-07i) 3.4526697614134361253e-4-1.1920928244535424533e-7i)+(num-test (sin -3.14193792057279441821e+00-1.19209289550781250e-07i) 3.4526697614134361253e-4+1.1920928244535424533e-7i)+(num-test (sin 3.14193792057279441821e+00+5.0e-01i) -3.8933200722526827075e-4-5.2109527443404709211e-1i)+(num-test (sin 3.14193792057279441821e+00-5.0e-01i) -3.8933200722526827075e-4+5.2109527443404709211e-1i)+(num-test (sin -3.14193792057279441821e+00+5.0e-01i) 3.8933200722526827075e-4-5.2109527443404709211e-1i)+(num-test (sin -3.14193792057279441821e+00-5.0e-01i) 3.8933200722526827075e-4+5.2109527443404709211e-1i)+(num-test (sin 3.14193792057279441821e+00+1.0e+00i) -5.3277478472492034385e-4-1.1752011235963524660e0i)+(num-test (sin 3.14193792057279441821e+00-1.0e+00i) -5.3277478472492034385e-4+1.1752011235963524660e0i)+(num-test (sin -3.14193792057279441821e+00+1.0e+00i) 5.3277478472492034385e-4-1.1752011235963524660e0i)+(num-test (sin -3.14193792057279441821e+00-1.0e+00i) 5.3277478472492034385e-4+1.1752011235963524660e0i)+(num-test (sin 3.14193792057279441821e+00+2.0e+00i) -1.2989619299124286975e-3-3.6268601916692946556e0i)+(num-test (sin 3.14193792057279441821e+00-2.0e+00i) -1.2989619299124286975e-3+3.6268601916692946556e0i)+(num-test (sin -3.14193792057279441821e+00+2.0e+00i) 1.2989619299124286975e-3-3.6268601916692946556e0i)+(num-test (sin -3.14193792057279441821e+00-2.0e+00i) 1.2989619299124286975e-3+3.6268601916692946556e0i)+(num-test (sin 4.71204371340168837179e+00+0.0e+00i) -9.9999994039535581664e-1+0.0i)+(num-test (sin -4.71204371340168837179e+00+0.0e+00i) 9.9999994039535581664e-1+0.0i)+(num-test (sin 4.71204371340168837179e+00+1.19209289550781250e-07i) -9.9999994039536292207e-1-4.1159030931192414605e-11i)+(num-test (sin 4.71204371340168837179e+00-1.19209289550781250e-07i) -9.9999994039536292207e-1+4.1159030931192414605e-11i)+(num-test (sin -4.71204371340168837179e+00+1.19209289550781250e-07i) 9.9999994039536292207e-1-4.1159030931192414605e-11i)+(num-test (sin -4.71204371340168837179e+00-1.19209289550781250e-07i) 9.9999994039536292207e-1+4.1159030931192414605e-11i)+(num-test (sin 4.71204371340168837179e+00+5.0e-01i) -1.1276258979946363572e0-1.7991700040943409243e-4i)+(num-test (sin 4.71204371340168837179e+00-5.0e-01i) -1.1276258979946363572e0+1.7991700040943409243e-4i)+(num-test (sin -4.71204371340168837179e+00+5.0e-01i) 1.1276258979946363572e0-1.7991700040943409243e-4i)+(num-test (sin -4.71204371340168837179e+00-5.0e-01i) 1.1276258979946363572e0+1.7991700040943409243e-4i)+(num-test (sin 4.71204371340168837179e+00+1.0e+00i) -1.5430805428404715941e0-4.0575816248744985081e-4i)+(num-test (sin 4.71204371340168837179e+00-1.0e+00i) -1.5430805428404715941e0+4.0575816248744985081e-4i)+(num-test (sin -4.71204371340168837179e+00+1.0e+00i) 1.5430805428404715941e0-4.0575816248744985081e-4i)+(num-test (sin -4.71204371340168837179e+00-1.0e+00i) 1.5430805428404715941e0+4.0575816248744985081e-4i)+(num-test (sin 4.71204371340168837179e+00+2.0e+00i) -3.7621954668392959444e0-1.2522351259052019007e-3i)+(num-test (sin 4.71204371340168837179e+00-2.0e+00i) -3.7621954668392959444e0+1.2522351259052019007e-3i)+(num-test (sin -4.71204371340168837179e+00+2.0e+00i) 3.7621954668392959444e0-1.2522351259052019007e-3i)+(num-test (sin -4.71204371340168837179e+00-2.0e+00i) 3.7621954668392959444e0+1.2522351259052019007e-3i)+(num-test (sin 4.71273424736769097620e+00+0.0e+00i) -9.9999994039535581677e-1+0.0i)+(num-test (sin -4.71273424736769097620e+00+0.0e+00i) 9.9999994039535581677e-1+0.0i)+(num-test (sin 4.71273424736769097620e+00+1.19209289550781250e-07i) -9.9999994039536292220e-1+4.1159030931148617825e-11i)+(num-test (sin 4.71273424736769097620e+00-1.19209289550781250e-07i) -9.9999994039536292220e-1-4.1159030931148617825e-11i)+(num-test (sin -4.71273424736769097620e+00+1.19209289550781250e-07i) 9.9999994039536292220e-1+4.1159030931148617825e-11i)+(num-test (sin -4.71273424736769097620e+00-1.19209289550781250e-07i) 9.9999994039536292220e-1-4.1159030931148617825e-11i)+(num-test (sin 4.71273424736769097620e+00+5.0e-01i) -1.1276258979946363573e0+1.7991700040924264514e-4i)+(num-test (sin 4.71273424736769097620e+00-5.0e-01i) -1.1276258979946363573e0-1.7991700040924264514e-4i)+(num-test (sin -4.71273424736769097620e+00+5.0e-01i) 1.1276258979946363573e0+1.7991700040924264514e-4i)+(num-test (sin -4.71273424736769097620e+00-5.0e-01i) 1.1276258979946363573e0-1.7991700040924264514e-4i)+(num-test (sin 4.71273424736769097620e+00+1.0e+00i) -1.5430805428404715943e0+4.0575816248701808892e-4i)+(num-test (sin 4.71273424736769097620e+00-1.0e+00i) -1.5430805428404715943e0-4.0575816248701808892e-4i)+(num-test (sin -4.71273424736769097620e+00+1.0e+00i) 1.5430805428404715943e0+4.0575816248701808892e-4i)+(num-test (sin -4.71273424736769097620e+00-1.0e+00i) 1.5430805428404715943e0-4.0575816248701808892e-4i)+(num-test (sin 4.71273424736769097620e+00+2.0e+00i) -3.7621954668392959448e0+1.2522351259038694139e-3i)+(num-test (sin 4.71273424736769097620e+00-2.0e+00i) -3.7621954668392959448e0-1.2522351259038694139e-3i)+(num-test (sin -4.71273424736769097620e+00+2.0e+00i) 3.7621954668392959448e0+1.2522351259038694139e-3i)+(num-test (sin -4.71273424736769097620e+00-2.0e+00i) 3.7621954668392959448e0-1.2522351259038694139e-3i)+(num-test (sin 6.28284004019658492979e+00+0.0e+00i) -3.4526697614170855328e-4+0.0i)+(num-test (sin -6.28284004019658492979e+00+0.0e+00i) 3.4526697614170855328e-4+0.0i)+(num-test (sin 6.28284004019658492979e+00+1.19209289550781250e-07i) -3.4526697614171100655e-4+1.1920928244535424532e-7i)+(num-test (sin 6.28284004019658492979e+00-1.19209289550781250e-07i) -3.4526697614171100655e-4-1.1920928244535424532e-7i)+(num-test (sin -6.28284004019658492979e+00+1.19209289550781250e-07i) 3.4526697614171100655e-4+1.1920928244535424532e-7i)+(num-test (sin -6.28284004019658492979e+00-1.19209289550781250e-07i) 3.4526697614171100655e-4-1.1920928244535424532e-7i)+(num-test (sin 6.28284004019658492979e+00+5.0e-01i) -3.8933200722568255379e-4+5.2109527443404709204e-1i)+(num-test (sin 6.28284004019658492979e+00-5.0e-01i) -3.8933200722568255379e-4-5.2109527443404709204e-1i)+(num-test (sin -6.28284004019658492979e+00+5.0e-01i) 3.8933200722568255379e-4+5.2109527443404709204e-1i)+(num-test (sin -6.28284004019658492979e+00-5.0e-01i) 3.8933200722568255379e-4-5.2109527443404709204e-1i)+(num-test (sin 6.28284004019658492979e+00+1.0e+00i) -5.3277478472548726245e-4+1.1752011235963524659e0i)+(num-test (sin 6.28284004019658492979e+00-1.0e+00i) -5.3277478472548726245e-4-1.1752011235963524659e0i)+(num-test (sin -6.28284004019658492979e+00+1.0e+00i) 5.3277478472548726245e-4+1.1752011235963524659e0i)+(num-test (sin -6.28284004019658492979e+00-1.0e+00i) 5.3277478472548726245e-4-1.1752011235963524659e0i)+(num-test (sin 6.28284004019658492979e+00+2.0e+00i) -1.2989619299138109057e-3+3.6268601916692946552e0i)+(num-test (sin 6.28284004019658492979e+00-2.0e+00i) -1.2989619299138109057e-3-3.6268601916692946552e0i)+(num-test (sin -6.28284004019658492979e+00+2.0e+00i) 1.2989619299138109057e-3+3.6268601916692946552e0i)+(num-test (sin -6.28284004019658492979e+00-2.0e+00i) 1.2989619299138109057e-3-3.6268601916692946552e0i)+(num-test (sin 6.28353057416258753420e+00+0.0e+00i) 3.4526697614121869459e-4+0.0i)+(num-test (sin -6.28353057416258753420e+00+0.0e+00i) -3.4526697614121869459e-4+0.0i)+(num-test (sin 6.28353057416258753420e+00+1.19209289550781250e-07i) 3.4526697614122114786e-4+1.1920928244535424534e-7i)+(num-test (sin 6.28353057416258753420e+00-1.19209289550781250e-07i) 3.4526697614122114786e-4-1.1920928244535424534e-7i)+(num-test (sin -6.28353057416258753420e+00+1.19209289550781250e-07i) -3.4526697614122114786e-4+1.1920928244535424534e-7i)+(num-test (sin -6.28353057416258753420e+00-1.19209289550781250e-07i) -3.4526697614122114786e-4-1.1920928244535424534e-7i)+(num-test (sin 6.28353057416258753420e+00+5.0e-01i) 3.8933200722513017641e-4+5.2109527443404709213e-1i)+(num-test (sin 6.28353057416258753420e+00-5.0e-01i) 3.8933200722513017641e-4-5.2109527443404709213e-1i)+(num-test (sin -6.28353057416258753420e+00+5.0e-01i) -3.8933200722513017641e-4+5.2109527443404709213e-1i)+(num-test (sin -6.28353057416258753420e+00-5.0e-01i) -3.8933200722513017641e-4-5.2109527443404709213e-1i)+(num-test (sin 6.28353057416258753420e+00+1.0e+00i) 5.3277478472473137099e-4+1.1752011235963524661e0i)+(num-test (sin 6.28353057416258753420e+00-1.0e+00i) 5.3277478472473137099e-4-1.1752011235963524661e0i)+(num-test (sin -6.28353057416258753420e+00+1.0e+00i) -5.3277478472473137099e-4+1.1752011235963524661e0i)+(num-test (sin -6.28353057416258753420e+00-1.0e+00i) -5.3277478472473137099e-4-1.1752011235963524661e0i)+(num-test (sin 6.28353057416258753420e+00+2.0e+00i) 1.2989619299119679614e-3+3.6268601916692946558e0i)+(num-test (sin 6.28353057416258753420e+00-2.0e+00i) 1.2989619299119679614e-3-3.6268601916692946558e0i)+(num-test (sin -6.28353057416258753420e+00+2.0e+00i) -1.2989619299119679614e-3+3.6268601916692946558e0i)+(num-test (sin -6.28353057416258753420e+00-2.0e+00i) -1.2989619299119679614e-3-3.6268601916692946558e0i)+(num-test (sin 9.42443269378637893396e+00+0.0e+00i) 3.4526697614094283958e-4+0.0i)+(num-test (sin -9.42443269378637893396e+00+0.0e+00i) -3.4526697614094283958e-4+0.0i)+(num-test (sin 9.42443269378637893396e+00+1.19209289550781250e-07i) 3.4526697614094529285e-4-1.1920928244535424535e-7i)+(num-test (sin 9.42443269378637893396e+00-1.19209289550781250e-07i) 3.4526697614094529285e-4+1.1920928244535424535e-7i)+(num-test (sin -9.42443269378637893396e+00+1.19209289550781250e-07i) -3.4526697614094529285e-4-1.1920928244535424535e-7i)+(num-test (sin -9.42443269378637893396e+00-1.19209289550781250e-07i) -3.4526697614094529285e-4+1.1920928244535424535e-7i)+(num-test (sin 9.42443269378637893396e+00+5.0e-01i) 3.8933200722481911514e-4-5.2109527443404709218e-1i)+(num-test (sin 9.42443269378637893396e+00-5.0e-01i) 3.8933200722481911514e-4+5.2109527443404709218e-1i)+(num-test (sin -9.42443269378637893396e+00+5.0e-01i) -3.8933200722481911514e-4-5.2109527443404709218e-1i)+(num-test (sin -9.42443269378637893396e+00-5.0e-01i) -3.8933200722481911514e-4+5.2109527443404709218e-1i)+(num-test (sin 9.42443269378637893396e+00+1.0e+00i) 5.3277478472430570447e-4-1.1752011235963524662e0i)+(num-test (sin 9.42443269378637893396e+00-1.0e+00i) 5.3277478472430570447e-4+1.1752011235963524662e0i)+(num-test (sin -9.42443269378637893396e+00+1.0e+00i) -5.3277478472430570447e-4-1.1752011235963524662e0i)+(num-test (sin -9.42443269378637893396e+00-1.0e+00i) -5.3277478472430570447e-4+1.1752011235963524662e0i)+(num-test (sin 9.42443269378637893396e+00+2.0e+00i) 1.2989619299109301409e-3-3.6268601916692946561e0i)+(num-test (sin 9.42443269378637893396e+00-2.0e+00i) 1.2989619299109301409e-3+3.6268601916692946561e0i)+(num-test (sin -9.42443269378637893396e+00+2.0e+00i) -1.2989619299109301409e-3-3.6268601916692946561e0i)+(num-test (sin -9.42443269378637893396e+00-2.0e+00i) -1.2989619299109301409e-3+3.6268601916692946561e0i)+(num-test (sin 9.42512322775237976202e+00+0.0e+00i) -3.4526697614020805155e-4+0.0i)+(num-test (sin -9.42512322775237976202e+00+0.0e+00i) 3.4526697614020805155e-4+0.0i)+(num-test (sin 9.42512322775237976202e+00+1.19209289550781250e-07i) -3.4526697614021050482e-4-1.1920928244535424538e-7i)+(num-test (sin 9.42512322775237976202e+00-1.19209289550781250e-07i) -3.4526697614021050482e-4+1.1920928244535424538e-7i)+(num-test (sin -9.42512322775237976202e+00+1.19209289550781250e-07i) 3.4526697614021050482e-4-1.1920928244535424538e-7i)+(num-test (sin -9.42512322775237976202e+00-1.19209289550781250e-07i) 3.4526697614021050482e-4+1.1920928244535424538e-7i)+(num-test (sin 9.42512322775237976202e+00+5.0e-01i) -3.8933200722399054908e-4-5.2109527443404709231e-1i)+(num-test (sin 9.42512322775237976202e+00-5.0e-01i) -3.8933200722399054908e-4+5.2109527443404709231e-1i)+(num-test (sin -9.42512322775237976202e+00+5.0e-01i) 3.8933200722399054908e-4-5.2109527443404709231e-1i)+(num-test (sin -9.42512322775237976202e+00-5.0e-01i) 3.8933200722399054908e-4+5.2109527443404709231e-1i)+(num-test (sin 9.42512322775237976202e+00+1.0e+00i) -5.3277478472317186729e-4-1.1752011235963524665e0i)+(num-test (sin 9.42512322775237976202e+00-1.0e+00i) -5.3277478472317186729e-4+1.1752011235963524665e0i)+(num-test (sin -9.42512322775237976202e+00+1.0e+00i) 5.3277478472317186729e-4-1.1752011235963524665e0i)+(num-test (sin -9.42512322775237976202e+00-1.0e+00i) 5.3277478472317186729e-4+1.1752011235963524665e0i)+(num-test (sin 9.42512322775237976202e+00+2.0e+00i) -1.2989619299081657245e-3-3.6268601916692946571e0i)+(num-test (sin 9.42512322775237976202e+00-2.0e+00i) -1.2989619299081657245e-3+3.6268601916692946571e0i)+(num-test (sin -9.42512322775237976202e+00+2.0e+00i) 1.2989619299081657245e-3-3.6268601916692946571e0i)+(num-test (sin -9.42512322775237976202e+00-2.0e+00i) 1.2989619299081657245e-3+3.6268601916692946571e0i)+++;; -------- cos+(num-test (cos 0) 1.0)+(num-test (cos 1) 0.54030230586814)+(num-test (cos 2) -0.41614683654714)+(num-test (cos 3) -0.98999249660045)+(num-test (cos 0/1) 1.0)+(num-test (cos 0/2) 1.0)+(num-test (cos 0/3) 1.0)+(num-test (cos 0/10) 1.0)+(num-test (cos 0/1234) 1.0)+(num-test (cos 0/1234000000) 1.0)+(num-test (cos 0/500029) 1.0)+(num-test (cos 0/362880) 1.0)+(num-test (cos 1/1) 0.54030230586814)+(num-test (cos 1/2) 0.87758256189037)+(num-test (cos -1/2) 0.87758256189037)+(num-test (cos 1/3) 0.94495694631474)+(num-test (cos -1/3) 0.94495694631474)+(num-test (cos 1/10) 0.99500416527803)+(num-test (cos -1/10) 0.99500416527803)+(num-test (cos 1/1234) 0.99999967164800)+(num-test (cos -1/1234) 0.99999967164800)+(num-test (cos 1/1234000000) 1.0)+(num-test (cos -1/1234000000) 1.0)+(num-test (cos 1/500029) 0.99999999999800)+(num-test (cos -1/500029) 0.99999999999800)+(num-test (cos 1/362880) 0.99999999999620)+(num-test (cos -1/362880) 0.99999999999620)+(num-test (cos 2/1) -0.41614683654714)+(num-test (cos 2/2) 0.54030230586814)+(num-test (cos 2/3) 0.78588726077695)+(num-test (cos 2/10) 0.98006657784124)+(num-test (cos -2/10) 0.98006657784124)+(num-test (cos 2/1234) 0.99999868659223)+(num-test (cos -2/1234) 0.99999868659223)+(num-test (cos 2/1234000000) 1.0)+(num-test (cos -2/1234000000) 1.0)+(num-test (cos 2/500029) 0.99999999999200)+(num-test (cos -2/500029) 0.99999999999200)+(num-test (cos 2/362880) 0.99999999998481)+(num-test (cos -2/362880) 0.99999999998481)+(num-test (cos 3/1) -0.98999249660045)+(num-test (cos 3/2) 0.07073720166770)+(num-test (cos 3/3) 0.54030230586814)+(num-test (cos 3/10) 0.95533648912561)+(num-test (cos -3/10) 0.95533648912561)+(num-test (cos 3/1234) 0.99999704483333)+(num-test (cos -3/1234) 0.99999704483333)+(num-test (cos 3/1234000000) 1.0)+(num-test (cos -3/1234000000) 1.0)+(num-test (cos 3/500029) 0.99999999998200)+(num-test (cos -3/500029) 0.99999999998200)+(num-test (cos 3/362880) 0.99999999996583)+(num-test (cos -3/362880) 0.99999999996583)+(num-test (cos 10/3) -0.98167400471108)+(num-test (cos 10/10) 0.54030230586814)+(num-test (cos 10/1234) 0.99996716497825)+(num-test (cos -10/1234) 0.99996716497825)+(num-test (cos 10/1234000000) 1.0)+(num-test (cos -10/1234000000) 1.0)+(num-test (cos 10/500029) 0.99999999980002)+(num-test (cos -10/500029) 0.99999999980002)+(num-test (cos 10/362880) 0.99999999962030)+(num-test (cos -10/362880) 0.99999999962030)+(num-test (cos 1234/1234) 0.54030230586814)+(num-test (cos 1234/1234000000) 0.99999999999950)+(num-test (cos -1234/1234000000) 0.99999999999950)+(num-test (cos 1234/500029) 0.99999695484279)+(num-test (cos -1234/500029) 0.99999695484279)+(num-test (cos 1234/362880) 0.99999421805655)+(num-test (cos -1234/362880) 0.99999421805655)+(num-test (cos 1234000000/1234000000) 0.54030230586814)+(num-test (cos 500029/1234000000) 0.99999991790247)+(num-test (cos -500029/1234000000) 0.99999991790247)+(num-test (cos 500029/500029) 0.54030230586814)+(num-test (cos 500029/362880) 0.19165727729458)+(num-test (cos 362880/1234000000) 0.99999995676199)+(num-test (cos -362880/1234000000) 0.99999995676199)+(num-test (cos 362880/500029) 0.74802315864263)+(num-test (cos 362880/362880) 0.54030230586814)+(num-test (cos 0.0) 1.0)+(num-test (cos 0.00000001) 1.0)+(num-test (cos -0.00000001) 1.0)+(num-test (cos 1.0) 0.54030230586814)+(num-test (cos our-pi) -1.0)+(num-test (cos 2.71828182845905) -0.91173391478697)+(num-test (cos 0.0+0.0i) 1.0)+(num-test (cos -0.0+0.0i) 1.0)+(num-test (cos 0.0-0.0i) 1.0)+(num-test (cos -0.0-0.0i) 1.0)+(num-test (cos 0.0+0.00000001i) 1.0)+(num-test (cos -0.0+0.00000001i) 1.0)+(num-test (cos 0.0-0.00000001i) 1.0)+(num-test (cos -0.0-0.00000001i) 1.0)+(num-test (cos 0.0+1.0i) 1.54308063481524)+(num-test (cos -0.0+1.0i) 1.54308063481524)+(num-test (cos 0.0-1.0i) 1.54308063481524)+(num-test (cos 0.0+3.14159265358979i) 11.59195327552152)+(num-test (cos -0.0+3.14159265358979i) 11.59195327552152)+(num-test (cos 0.0-3.14159265358979i) 11.59195327552152)+(num-test (cos 0.0+2.71828182845905i) 7.61012513866229)+(num-test (cos -0.0+2.71828182845905i) 7.61012513866229)+(num-test (cos 0.0-2.71828182845905i) 7.61012513866229)+(num-test (cos 0.00000001+0.0i) 1.0)+(num-test (cos -0.00000001+0.0i) 1.0)+(num-test (cos 0.00000001-0.0i) 1.0)+(num-test (cos -0.00000001-0.0i) 1.0)+(num-test (cos 0.00000001+0.00000001i) 1.0-1e-16i) ; maxima+(num-test (cos -0.00000001+0.00000001i) 1.0+1e-16i)+(num-test (cos 0.00000001-0.00000001i) 1.0+1e-16i)+(num-test (cos -0.00000001-0.00000001i) 1.0-1e-16i)+(num-test (cos 0.00000001+1.0i) 1.54308063481524-0.00000001175201i)+(num-test (cos 0.00000001-1.0i) 1.54308063481524+0.00000001175201i)+(num-test (cos 0.00000001+3.14159265358979i) 11.59195327552152-0.00000011548739i)+(num-test (cos 0.00000001-3.14159265358979i) 11.59195327552152+0.00000011548739i)+(num-test (cos 0.00000001+2.71828182845905i) 7.61012513866229-0.00000007544137i)+(num-test (cos 0.00000001-2.71828182845905i) 7.61012513866229+0.00000007544137i)+(num-test (cos 1.0+0.0i) 0.54030230586814)+(num-test (cos 1.0-0.0i) 0.54030230586814)+(num-test (cos 1.0+0.00000001i) 0.54030230586814-0.00000000841471i)+(num-test (cos 1.0-0.00000001i) 0.54030230586814+0.00000000841471i)+(num-test (cos 1.0+1.0i) 0.83373002513115-0.98889770576287i)+(num-test (cos 1.0-1.0i) 0.83373002513115+0.98889770576287i)+(num-test (cos 1.0+3.14159265358979i) 6.26315908428001-9.71792908024139i)+(num-test (cos 1.0-3.14159265358979i) 6.26315908428001+9.71792908024139i)+(num-test (cos 1.0+2.71828182845905i) 4.11176816036433-6.34817247743319i)+(num-test (cos 1.0-2.71828182845905i) 4.11176816036433+6.34817247743319i)+(num-test (cos 3.14159265358979+0.0i) -1.0)+(num-test (cos 3.14159265358979-0.0i) -1.0)+(num-test (cos 3.14159265358979+0.00000001i) -1.0-3.23121723694911E-23i) ; maxima+(num-test (cos 3.14159265358979-0.00000001i) -1.0+3.23121723694911E-23i) ; maxima+(num-test (cos 3.14159265358979+1.0i) -1.54308063481524-0.0i)+(num-test (cos 3.14159265358979-1.0i) -1.54308063481524+0.0i)+(num-test (cos 3.14159265358979+3.14159265358979i) -11.5919532755216+8.064357485351393E-14i) ; maxima+(num-test (cos 3.14159265358979-3.14159265358979i) -11.59195327552152+3.73164856762037E-14i)+(num-test (cos 3.14159265358979+2.71828182845905i) -7.61012513866229-2.437674584452965E-14i)+(num-test (cos 3.14159265358979-2.71828182845905i) -7.61012513866229+2.437674584452965E-14i)+(num-test (cos 2.71828182845905+0.0i) -0.91173391478697)+(num-test (cos 2.71828182845905-0.0i) -0.91173391478697)+(num-test (cos 2.71828182845905+0.00000001i) -0.91173391478697-0.00000000410781i)+(num-test (cos 2.71828182845905-0.00000001i) -0.91173391478697+0.00000000410781i)+(num-test (cos 2.71828182845905+1.0i) -1.40687894801206-0.48275066292556i)+(num-test (cos 2.71828182845905-1.0i) -1.40687894801206+0.48275066292556i)+(num-test (cos 2.71828182835905+3.14159265358979i) -10.56877693991882-4.74400605685607i)+(num-test (cos 2.71828182845905-3.14159265358979i) -10.56877693991882+4.74400605685607i)+(num-test (cos 2.71828182845905+2.71828182845905i) -6.93840918469126-3.09899037482603i)+(num-test (cos 2.71828182845905-2.71828182845905i) -6.93840918469126+3.09899037482603i)+(num-test (cos -2/3) .7858872607769459)+(num-test (cos -3/2) 0.0707372016677029)+(num-test (cos -10/3) -0.9816740047110853)+(num-test (cos 1234/3) -0.9769114301438807)+(num-test (cos 1234/10) -0.6387786688749486)+(num-test (cos 1234000000/3) -5.317013319482049e-2)+(num-test (cos 1234000000/500029) .1354175745756898)+(num-test (cos 1234000000/362880) .1995074806029773)+(num-test (cos 500029/2) 0.962847094896035)+(num-test (cos 500029/3) -0.6487140328750399)+(num-test (cos 500029/10) .2565691622107056)+(num-test (cos 500029/1234) -0.9984566200318916)+(num-test (cos -500029/362880) .1916572772946199)+(num-test (cos 362880/1234) .3232465372699541)+(num-test (cos -362880/500029) .7480231586426291)+(num-test (cos -3.14159265358979) -1.0)+(num-test (cos -2.71828182845905) -0.9117339147869464)+(num-test (cos 0.0+3.14159265358979i) 11.5919532755216)+(num-test (cos 0.0+2.71828182845905i) 7.610125138661946)+(num-test (cos 0.00000001+1.0i) 1.543080634815244-1.1752011936438014E-8i)+(num-test (cos 0.00000001+3.14159265358979i) 11.5919532755216-1.154873935725783E-7i)+(num-test (cos 0.00000001+2.71828182845905i) 7.610125138661945-7.54413710281663E-8i)+(num-test (cos 1.0+0.00000001i) .5403023058681398-8.414709848078964E-9i)+(num-test (cos 1.0+3.14159265358979i) 6.263159084280057-9.71792908024146i)+(num-test (cos 1.0+2.71828182845905i) 4.111768160364146-6.348172477432901i)+(num-test (cos 3.14159265358979+0.0i) -1.0)+(num-test (cos 3.14159265358979+0.00000001i) -1.0+6.982889851335445E-23i)+(num-test (cos 3.14159265358979+1.0i) -1.543080634815244+8.206300488372603E-15i)+(num-test (cos 3.14159265358979+3.14159265358979i) -11.5919532755216+8.064357485351393E-14i)+(num-test (cos 3.14159265358979+2.71828182845905i) -7.610125138661946+5.267987841234144E-14i)+(num-test (cos 2.71828182845905+0.0i) -0.9117339147869464)+(num-test (cos 2.71828182845905+0.00000001i) -0.9117339147869464-4.1078129050295015E-9i)+(num-test (cos 2.71828182845905+1.0i) -1.406878948012029-0.4827506629256081i)+(num-test (cos 2.71828182845905+3.14159265358979i) -10.56877693991868-4.744006056856582i)+(num-test (cos 2.71828182845905+2.71828182845905i) -6.93840918469081-3.098990374826203i)+(num-test (cos 1234.0+0.00000001i) -0.7985506235875843-6.019276547624973E-9i)+(num-test (cos 1234.0+3.14159265358979i) -9.256761516765916-6.951505596777556i)+(num-test (cos 1234.0+2.71828182845905i) -6.077070175058048-4.541024753505155i)+(num-test (cos 1234000000.0+0.00000001i) +0.1589091308902228+9.872932128398908E-9i)+(num-test (cos 1234000000.0+3.14159265358979i) +1.84206722033321+11.40199198427758i)+(num-test (cos 1234000000.0+2.71828182845905i) +1.209318371750606+7.448275358344457i)+(num-test (cos 1234.0+12.0i) -64983.97009220963-48983.30494825104i)+(num-test (cos -3.45266983001243932001e-04+0.0e+00i) 9.9999994039535581673e-1+0.0i)+(num-test (cos 3.45266983001243932001e-04+0.0e+00i) 9.9999994039535581673e-1+0.0i)+(num-test (cos -3.45266983001243932001e-04+1.19209289550781250e-07i) 9.9999994039536292216e-1+4.1159030931163569191e-11i)+(num-test (cos -3.45266983001243932001e-04-1.19209289550781250e-07i) 9.9999994039536292216e-1-4.1159030931163569191e-11i)+(num-test (cos 3.45266983001243932001e-04+1.19209289550781250e-07i) 9.9999994039536292216e-1-4.1159030931163569191e-11i)+(num-test (cos 3.45266983001243932001e-04-1.19209289550781250e-07i) 9.9999994039536292216e-1+4.1159030931163569191e-11i)+(num-test (cos -3.45266983001243932001e-04+5.0e-01i) 1.1276258979946363573e0+1.7991700040930800151e-4i)+(num-test (cos -3.45266983001243932001e-04-5.0e-01i) 1.1276258979946363573e0-1.7991700040930800151e-4i)+(num-test (cos 3.45266983001243932001e-04+5.0e-01i) 1.1276258979946363573e0-1.7991700040930800151e-4i)+(num-test (cos 3.45266983001243932001e-04-5.0e-01i) 1.1276258979946363573e0+1.7991700040930800151e-4i)+(num-test (cos -3.45266983001243932001e-04+1.0e+00i) 1.5430805428404715942e0+4.057581624871654840e-4i)+(num-test (cos -3.45266983001243932001e-04-1.0e+00i) 1.5430805428404715942e0-4.057581624871654840e-4i)+(num-test (cos 3.45266983001243932001e-04+1.0e+00i) 1.5430805428404715942e0-4.057581624871654840e-4i)+(num-test (cos 3.45266983001243932001e-04-1.0e+00i) 1.5430805428404715942e0+4.057581624871654840e-4i)+(num-test (cos -3.45266983001243932001e-04+2.0e+00i) 3.7621954668392959447e0+1.2522351259043242989e-3i)+(num-test (cos -3.45266983001243932001e-04-2.0e+00i) 3.7621954668392959447e0-1.2522351259043242989e-3i)+(num-test (cos 3.45266983001243932001e-04+2.0e+00i) 3.7621954668392959447e0-1.2522351259043242989e-3i)+(num-test (cos 3.45266983001243932001e-04-2.0e+00i) 3.7621954668392959447e0+1.2522351259043242989e-3i)+(num-test (cos 1.57045105981189525579e+00+0.0e+00i) 3.4526697614152485627e-4+0.0i)+(num-test (cos -1.57045105981189525579e+00+0.0e+00i) 3.4526697614152485627e-4+0.0i)+(num-test (cos 1.57045105981189525579e+00+1.19209289550781250e-07i) 3.4526697614152730954e-4-1.1920928244535424532e-7i)+(num-test (cos 1.57045105981189525579e+00-1.19209289550781250e-07i) 3.4526697614152730954e-4+1.1920928244535424532e-7i)+(num-test (cos -1.57045105981189525579e+00+1.19209289550781250e-07i) 3.4526697614152730954e-4+1.1920928244535424532e-7i)+(num-test (cos -1.57045105981189525579e+00-1.19209289550781250e-07i) 3.4526697614152730954e-4-1.1920928244535424532e-7i)+(num-test (cos 1.57045105981189525579e+00+5.0e-01i) 3.8933200722547541227e-4-5.2109527443404709207e-1i)+(num-test (cos 1.57045105981189525579e+00-5.0e-01i) 3.8933200722547541227e-4+5.2109527443404709207e-1i)+(num-test (cos -1.57045105981189525579e+00+5.0e-01i) 3.8933200722547541227e-4+5.2109527443404709207e-1i)+(num-test (cos -1.57045105981189525579e+00-5.0e-01i) 3.8933200722547541227e-4-5.2109527443404709207e-1i)+(num-test (cos 1.57045105981189525579e+00+1.0e+00i) 5.3277478472520380315e-4-1.1752011235963524659e0i)+(num-test (cos 1.57045105981189525579e+00-1.0e+00i) 5.3277478472520380315e-4+1.1752011235963524659e0i)+(num-test (cos -1.57045105981189525579e+00+1.0e+00i) 5.3277478472520380315e-4+1.1752011235963524659e0i)+(num-test (cos -1.57045105981189525579e+00-1.0e+00i) 5.3277478472520380315e-4-1.1752011235963524659e0i)+(num-test (cos 1.57045105981189525579e+00+2.0e+00i) 1.2989619299131198016e-3-3.6268601916692946554e0i)+(num-test (cos 1.57045105981189525579e+00-2.0e+00i) 1.2989619299131198016e-3+3.6268601916692946554e0i)+(num-test (cos -1.57045105981189525579e+00+2.0e+00i) 1.2989619299131198016e-3+3.6268601916692946554e0i)+(num-test (cos -1.57045105981189525579e+00-2.0e+00i) 1.2989619299131198016e-3-3.6268601916692946554e0i)+(num-test (cos 1.57114159377789786021e+00+0.0e+00i) -3.4526697614140239160e-4+0.0i)+(num-test (cos -1.57114159377789786021e+00+0.0e+00i) -3.4526697614140239160e-4+0.0i)+(num-test (cos 1.57114159377789786021e+00+1.19209289550781250e-07i) -3.4526697614140484486e-4-1.1920928244535424533e-7i)+(num-test (cos 1.57114159377789786021e+00-1.19209289550781250e-07i) -3.4526697614140484486e-4+1.1920928244535424533e-7i)+(num-test (cos -1.57114159377789786021e+00+1.19209289550781250e-07i) -3.4526697614140484486e-4+1.1920928244535424533e-7i)+(num-test (cos -1.57114159377789786021e+00-1.19209289550781250e-07i) -3.4526697614140484486e-4-1.1920928244535424533e-7i)+(num-test (cos 1.57114159377789786021e+00+5.0e-01i) -3.8933200722533731792e-4-5.2109527443404709209e-1i)+(num-test (cos 1.57114159377789786021e+00-5.0e-01i) -3.8933200722533731792e-4+5.2109527443404709209e-1i)+(num-test (cos -1.57114159377789786021e+00+5.0e-01i) -3.8933200722533731792e-4+5.2109527443404709209e-1i)+(num-test (cos -1.57114159377789786021e+00-5.0e-01i) -3.8933200722533731792e-4-5.2109527443404709209e-1i)+(num-test (cos 1.57114159377789786021e+00+1.0e+00i) -5.3277478472501483029e-4-1.1752011235963524660e0i)+(num-test (cos 1.57114159377789786021e+00-1.0e+00i) -5.3277478472501483029e-4+1.1752011235963524660e0i)+(num-test (cos -1.57114159377789786021e+00+1.0e+00i) -5.3277478472501483029e-4+1.1752011235963524660e0i)+(num-test (cos -1.57114159377789786021e+00-1.0e+00i) -5.3277478472501483029e-4-1.1752011235963524660e0i)+(num-test (cos 1.57114159377789786021e+00+2.0e+00i) -1.2989619299126590655e-3-3.6268601916692946556e0i)+(num-test (cos 1.57114159377789786021e+00-2.0e+00i) -1.2989619299126590655e-3+3.6268601916692946556e0i)+(num-test (cos -1.57114159377789786021e+00+2.0e+00i) -1.2989619299126590655e-3+3.6268601916692946556e0i)+(num-test (cos -1.57114159377789786021e+00-2.0e+00i) -1.2989619299126590655e-3-3.6268601916692946556e0i)+(num-test (cos 3.14124738660679181379e+00+0.0e+00i) -9.9999994039535581667e-1+0.0i)+(num-test (cos -3.14124738660679181379e+00+0.0e+00i) -9.9999994039535581667e-1+0.0i)+(num-test (cos 3.14124738660679181379e+00+1.19209289550781250e-07i) -9.9999994039536292209e-1-4.1159030931185115142e-11i)+(num-test (cos 3.14124738660679181379e+00-1.19209289550781250e-07i) -9.9999994039536292209e-1+4.1159030931185115142e-11i)+(num-test (cos -3.14124738660679181379e+00+1.19209289550781250e-07i) -9.9999994039536292209e-1+4.1159030931185115142e-11i)+(num-test (cos -3.14124738660679181379e+00-1.19209289550781250e-07i) -9.9999994039536292209e-1-4.1159030931185115142e-11i)+(num-test (cos 3.14124738660679181379e+00+5.0e-01i) -1.1276258979946363572e0-1.7991700040940218455e-4i)+(num-test (cos 3.14124738660679181379e+00-5.0e-01i) -1.1276258979946363572e0+1.7991700040940218455e-4i)+(num-test (cos -3.14124738660679181379e+00+5.0e-01i) -1.1276258979946363572e0+1.7991700040940218455e-4i)+(num-test (cos -3.14124738660679181379e+00-5.0e-01i) -1.1276258979946363572e0-1.7991700040940218455e-4i)+(num-test (cos 3.14124738660679181379e+00+1.0e+00i) -1.5430805428404715941e0-4.0575816248737789049e-4i)+(num-test (cos 3.14124738660679181379e+00-1.0e+00i) -1.5430805428404715941e0+4.0575816248737789049e-4i)+(num-test (cos -3.14124738660679181379e+00+1.0e+00i) -1.5430805428404715941e0+4.0575816248737789049e-4i)+(num-test (cos -3.14124738660679181379e+00-1.0e+00i) -1.5430805428404715941e0-4.0575816248737789049e-4i)+(num-test (cos 3.14124738660679181379e+00+2.0e+00i) -3.7621954668392959444e0-1.2522351259049798196e-3i)+(num-test (cos 3.14124738660679181379e+00-2.0e+00i) -3.7621954668392959444e0+1.2522351259049798196e-3i)+(num-test (cos -3.14124738660679181379e+00+2.0e+00i) -3.7621954668392959444e0+1.2522351259049798196e-3i)+(num-test (cos -3.14124738660679181379e+00-2.0e+00i) -3.7621954668392959444e0-1.2522351259049798196e-3i)+(num-test (cos 3.14193792057279441821e+00+0.0e+00i) -9.9999994039535581675e-1+0.0i)+(num-test (cos -3.14193792057279441821e+00+0.0e+00i) -9.9999994039535581675e-1+0.0i)+(num-test (cos 3.14193792057279441821e+00+1.19209289550781250e-07i) -9.9999994039536292218e-1+4.1159030931155917289e-11i)+(num-test (cos 3.14193792057279441821e+00-1.19209289550781250e-07i) -9.9999994039536292218e-1-4.1159030931155917289e-11i)+(num-test (cos -3.14193792057279441821e+00+1.19209289550781250e-07i) -9.9999994039536292218e-1-4.1159030931155917289e-11i)+(num-test (cos -3.14193792057279441821e+00-1.19209289550781250e-07i) -9.9999994039536292218e-1+4.1159030931155917289e-11i)+(num-test (cos 3.14193792057279441821e+00+5.0e-01i) -1.1276258979946363573e0+1.7991700040927455302e-4i)+(num-test (cos 3.14193792057279441821e+00-5.0e-01i) -1.1276258979946363573e0-1.7991700040927455302e-4i)+(num-test (cos -3.14193792057279441821e+00+5.0e-01i) -1.1276258979946363573e0-1.7991700040927455302e-4i)+(num-test (cos -3.14193792057279441821e+00-5.0e-01i) -1.1276258979946363573e0+1.7991700040927455302e-4i)+(num-test (cos 3.14193792057279441821e+00+1.0e+00i) -1.5430805428404715943e0+4.0575816248709004923e-4i)+(num-test (cos 3.14193792057279441821e+00-1.0e+00i) -1.5430805428404715943e0-4.0575816248709004923e-4i)+(num-test (cos -3.14193792057279441821e+00+1.0e+00i) -1.5430805428404715943e0-4.0575816248709004923e-4i)+(num-test (cos -3.14193792057279441821e+00-1.0e+00i) -1.5430805428404715943e0+4.0575816248709004923e-4i)+(num-test (cos 3.14193792057279441821e+00+2.0e+00i) -3.7621954668392959448e0+1.2522351259040914950e-3i)+(num-test (cos 3.14193792057279441821e+00-2.0e+00i) -3.7621954668392959448e0-1.2522351259040914950e-3i)+(num-test (cos -3.14193792057279441821e+00+2.0e+00i) -3.7621954668392959448e0-1.2522351259040914950e-3i)+(num-test (cos -3.14193792057279441821e+00-2.0e+00i) -3.7621954668392959448e0+1.2522351259040914950e-3i)+(num-test (cos 4.71204371340168837179e+00+0.0e+00i) -3.4526697614164732094e-4+0.0i)+(num-test (cos -4.71204371340168837179e+00+0.0e+00i) -3.4526697614164732094e-4+0.0i)+(num-test (cos 4.71204371340168837179e+00+1.19209289550781250e-07i) -3.4526697614164977421e-4+1.1920928244535424532e-7i)+(num-test (cos 4.71204371340168837179e+00-1.19209289550781250e-07i) -3.4526697614164977421e-4-1.1920928244535424532e-7i)+(num-test (cos -4.71204371340168837179e+00+1.19209289550781250e-07i) -3.4526697614164977421e-4-1.1920928244535424532e-7i)+(num-test (cos -4.71204371340168837179e+00-1.19209289550781250e-07i) -3.4526697614164977421e-4+1.1920928244535424532e-7i)+(num-test (cos 4.71204371340168837179e+00+5.0e-01i) -3.8933200722561350661e-4+5.2109527443404709205e-1i)+(num-test (cos 4.71204371340168837179e+00-5.0e-01i) -3.8933200722561350661e-4-5.2109527443404709205e-1i)+(num-test (cos -4.71204371340168837179e+00+5.0e-01i) -3.8933200722561350661e-4-5.2109527443404709205e-1i)+(num-test (cos -4.71204371340168837179e+00-5.0e-01i) -3.8933200722561350661e-4+5.2109527443404709205e-1i)+(num-test (cos 4.71204371340168837179e+00+1.0e+00i) -5.3277478472539277601e-4+1.1752011235963524659e0i)+(num-test (cos 4.71204371340168837179e+00-1.0e+00i) -5.3277478472539277601e-4-1.1752011235963524659e0i)+(num-test (cos -4.71204371340168837179e+00+1.0e+00i) -5.3277478472539277601e-4-1.1752011235963524659e0i)+(num-test (cos -4.71204371340168837179e+00-1.0e+00i) -5.3277478472539277601e-4+1.1752011235963524659e0i)+(num-test (cos 4.71204371340168837179e+00+2.0e+00i) -1.2989619299135805376e-3+3.6268601916692946552e0i)+(num-test (cos 4.71204371340168837179e+00-2.0e+00i) -1.2989619299135805376e-3-3.6268601916692946552e0i)+(num-test (cos -4.71204371340168837179e+00+2.0e+00i) -1.2989619299135805376e-3-3.6268601916692946552e0i)+(num-test (cos -4.71204371340168837179e+00-2.0e+00i) -1.2989619299135805376e-3+3.6268601916692946552e0i)+(num-test (cos 4.71273424736769097620e+00+0.0e+00i) 3.4526697614127992692e-4+0.0i)+(num-test (cos -4.71273424736769097620e+00+0.0e+00i) 3.4526697614127992692e-4+0.0i)+(num-test (cos 4.71273424736769097620e+00+1.19209289550781250e-07i) 3.4526697614128238019e-4+1.1920928244535424533e-7i)+(num-test (cos 4.71273424736769097620e+00-1.19209289550781250e-07i) 3.4526697614128238019e-4-1.1920928244535424533e-7i)+(num-test (cos -4.71273424736769097620e+00+1.19209289550781250e-07i) 3.4526697614128238019e-4-1.1920928244535424533e-7i)+(num-test (cos -4.71273424736769097620e+00-1.19209289550781250e-07i) 3.4526697614128238019e-4+1.1920928244535424533e-7i)+(num-test (cos 4.71273424736769097620e+00+5.0e-01i) 3.8933200722519922358e-4+5.2109527443404709212e-1i)+(num-test (cos 4.71273424736769097620e+00-5.0e-01i) 3.8933200722519922358e-4-5.2109527443404709212e-1i)+(num-test (cos -4.71273424736769097620e+00+5.0e-01i) 3.8933200722519922358e-4-5.2109527443404709212e-1i)+(num-test (cos -4.71273424736769097620e+00-5.0e-01i) 3.8933200722519922358e-4+5.2109527443404709212e-1i)+(num-test (cos 4.71273424736769097620e+00+1.0e+00i) 5.3277478472482585742e-4+1.1752011235963524660e0i)+(num-test (cos 4.71273424736769097620e+00-1.0e+00i) 5.3277478472482585742e-4-1.1752011235963524660e0i)+(num-test (cos -4.71273424736769097620e+00+1.0e+00i) 5.3277478472482585742e-4-1.1752011235963524660e0i)+(num-test (cos -4.71273424736769097620e+00-1.0e+00i) 5.3277478472482585742e-4+1.1752011235963524660e0i)+(num-test (cos 4.71273424736769097620e+00+2.0e+00i) 1.2989619299121983294e-3+3.6268601916692946557e0i)+(num-test (cos 4.71273424736769097620e+00-2.0e+00i) 1.2989619299121983294e-3-3.6268601916692946557e0i)+(num-test (cos -4.71273424736769097620e+00+2.0e+00i) 1.2989619299121983294e-3-3.6268601916692946557e0i)+(num-test (cos -4.71273424736769097620e+00-2.0e+00i) 1.2989619299121983294e-3+3.6268601916692946557e0i)+(num-test (cos 6.28284004019658492979e+00+0.0e+00i) 9.9999994039535581662e-1+0.0i)+(num-test (cos -6.28284004019658492979e+00+0.0e+00i) 9.9999994039535581662e-1+0.0i)+(num-test (cos 6.28284004019658492979e+00+1.19209289550781250e-07i) 9.9999994039536292205e-1+4.1159030931199714069e-11i)+(num-test (cos 6.28284004019658492979e+00-1.19209289550781250e-07i) 9.9999994039536292205e-1-4.1159030931199714069e-11i)+(num-test (cos -6.28284004019658492979e+00+1.19209289550781250e-07i) 9.9999994039536292205e-1-4.1159030931199714069e-11i)+(num-test (cos -6.28284004019658492979e+00-1.19209289550781250e-07i) 9.9999994039536292205e-1+4.1159030931199714069e-11i)+(num-test (cos 6.28284004019658492979e+00+5.0e-01i) 1.1276258979946363572e0+1.7991700040946600032e-4i)+(num-test (cos 6.28284004019658492979e+00-5.0e-01i) 1.1276258979946363572e0-1.7991700040946600032e-4i)+(num-test (cos -6.28284004019658492979e+00+5.0e-01i) 1.1276258979946363572e0-1.7991700040946600032e-4i)+(num-test (cos -6.28284004019658492979e+00-5.0e-01i) 1.1276258979946363572e0+1.7991700040946600032e-4i)+(num-test (cos 6.28284004019658492979e+00+1.0e+00i) 1.5430805428404715941e0+4.0575816248752181112e-4i)+(num-test (cos 6.28284004019658492979e+00-1.0e+00i) 1.5430805428404715941e0-4.0575816248752181112e-4i)+(num-test (cos -6.28284004019658492979e+00+1.0e+00i) 1.5430805428404715941e0-4.0575816248752181112e-4i)+(num-test (cos -6.28284004019658492979e+00-1.0e+00i) 1.5430805428404715941e0+4.0575816248752181112e-4i)+(num-test (cos 6.28284004019658492979e+00+2.0e+00i) 3.7621954668392959443e0+1.2522351259054239819e-3i)+(num-test (cos 6.28284004019658492979e+00-2.0e+00i) 3.7621954668392959443e0-1.2522351259054239819e-3i)+(num-test (cos -6.28284004019658492979e+00+2.0e+00i) 3.7621954668392959443e0-1.2522351259054239819e-3i)+(num-test (cos -6.28284004019658492979e+00-2.0e+00i) 3.7621954668392959443e0+1.2522351259054239819e-3i)+(num-test (cos 6.28353057416258753420e+00+0.0e+00i) 9.9999994039535581679e-1+0.0i)+(num-test (cos -6.28353057416258753420e+00+0.0e+00i) 9.9999994039535581679e-1+0.0i)+(num-test (cos 6.28353057416258753420e+00+1.19209289550781250e-07i) 9.9999994039536292222e-1-4.1159030931141318362e-11i)+(num-test (cos 6.28353057416258753420e+00-1.19209289550781250e-07i) 9.9999994039536292222e-1+4.1159030931141318362e-11i)+(num-test (cos -6.28353057416258753420e+00+1.19209289550781250e-07i) 9.9999994039536292222e-1+4.1159030931141318362e-11i)+(num-test (cos -6.28353057416258753420e+00-1.19209289550781250e-07i) 9.9999994039536292222e-1-4.1159030931141318362e-11i)+(num-test (cos 6.28353057416258753420e+00+5.0e-01i) 1.1276258979946363574e0-1.7991700040921073725e-4i)+(num-test (cos 6.28353057416258753420e+00-5.0e-01i) 1.1276258979946363574e0+1.7991700040921073725e-4i)+(num-test (cos -6.28353057416258753420e+00+5.0e-01i) 1.1276258979946363574e0+1.7991700040921073725e-4i)+(num-test (cos -6.28353057416258753420e+00-5.0e-01i) 1.1276258979946363574e0-1.7991700040921073725e-4i)+(num-test (cos 6.28353057416258753420e+00+1.0e+00i) 1.5430805428404715943e0-4.0575816248694612861e-4i)+(num-test (cos 6.28353057416258753420e+00-1.0e+00i) 1.5430805428404715943e0+4.0575816248694612861e-4i)+(num-test (cos -6.28353057416258753420e+00+1.0e+00i) 1.5430805428404715943e0+4.0575816248694612861e-4i)+(num-test (cos -6.28353057416258753420e+00-1.0e+00i) 1.5430805428404715943e0-4.0575816248694612861e-4i)+(num-test (cos 6.28353057416258753420e+00+2.0e+00i) 3.7621954668392959449e0-1.2522351259036473328e-3i)+(num-test (cos 6.28353057416258753420e+00-2.0e+00i) 3.7621954668392959449e0+1.2522351259036473328e-3i)+(num-test (cos -6.28353057416258753420e+00+2.0e+00i) 3.7621954668392959449e0+1.2522351259036473328e-3i)+(num-test (cos -6.28353057416258753420e+00-2.0e+00i) 3.7621954668392959449e0-1.2522351259036473328e-3i)+(num-test (cos 9.42443269378637893396e+00+0.0e+00i) -9.9999994039535581689e-1+0.0i)+(num-test (cos -9.42443269378637893396e+00+0.0e+00i) -9.9999994039535581689e-1+0.0i)+(num-test (cos 9.42443269378637893396e+00+1.19209289550781250e-07i) -9.9999994039536292231e-1-4.1159030931108433883e-11i)+(num-test (cos 9.42443269378637893396e+00-1.19209289550781250e-07i) -9.9999994039536292231e-1+4.1159030931108433883e-11i)+(num-test (cos -9.42443269378637893396e+00+1.19209289550781250e-07i) -9.9999994039536292231e-1+4.1159030931108433883e-11i)+(num-test (cos -9.42443269378637893396e+00-1.19209289550781250e-07i) -9.9999994039536292231e-1-4.1159030931108433883e-11i)+(num-test (cos 9.42443269378637893396e+00+5.0e-01i) -1.1276258979946363575e0-1.7991700040906699050e-4i)+(num-test (cos 9.42443269378637893396e+00-5.0e-01i) -1.1276258979946363575e0+1.7991700040906699050e-4i)+(num-test (cos -9.42443269378637893396e+00+5.0e-01i) -1.1276258979946363575e0+1.7991700040906699050e-4i)+(num-test (cos -9.42443269378637893396e+00-5.0e-01i) -1.1276258979946363575e0-1.7991700040906699050e-4i)+(num-test (cos 9.42443269378637893396e+00+1.0e+00i) -1.5430805428404715945e0-4.0575816248662194348e-4i)+(num-test (cos 9.42443269378637893396e+00-1.0e+00i) -1.5430805428404715945e0+4.0575816248662194348e-4i)+(num-test (cos -9.42443269378637893396e+00+1.0e+00i) -1.5430805428404715945e0+4.0575816248662194348e-4i)+(num-test (cos -9.42443269378637893396e+00-1.0e+00i) -1.5430805428404715945e0-4.0575816248662194348e-4i)+(num-test (cos 9.42443269378637893396e+00+2.0e+00i) -3.7621954668392959453e0-1.2522351259026468452e-3i)+(num-test (cos 9.42443269378637893396e+00-2.0e+00i) -3.7621954668392959453e0+1.2522351259026468452e-3i)+(num-test (cos -9.42443269378637893396e+00+2.0e+00i) -3.7621954668392959453e0+1.2522351259026468452e-3i)+(num-test (cos -9.42443269378637893396e+00-2.0e+00i) -3.7621954668392959453e0-1.2522351259026468452e-3i)+(num-test (cos 9.42512322775237976202e+00+0.0e+00i) -9.9999994039535581714e-1+0.0i)+(num-test (cos -9.42512322775237976202e+00+0.0e+00i) -9.9999994039535581714e-1+0.0i)+(num-test (cos 9.42512322775237976202e+00+1.19209289550781250e-07i) -9.9999994039536292257e-1+4.1159030931020840323e-11i)+(num-test (cos 9.42512322775237976202e+00-1.19209289550781250e-07i) -9.9999994039536292257e-1-4.1159030931020840323e-11i)+(num-test (cos -9.42512322775237976202e+00+1.19209289550781250e-07i) -9.9999994039536292257e-1-4.1159030931020840323e-11i)+(num-test (cos -9.42512322775237976202e+00-1.19209289550781250e-07i) -9.9999994039536292257e-1+4.1159030931020840323e-11i)+(num-test (cos 9.42512322775237976202e+00+5.0e-01i) -1.1276258979946363577e0+1.7991700040868409591e-4i)+(num-test (cos 9.42512322775237976202e+00-5.0e-01i) -1.1276258979946363577e0-1.7991700040868409591e-4i)+(num-test (cos -9.42512322775237976202e+00+5.0e-01i) -1.1276258979946363577e0-1.7991700040868409591e-4i)+(num-test (cos -9.42512322775237976202e+00-5.0e-01i) -1.1276258979946363577e0+1.7991700040868409591e-4i)+(num-test (cos 9.42512322775237976202e+00+1.0e+00i) -1.5430805428404715949e0+4.0575816248575841970e-4i)+(num-test (cos 9.42512322775237976202e+00-1.0e+00i) -1.5430805428404715949e0-4.0575816248575841970e-4i)+(num-test (cos -9.42512322775237976202e+00+1.0e+00i) -1.5430805428404715949e0-4.0575816248575841970e-4i)+(num-test (cos -9.42512322775237976202e+00-1.0e+00i) -1.5430805428404715949e0+4.0575816248575841970e-4i)+(num-test (cos 9.42512322775237976202e+00+2.0e+00i) -3.7621954668392959462e0+1.2522351258999818715e-3i)+(num-test (cos 9.42512322775237976202e+00-2.0e+00i) -3.7621954668392959462e0-1.2522351258999818715e-3i)+(num-test (cos -9.42512322775237976202e+00+2.0e+00i) -3.7621954668392959462e0-1.2522351258999818715e-3i)+(num-test (cos -9.42512322775237976202e+00-2.0e+00i) -3.7621954668392959462e0+1.2522351258999818715e-3i)+(num-test (cos 0) 1.0)+++;; -------- tan+(num-test (tan 0) 0.0)+(num-test (tan 1) 1.55740772465490)+(num-test (tan -1) -1.55740772465490)+(num-test (tan 0/1) 0.0)+(num-test (tan 0/2) 0.0)+(num-test (tan 0/3) 0.0)+(num-test (tan 0/10) 0.0)+(num-test (tan 0/1234) 0.0)+(num-test (tan 0/1234000000) 0.0)+(num-test (tan 0/500029) 0.0)+(num-test (tan 0/362880) 0.0)+(num-test (tan 1/1) 1.55740772465490)+(num-test (tan -1/1) -1.55740772465490)+(num-test (tan 1/2) 0.54630248984379)+(num-test (tan -1/2) -0.54630248984379)+(num-test (tan 1/3) 0.34625354951058)+(num-test (tan -1/3) -0.34625354951058)+(num-test (tan 1/10) 0.10033467208545)+(num-test (tan -1/10) -0.10033467208545)+(num-test (tan 1/1234) 0.00081037294887)+(num-test (tan -1/1234) -0.00081037294887)+(num-test (tan 1/1234000000) 0.00000000081037)+(num-test (tan -1/1234000000) -0.00000000081037)+(num-test (tan 1/500029) 0.00000199988401)+(num-test (tan -1/500029) -0.00000199988401)+(num-test (tan 1/362880) 0.00000275573192)+(num-test (tan -1/362880) -0.00000275573192)+(num-test (tan 2/2) 1.55740772465490)+(num-test (tan -2/2) -1.55740772465490)+(num-test (tan 2/3) 0.78684288947298)+(num-test (tan -2/3) -0.78684288947298)+(num-test (tan 2/10) 0.20271003550867)+(num-test (tan -2/10) -0.20271003550867)+(num-test (tan 2/1234) 0.00162074696208)+(num-test (tan -2/1234) -0.00162074696208)+(num-test (tan 2/1234000000) 0.00000000162075)+(num-test (tan -2/1234000000) -0.00000000162075)+(num-test (tan 2/500029) 0.00000399976801)+(num-test (tan -2/500029) -0.00000399976801)+(num-test (tan 2/362880) 0.00000551146384)+(num-test (tan -2/362880) -0.00000551146384)+(num-test (tan 3/2) 14.10141994717166)+(num-test (tan -3/2) -14.10141994717166)+(num-test (tan 3/3) 1.55740772465490)+(num-test (tan -3/3) -1.55740772465490)+(num-test (tan 3/10) 0.30933624960962)+(num-test (tan -3/10) -0.30933624960962)+(num-test (tan 3/1234) 0.00243112310401)+(num-test (tan -3/1234) -0.00243112310401)+(num-test (tan 3/1234000000) 0.00000000243112)+(num-test (tan -3/1234000000) -0.00000000243112)+(num-test (tan 3/500029) 0.00000599965202)+(num-test (tan -3/500029) -0.00000599965202)+(num-test (tan 3/362880) 0.00000826719577)+(num-test (tan -3/362880) -0.00000826719577)+(num-test (tan 10/10) 1.55740772465490)+(num-test (tan -10/10) -1.55740772465490)+(num-test (tan 10/1234) 0.00810390511110)+(num-test (tan -10/1234) -0.00810390511110)+(num-test (tan 10/1234000000) 0.00000000810373)+(num-test (tan -10/1234000000) -0.00000000810373)+(num-test (tan 10/500029) 0.00001999884007)+(num-test (tan -10/500029) -0.00001999884007)+(num-test (tan 10/362880) 0.00002755731923)+(num-test (tan -10/362880) -0.00002755731923)+(num-test (tan 1234/1234) 1.55740772465490)+(num-test (tan -1234/1234) -1.55740772465490)+(num-test (tan 1234/1234000000) 0.00000100000000)+(num-test (tan -1234/1234000000) -0.00000100000000)+(num-test (tan 1234/500029) 0.00246786187432)+(num-test (tan -1234/500029) -0.00246786187432)+(num-test (tan 1234/362880) 0.00340058630026)+(num-test (tan -1234/362880) -0.00340058630026)+(num-test (tan 1234000000/1234000000) 1.55740772465490)+(num-test (tan -1234000000/1234000000) -1.55740772465490)+(num-test (tan 500029/1234000000) 0.00040520990873)+(num-test (tan -500029/1234000000) -0.00040520990873)+(num-test (tan 500029/500029) 1.55740772465490)+(num-test (tan -500029/500029) -1.55740772465490)+(num-test (tan 500029/362880) 5.12092171798848)+(num-test (tan -500029/362880) -5.12092171798848)+(num-test (tan 362880/1234000000) 0.00029406807979)+(num-test (tan -362880/1234000000) -0.00029406807979)+(num-test (tan 362880/500029) 0.88723539913856)+(num-test (tan -362880/500029) -0.88723539913856)+(num-test (tan 362880/362880) 1.55740772465490)+(num-test (tan -362880/362880) -1.55740772465490)+(num-test (tan 0.0) 0.0)+(num-test (tan 0.00000001) 0.00000001)+(num-test (tan -0.00000001) -0.00000001)+(num-test (tan 1.0) 1.55740772465490)+(num-test (tan -1.0) -1.55740772465490)+(num-test (tan 0.0+0.0i) 0.0)+(num-test (tan -0.0+0.0i) 0.0)+(num-test (tan 0.0-0.0i) 0.0)+(num-test (tan -0.0-0.0i) -0.0)+(num-test (tan 0.0+0.00000001i) 0.0+0.00000001i)+(num-test (tan -0.0+0.00000001i) 0.0+0.00000001i)+(num-test (tan 0.0-0.00000001i) 0.0-0.00000001i)+(num-test (tan -0.0-0.00000001i) -0.0-0.00000001i)+(num-test (tan 0.0+1.0i) 0.0+0.76159415595576i)+(num-test (tan -0.0+1.0i) 0.0+0.76159415595576i)+(num-test (tan 0.0-1.0i) 0.0-0.76159415595576i)+(num-test (tan -0.0-1.0i) -0.0-0.76159415595576i)+(num-test (tan 0.0+3.14159265358979i) 0.0+0.99627207622075i)+(num-test (tan -0.0+3.14159265358979i) 0.0+0.99627207622075i)+(num-test (tan 0.0-3.14159265358979i) 0.0-0.99627207622075i)+(num-test (tan -0.0-3.14159265358979i) -0.0-0.99627207622075i)+(num-test (tan 0.0+2.71828182845905i) 0.0+0.99132891580060i)+(num-test (tan -0.0+2.71828182845905i) 0.0+0.99132891580060i)+(num-test (tan 0.0-2.71828182845905i) 0.0-0.99132891580060i)+(num-test (tan -0.0-2.71828182845905i) -0.0-0.99132891580060i)+(num-test (tan 0.00000001+0.0i) 0.00000001)+(num-test (tan -0.00000001+0.0i) -0.00000001)+(num-test (tan 0.00000001-0.0i) 0.00000001)+(num-test (tan -0.00000001-0.0i) -0.00000001)+(num-test (tan 0.00000001+0.00000001i) 0.00000001+0.00000001i)+(num-test (tan -0.00000001+0.00000001i) -0.00000001+0.00000001i)+(num-test (tan 0.00000001-0.00000001i) 0.00000001-0.00000001i)+(num-test (tan -0.00000001-0.00000001i) -0.00000001-0.00000001i)+(num-test (tan 0.00000001+1.0i) 0.00000000419974+0.76159415595576i)+(num-test (tan -0.00000001+1.0i) -0.00000000419974+0.76159415595576i)+(num-test (tan 0.00000001-1.0i) 0.00000000419974-0.76159415595576i)+(num-test (tan -0.00000001-1.0i) -0.00000000419974-0.76159415595576i)+(num-test (tan 0.00000001+3.14159265358979i) 0.00000000007442+0.99627207622075i)+(num-test (tan -0.00000001+3.14159265358979i) -0.00000000007442+0.99627207622075i)+(num-test (tan 0.00000001-3.14159265358979i) 0.00000000007442-0.99627207622075i)+(num-test (tan -0.00000001-3.14159265358979i) -0.00000000007442-0.99627207622075i)+(num-test (tan 0.00000001+2.71828182845905i) 0.00000000017267+0.99132891580060i)+(num-test (tan -0.00000001+2.71828182845905i) -0.00000000017267+0.99132891580060i)+(num-test (tan 0.00000001-2.71828182845905i) 0.00000000017267-0.99132891580060i)+(num-test (tan -0.00000001-2.71828182845905i) -0.00000000017267-0.99132891580060i)+(num-test (tan 1.0+0.0i) 1.55740772465490)+(num-test (tan -1.0+0.0i) -1.55740772465490)+(num-test (tan 1.0-0.0i) 1.55740772465490)+(num-test (tan -1.0-0.0i) -1.55740772465490)+(num-test (tan 1.0+0.00000001i) 1.55740772465490+0.00000003425519i)+(num-test (tan -1.0+0.00000001i) -1.55740772465490+0.00000003425519i)+(num-test (tan 1.0-0.00000001i) 1.55740772465490-0.00000003425519i)+(num-test (tan -1.0-0.00000001i) -1.55740772465490-0.00000003425519i)+(num-test (tan 1.0+1.0i) 0.27175258531951+1.08392332733869i)+(num-test (tan -1.0+1.0i) -0.27175258531951+1.08392332733869i)+(num-test (tan 1.0-1.0i) 0.27175258531951-1.08392332733869i)+(num-test (tan -1.0-1.0i) -0.27175258531951-1.08392332733869i)+(num-test (tan 1.0+3.14159265358979i) 0.00340139653674+1.00154968930275i)+(num-test (tan -1.0+3.14159265358979i) -0.00340139653674+1.00154968930275i)+(num-test (tan 1.0-3.14159265358979i) 0.00340139653674-1.00154968930275i)+(num-test (tan -1.0-3.14159265358979i) -0.00340139653674-1.00154968930275i)+(num-test (tan 1.0+2.71828182845905i) 0.00794757997665+1.00359921084211i)+(num-test (tan -1.0+2.71828182845905i) -0.00794757997665+1.00359921084211i)+(num-test (tan 1.0-2.71828182845905i) 0.00794757997665-1.00359921084211i)+(num-test (tan -1.0-2.71828182845905i) -0.00794757997665-1.00359921084211i)+(num-test (tan 1234.0+1234.0i) 2.7e-20+1.0i)+(num-test (tan 1234.0-1234.0i) 2.7e-20-1.0i)+(num-test (tan 10/3) .1941255059835657)+(num-test (tan 1234/3) -0.2186940320047828)+(num-test (tan 1234/10) 1.204471256531804)+(num-test (tan 1234000000/3) -18.78094727276203)              ; -18.78094815124064721190472 according to arprec's mathtool+(num-test (tan 1234000000/500029) -7.31654379832009)+(num-test (tan 1234000000/362880) 4.911576750502133)+(num-test (tan 500029/2) .2804673425353792)+(num-test (tan 500029/3) -1.173139817032177)+(num-test (tan 500029/10) 3.767116303516932)+(num-test (tan 500029/1234) -0.05562302342803592)+(num-test (tan 362880/1234) -2.927532635052267)+(num-test (tan our-pi) 6.982889851335445E-15)+(num-test (tan 2.71828182845905) -0.4505495340698621)+(num-test (tan 0.00000001+1234.0i) +8.077935669463161E-28+1.0i)+(num-test (tan 0.00000001+1234000000.0i) 0.0+1.0i)+(num-test (tan 3.14159265358979+0.0i) 6.982889851335445E-15)+(num-test (tan 3.14159265358979+0.00000001i) +6.982889851335444E-15+1.0E-8i)+(num-test (tan 3.14159265358979+1.0i) +2.932634567877868E-15+0.7615941559557649i)+(num-test (tan 3.14159265358979+3.14159265358979i) +5.196631812627532E-17+0.99627207622075i)+(num-test (tan 3.14159265358979+2.71828182845905i) +1.205734242765375E-16+0.991328915800599i)+(num-test (tan 3.14159265358979+1234.0i) 0.0+1.0i)+(num-test (tan 3.14159265358979+1234000000.0i) -7.703719777548943E-34+1.0i)+(num-test (tan 2.71828182845905+0.0i) -0.4505495340698621)+(num-test (tan 2.71828182845905+0.00000001i) -0.4505495340698621+1.2029948826505699E-8i)+(num-test (tan 2.71828182845905+1.0i) -0.1692870118766369+0.8196826057997404i)+(num-test (tan 2.71828182845905+3.14159265358979i) -0.002790687681003331+0.9975247319761639i)+(num-test (tan 2.71828182845905+2.71828182845905i) -0.00648578276962794+0.9942257438545914i)+(num-test (tan 2.71828182845905+1234.0i) +2.710505431213761E-20+1.0i)+(num-test (tan 2.71828182845905+1234000000.0i) +2.710505431213761E-20+1.0i)+(num-test (tan 1234.0+0.00000001i) -0.7537751984442328+1.5681770497896427E-8i)+(num-test (tan 1234.0+3.14159265358979i) -0.003586791196867043+0.9989656315245496i)+(num-test (tan 1234.0+2.71828182845905i) -0.008351965390936033+0.9975698313220817i)+(num-test (tan 1234000000.0+0.00000001i) -6.212941995900324+3.9600648244422054E-7i)+(num-test (tan 1234000000.0+3.14159265358979i) -0.001176098307980411+1.003551866736695i)+(num-test (tan 1234000000.0+2.71828182845905i) -0.002755390838840499+1.008299558244272i)+;(num-test (tan 1.5707963259845+2.0630965522972e-18i) 1.234000079689074E+9+3.141593059344448i)+(num-test (tan -3.45266983001243932001e-04+0.0e+00i) -3.4526699672092183585e-4+0.0i)+(num-test (tan 3.45266983001243932001e-04+0.0e+00i) 3.4526699672092183585e-4+0.0i)+(num-test (tan -3.45266983001243932001e-04+1.19209289550781250e-07i) -3.4526699672091692931e-4+1.1920930376163652989e-7i)+(num-test (tan -3.45266983001243932001e-04-1.19209289550781250e-07i) -3.4526699672091692931e-4-1.1920930376163652989e-7i)+(num-test (tan 3.45266983001243932001e-04+1.19209289550781250e-07i) 3.4526699672091692931e-4+1.1920930376163652989e-7i)+(num-test (tan 3.45266983001243932001e-04-1.19209289550781250e-07i) 3.4526699672091692931e-4-1.1920930376163652989e-7i)+(num-test (tan -3.45266983001243932001e-04+5.0e-01i) -2.7153443992655805934e-4+4.6211720058436229979e-1i)+(num-test (tan -3.45266983001243932001e-04-5.0e-01i) -2.7153443992655805934e-4-4.6211720058436229979e-1i)+(num-test (tan 3.45266983001243932001e-04+5.0e-01i) 2.7153443992655805934e-4+4.6211720058436229979e-1i)+(num-test (tan 3.45266983001243932001e-04-5.0e-01i) 2.7153443992655805934e-4-4.6211720058436229979e-1i)+(num-test (tan -3.45266983001243932001e-04+1.0e+00i) -1.4500326960274960880e-4+7.6159419408485704836e-1i)+(num-test (tan -3.45266983001243932001e-04-1.0e+00i) -1.4500326960274960880e-4-7.6159419408485704836e-1i)+(num-test (tan 3.45266983001243932001e-04+1.0e+00i) 1.4500326960274960880e-4+7.6159419408485704836e-1i)+(num-test (tan 3.45266983001243932001e-04-1.0e+00i) 1.4500326960274960880e-4-7.6159419408485704836e-1i)+(num-test (tan -3.45266983001243932001e-04+2.0e+00i) -2.4393395410435306874e-5+9.6402758819508310556e-1i)+(num-test (tan -3.45266983001243932001e-04-2.0e+00i) -2.4393395410435306874e-5-9.6402758819508310556e-1i)+(num-test (tan 3.45266983001243932001e-04+2.0e+00i) 2.4393395410435306874e-5+9.6402758819508310556e-1i)+(num-test (tan 3.45266983001243932001e-04-2.0e+00i) 2.4393395410435306874e-5-9.6402758819508310556e-1i)+(num-test (tan 1.57045105981189525579e+00+0.0e+00i) 2.8963092606501007060e3+0.0i)+(num-test (tan -1.57045105981189525579e+00+0.0e+00i) -2.8963092606501007060e3+0.0i)+(num-test (tan 1.57045105981189525579e+00+1.19209289550781250e-07i) 2.8963089153831588642e3+9.9999992052646305569e-1i)+(num-test (tan 1.57045105981189525579e+00-1.19209289550781250e-07i) 2.8963089153831588642e3-9.9999992052646305569e-1i)+(num-test (tan -1.57045105981189525579e+00+1.19209289550781250e-07i) -2.8963089153831588642e3+9.9999992052646305569e-1i)+(num-test (tan -1.57045105981189525579e+00-1.19209289550781250e-07i) -2.8963089153831588642e3-9.9999992052646305569e-1i)+(num-test (tan 1.57045105981189525579e+00+5.0e-01i) 1.2715121175455623363e-3+2.1639524637389325996e0i)+(num-test (tan 1.57045105981189525579e+00-5.0e-01i) 1.2715121175455623363e-3-2.1639524637389325996e0i)+(num-test (tan -1.57045105981189525579e+00+5.0e-01i) -1.2715121175455623363e-3+2.1639524637389325996e0i)+(num-test (tan -1.57045105981189525579e+00-5.0e-01i) -1.2715121175455623363e-3-2.1639524637389325996e0i)+(num-test (tan 1.57045105981189525579e+00+1.0e+00i) 2.4999454374276273814e-4+1.3130351721648674823e0i)+(num-test (tan 1.57045105981189525579e+00-1.0e+00i) 2.4999454374276273814e-4-1.3130351721648674823e0i)+(num-test (tan -1.57045105981189525579e+00+1.0e+00i) -2.4999454374276273814e-4+1.3130351721648674823e0i)+(num-test (tan -1.57045105981189525579e+00-1.0e+00i) -2.4999454374276273814e-4-1.3130351721648674823e0i)+(num-test (tan 1.57045105981189525579e+00+2.0e+00i) 2.6247825506572821595e-5+1.0373147113268752620e0i)+(num-test (tan 1.57045105981189525579e+00-2.0e+00i) 2.6247825506572821595e-5-1.0373147113268752620e0i)+(num-test (tan -1.57045105981189525579e+00+2.0e+00i) -2.6247825506572821595e-5+1.0373147113268752620e0i)+(num-test (tan -1.57045105981189525579e+00-2.0e+00i) -2.6247825506572821595e-5-1.0373147113268752620e0i)+(num-test (tan 1.57114159377789786021e+00+0.0e+00i) -2.8963092606511280143e3+0.0i)+(num-test (tan -1.57114159377789786021e+00+0.0e+00i) 2.8963092606511280143e3+0.0i)+(num-test (tan 1.57114159377789786021e+00+1.19209289550781250e-07i) -2.8963089153841861720e3+9.9999992052717244672e-1i)+(num-test (tan 1.57114159377789786021e+00-1.19209289550781250e-07i) -2.8963089153841861720e3-9.9999992052717244672e-1i)+(num-test (tan -1.57114159377789786021e+00+1.19209289550781250e-07i) 2.8963089153841861720e3+9.9999992052717244672e-1i)+(num-test (tan -1.57114159377789786021e+00-1.19209289550781250e-07i) 2.8963089153841861720e3-9.9999992052717244672e-1i)+(num-test (tan 1.57114159377789786021e+00+5.0e-01i) -1.2715121175451113370e-3+2.1639524637389326002e0i)+(num-test (tan 1.57114159377789786021e+00-5.0e-01i) -1.2715121175451113370e-3-2.1639524637389326002e0i)+(num-test (tan -1.57114159377789786021e+00+5.0e-01i) 1.2715121175451113370e-3+2.1639524637389326002e0i)+(num-test (tan -1.57114159377789786021e+00-5.0e-01i) 1.2715121175451113370e-3-2.1639524637389326002e0i)+(num-test (tan 1.57114159377789786021e+00+1.0e+00i) -2.4999454374267406620e-4+1.3130351721648674824e0i)+(num-test (tan 1.57114159377789786021e+00-1.0e+00i) -2.4999454374267406620e-4-1.3130351721648674824e0i)+(num-test (tan -1.57114159377789786021e+00+1.0e+00i) 2.4999454374267406620e-4+1.3130351721648674824e0i)+(num-test (tan -1.57114159377789786021e+00-1.0e+00i) 2.4999454374267406620e-4-1.3130351721648674824e0i)+(num-test (tan 1.57114159377789786021e+00+2.0e+00i) -2.6247825506563511609e-5+1.0373147113268752620e0i)+(num-test (tan 1.57114159377789786021e+00-2.0e+00i) -2.6247825506563511609e-5-1.0373147113268752620e0i)+(num-test (tan -1.57114159377789786021e+00+2.0e+00i) 2.6247825506563511609e-5+1.0373147113268752620e0i)+(num-test (tan -1.57114159377789786021e+00-2.0e+00i) 2.6247825506563511609e-5-1.0373147113268752620e0i)+(num-test (tan 3.14124738660679181379e+00+0.0e+00i) -3.4526699672110257641e-4+0.0i)+(num-test (tan -3.14124738660679181379e+00+0.0e+00i) 3.4526699672110257641e-4+0.0i)+(num-test (tan 3.14124738660679181379e+00+1.19209289550781250e-07i) -3.4526699672109766987e-4+1.1920930376163652991e-7i)+(num-test (tan 3.14124738660679181379e+00-1.19209289550781250e-07i) -3.4526699672109766987e-4-1.1920930376163652991e-7i)+(num-test (tan -3.14124738660679181379e+00+1.19209289550781250e-07i) 3.4526699672109766987e-4+1.1920930376163652991e-7i)+(num-test (tan -3.14124738660679181379e+00-1.19209289550781250e-07i) 3.4526699672109766987e-4-1.1920930376163652991e-7i)+(num-test (tan 3.14124738660679181379e+00+5.0e-01i) -2.7153443992670020234e-4+4.6211720058436229984e-1i)+(num-test (tan 3.14124738660679181379e+00-5.0e-01i) -2.7153443992670020234e-4-4.6211720058436229984e-1i)+(num-test (tan -3.14124738660679181379e+00+5.0e-01i) 2.7153443992670020234e-4+4.6211720058436229984e-1i)+(num-test (tan -3.14124738660679181379e+00-5.0e-01i) 2.7153443992670020234e-4-4.6211720058436229984e-1i)+(num-test (tan 3.14124738660679181379e+00+1.0e+00i) -1.4500326960282551519e-4+7.6159419408485704840e-1i)+(num-test (tan 3.14124738660679181379e+00-1.0e+00i) -1.4500326960282551519e-4-7.6159419408485704840e-1i)+(num-test (tan -3.14124738660679181379e+00+1.0e+00i) 1.4500326960282551519e-4+7.6159419408485704840e-1i)+(num-test (tan -3.14124738660679181379e+00-1.0e+00i) 1.4500326960282551519e-4-7.6159419408485704840e-1i)+(num-test (tan 3.14124738660679181379e+00+2.0e+00i) -2.4393395410448076340e-5+9.6402758819508310557e-1i)+(num-test (tan 3.14124738660679181379e+00-2.0e+00i) -2.4393395410448076340e-5-9.6402758819508310557e-1i)+(num-test (tan -3.14124738660679181379e+00+2.0e+00i) 2.4393395410448076340e-5+9.6402758819508310557e-1i)+(num-test (tan -3.14124738660679181379e+00-2.0e+00i) 2.4393395410448076340e-5-9.6402758819508310557e-1i)+(num-test (tan 3.14193792057279441821e+00+0.0e+00i) 3.4526699672085764703e-4+0.0i)+(num-test (tan -3.14193792057279441821e+00+0.0e+00i) -3.4526699672085764703e-4+0.0i)+(num-test (tan 3.14193792057279441821e+00+1.19209289550781250e-07i) 3.4526699672085274049e-4+1.1920930376163652989e-7i)+(num-test (tan 3.14193792057279441821e+00-1.19209289550781250e-07i) 3.4526699672085274049e-4-1.1920930376163652989e-7i)+(num-test (tan -3.14193792057279441821e+00+1.19209289550781250e-07i) -3.4526699672085274049e-4+1.1920930376163652989e-7i)+(num-test (tan -3.14193792057279441821e+00-1.19209289550781250e-07i) -3.4526699672085274049e-4-1.1920930376163652989e-7i)+(num-test (tan 3.14193792057279441821e+00+5.0e-01i) 2.7153443992650757820e-4+4.6211720058436229978e-1i)+(num-test (tan 3.14193792057279441821e+00-5.0e-01i) 2.7153443992650757820e-4-4.6211720058436229978e-1i)+(num-test (tan -3.14193792057279441821e+00+5.0e-01i) -2.7153443992650757820e-4+4.6211720058436229978e-1i)+(num-test (tan -3.14193792057279441821e+00-5.0e-01i) -2.7153443992650757820e-4-4.6211720058436229978e-1i)+(num-test (tan 3.14193792057279441821e+00+1.0e+00i) 1.4500326960272265115e-4+7.6159419408485704835e-1i)+(num-test (tan 3.14193792057279441821e+00-1.0e+00i) 1.4500326960272265115e-4-7.6159419408485704835e-1i)+(num-test (tan -3.14193792057279441821e+00+1.0e+00i) -1.4500326960272265115e-4+7.6159419408485704835e-1i)+(num-test (tan -3.14193792057279441821e+00-1.0e+00i) -1.4500326960272265115e-4-7.6159419408485704835e-1i)+(num-test (tan 3.14193792057279441821e+00+2.0e+00i) 2.4393395410430771882e-5+9.6402758819508310556e-1i)+(num-test (tan 3.14193792057279441821e+00-2.0e+00i) 2.4393395410430771882e-5-9.6402758819508310556e-1i)+(num-test (tan -3.14193792057279441821e+00+2.0e+00i) -2.4393395410430771882e-5+9.6402758819508310556e-1i)+(num-test (tan -3.14193792057279441821e+00-2.0e+00i) -2.4393395410430771882e-5-9.6402758819508310556e-1i)+(num-test (tan 4.71204371340168837179e+00+0.0e+00i) 2.8963092606490733978e3+0.0i)+(num-test (tan -4.71204371340168837179e+00+0.0e+00i) -2.8963092606490733978e3+0.0i)+(num-test (tan 4.71204371340168837179e+00+1.19209289550781250e-07i) 2.8963089153821315563e3+9.9999992052575366466e-1i)+(num-test (tan 4.71204371340168837179e+00-1.19209289550781250e-07i) 2.8963089153821315563e3-9.9999992052575366466e-1i)+(num-test (tan -4.71204371340168837179e+00+1.19209289550781250e-07i) -2.8963089153821315563e3+9.9999992052575366466e-1i)+(num-test (tan -4.71204371340168837179e+00-1.19209289550781250e-07i) -2.8963089153821315563e3-9.9999992052575366466e-1i)+(num-test (tan 4.71204371340168837179e+00+5.0e-01i) 1.2715121175460133355e-3+2.1639524637389325989e0i)+(num-test (tan 4.71204371340168837179e+00-5.0e-01i) 1.2715121175460133355e-3-2.1639524637389325989e0i)+(num-test (tan -4.71204371340168837179e+00+5.0e-01i) -1.2715121175460133355e-3+2.1639524637389325989e0i)+(num-test (tan -4.71204371340168837179e+00-5.0e-01i) -1.2715121175460133355e-3-2.1639524637389325989e0i)+(num-test (tan 4.71204371340168837179e+00+1.0e+00i) 2.4999454374285141007e-4+1.3130351721648674822e0i)+(num-test (tan 4.71204371340168837179e+00-1.0e+00i) 2.4999454374285141007e-4-1.3130351721648674822e0i)+(num-test (tan -4.71204371340168837179e+00+1.0e+00i) -2.4999454374285141007e-4+1.3130351721648674822e0i)+(num-test (tan -4.71204371340168837179e+00-1.0e+00i) -2.4999454374285141007e-4-1.3130351721648674822e0i)+(num-test (tan 4.71204371340168837179e+00+2.0e+00i) 2.6247825506582131582e-5+1.0373147113268752620e0i)+(num-test (tan 4.71204371340168837179e+00-2.0e+00i) 2.6247825506582131582e-5-1.0373147113268752620e0i)+(num-test (tan -4.71204371340168837179e+00+2.0e+00i) -2.6247825506582131582e-5+1.0373147113268752620e0i)+(num-test (tan -4.71204371340168837179e+00-2.0e+00i) -2.6247825506582131582e-5-1.0373147113268752620e0i)+(num-test (tan 4.71273424736769097620e+00+0.0e+00i) -2.8963092606521553225e3+0.0i)+(num-test (tan -4.71273424736769097620e+00+0.0e+00i) 2.8963092606521553225e3+0.0i)+(num-test (tan 4.71273424736769097620e+00+1.19209289550781250e-07i) -2.8963089153852134799e3+9.9999992052788183776e-1i)+(num-test (tan 4.71273424736769097620e+00-1.19209289550781250e-07i) -2.8963089153852134799e3-9.9999992052788183776e-1i)+(num-test (tan -4.71273424736769097620e+00+1.19209289550781250e-07i) 2.8963089153852134799e3+9.9999992052788183776e-1i)+(num-test (tan -4.71273424736769097620e+00-1.19209289550781250e-07i) 2.8963089153852134799e3-9.9999992052788183776e-1i)+(num-test (tan 4.71273424736769097620e+00+5.0e-01i) -1.2715121175446603377e-3+2.1639524637389326009e0i)+(num-test (tan 4.71273424736769097620e+00-5.0e-01i) -1.2715121175446603377e-3-2.1639524637389326009e0i)+(num-test (tan -4.71273424736769097620e+00+5.0e-01i) 1.2715121175446603377e-3+2.1639524637389326009e0i)+(num-test (tan -4.71273424736769097620e+00-5.0e-01i) 1.2715121175446603377e-3-2.1639524637389326009e0i)+(num-test (tan 4.71273424736769097620e+00+1.0e+00i) -2.4999454374258539427e-4+1.3130351721648674825e0i)+(num-test (tan 4.71273424736769097620e+00-1.0e+00i) -2.4999454374258539427e-4-1.3130351721648674825e0i)+(num-test (tan -4.71273424736769097620e+00+1.0e+00i) 2.4999454374258539427e-4+1.3130351721648674825e0i)+(num-test (tan -4.71273424736769097620e+00-1.0e+00i) 2.4999454374258539427e-4-1.3130351721648674825e0i)+(num-test (tan 4.71273424736769097620e+00+2.0e+00i) -2.6247825506554201622e-5+1.0373147113268752620e0i)+(num-test (tan 4.71273424736769097620e+00-2.0e+00i) -2.6247825506554201622e-5-1.0373147113268752620e0i)+(num-test (tan -4.71273424736769097620e+00+2.0e+00i) 2.6247825506554201622e-5+1.0373147113268752620e0i)+(num-test (tan -4.71273424736769097620e+00-2.0e+00i) 2.6247825506554201622e-5-1.0373147113268752620e0i)+(num-test (tan 6.28284004019658492979e+00+0.0e+00i) -3.4526699672122504111e-4+0.0i)+(num-test (tan -6.28284004019658492979e+00+0.0e+00i) 3.4526699672122504111e-4+0.0i)+(num-test (tan 6.28284004019658492979e+00+1.19209289550781250e-07i) -3.4526699672122013457e-4+1.1920930376163652992e-7i)+(num-test (tan 6.28284004019658492979e+00-1.19209289550781250e-07i) -3.4526699672122013457e-4-1.1920930376163652992e-7i)+(num-test (tan -6.28284004019658492979e+00+1.19209289550781250e-07i) 3.4526699672122013457e-4+1.1920930376163652992e-7i)+(num-test (tan -6.28284004019658492979e+00-1.19209289550781250e-07i) 3.4526699672122013457e-4-1.1920930376163652992e-7i)+(num-test (tan 6.28284004019658492979e+00+5.0e-01i) -2.7153443992679651442e-4+4.6211720058436229987e-1i)+(num-test (tan 6.28284004019658492979e+00-5.0e-01i) -2.7153443992679651442e-4-4.6211720058436229987e-1i)+(num-test (tan -6.28284004019658492979e+00+5.0e-01i) 2.7153443992679651442e-4+4.6211720058436229987e-1i)+(num-test (tan -6.28284004019658492979e+00-5.0e-01i) 2.7153443992679651442e-4-4.6211720058436229987e-1i)+(num-test (tan 6.28284004019658492979e+00+1.0e+00i) -1.4500326960287694721e-4+7.6159419408485704843e-1i)+(num-test (tan 6.28284004019658492979e+00-1.0e+00i) -1.4500326960287694721e-4-7.6159419408485704843e-1i)+(num-test (tan -6.28284004019658492979e+00+1.0e+00i) 1.4500326960287694721e-4+7.6159419408485704843e-1i)+(num-test (tan -6.28284004019658492979e+00-1.0e+00i) 1.4500326960287694721e-4-7.6159419408485704843e-1i)+(num-test (tan 6.28284004019658492979e+00+2.0e+00i) -2.4393395410456728569e-5+9.6402758819508310558e-1i)+(num-test (tan 6.28284004019658492979e+00-2.0e+00i) -2.4393395410456728569e-5-9.6402758819508310558e-1i)+(num-test (tan -6.28284004019658492979e+00+2.0e+00i) 2.4393395410456728569e-5+9.6402758819508310558e-1i)+(num-test (tan -6.28284004019658492979e+00-2.0e+00i) 2.4393395410456728569e-5-9.6402758819508310558e-1i)+(num-test (tan 6.28353057416258753420e+00+0.0e+00i) 3.4526699672073518233e-4+0.0i)+(num-test (tan -6.28353057416258753420e+00+0.0e+00i) -3.4526699672073518233e-4+0.0i)+(num-test (tan 6.28353057416258753420e+00+1.19209289550781250e-07i) 3.4526699672073027579e-4+1.1920930376163652988e-7i)+(num-test (tan 6.28353057416258753420e+00-1.19209289550781250e-07i) 3.4526699672073027579e-4-1.1920930376163652988e-7i)+(num-test (tan -6.28353057416258753420e+00+1.19209289550781250e-07i) -3.4526699672073027579e-4+1.1920930376163652988e-7i)+(num-test (tan -6.28353057416258753420e+00-1.19209289550781250e-07i) -3.4526699672073027579e-4-1.1920930376163652988e-7i)+(num-test (tan 6.28353057416258753420e+00+5.0e-01i) 2.7153443992641126612e-4+4.6211720058436229974e-1i)+(num-test (tan 6.28353057416258753420e+00-5.0e-01i) 2.7153443992641126612e-4-4.6211720058436229974e-1i)+(num-test (tan -6.28353057416258753420e+00+5.0e-01i) -2.7153443992641126612e-4+4.6211720058436229974e-1i)+(num-test (tan -6.28353057416258753420e+00-5.0e-01i) -2.7153443992641126612e-4-4.6211720058436229974e-1i)+(num-test (tan 6.28353057416258753420e+00+1.0e+00i) 1.4500326960267121913e-4+7.6159419408485704832e-1i)+(num-test (tan 6.28353057416258753420e+00-1.0e+00i) 1.4500326960267121913e-4-7.6159419408485704832e-1i)+(num-test (tan -6.28353057416258753420e+00+1.0e+00i) -1.4500326960267121913e-4+7.6159419408485704832e-1i)+(num-test (tan -6.28353057416258753420e+00-1.0e+00i) -1.4500326960267121913e-4-7.6159419408485704832e-1i)+(num-test (tan 6.28353057416258753420e+00+2.0e+00i) 2.4393395410422119654e-5+9.6402758819508310555e-1i)+(num-test (tan 6.28353057416258753420e+00-2.0e+00i) 2.4393395410422119654e-5-9.6402758819508310555e-1i)+(num-test (tan -6.28353057416258753420e+00+2.0e+00i) -2.4393395410422119654e-5+9.6402758819508310555e-1i)+(num-test (tan -6.28353057416258753420e+00-2.0e+00i) -2.4393395410422119654e-5-9.6402758819508310555e-1i)+(num-test (tan 9.42443269378637893396e+00+0.0e+00i) -3.4526699672045932728e-4+0.0i)+(num-test (tan -9.42443269378637893396e+00+0.0e+00i) 3.4526699672045932728e-4+0.0i)+(num-test (tan 9.42443269378637893396e+00+1.19209289550781250e-07i) -3.4526699672045442074e-4+1.1920930376163652985e-7i)+(num-test (tan 9.42443269378637893396e+00-1.19209289550781250e-07i) -3.4526699672045442074e-4-1.1920930376163652985e-7i)+(num-test (tan -9.42443269378637893396e+00+1.19209289550781250e-07i) 3.4526699672045442074e-4+1.1920930376163652985e-7i)+(num-test (tan -9.42443269378637893396e+00-1.19209289550781250e-07i) 3.4526699672045442074e-4-1.1920930376163652985e-7i)+(num-test (tan 9.42443269378637893396e+00+5.0e-01i) -2.7153443992619432056e-4+4.6211720058436229968e-1i)+(num-test (tan 9.42443269378637893396e+00-5.0e-01i) -2.7153443992619432056e-4-4.6211720058436229968e-1i)+(num-test (tan -9.42443269378637893396e+00+5.0e-01i) 2.7153443992619432056e-4+4.6211720058436229968e-1i)+(num-test (tan -9.42443269378637893396e+00-5.0e-01i) 2.7153443992619432056e-4-4.6211720058436229968e-1i)+(num-test (tan 9.42443269378637893396e+00+1.0e+00i) -1.4500326960255536711e-4+7.6159419408485704826e-1i)+(num-test (tan 9.42443269378637893396e+00-1.0e+00i) -1.4500326960255536711e-4-7.6159419408485704826e-1i)+(num-test (tan -9.42443269378637893396e+00+1.0e+00i) 1.4500326960255536711e-4+7.6159419408485704826e-1i)+(num-test (tan -9.42443269378637893396e+00-1.0e+00i) 1.4500326960255536711e-4-7.6159419408485704826e-1i)+(num-test (tan 9.42443269378637893396e+00+2.0e+00i) -2.4393395410402630273e-5+9.6402758819508310554e-1i)+(num-test (tan 9.42443269378637893396e+00-2.0e+00i) -2.4393395410402630273e-5-9.6402758819508310554e-1i)+(num-test (tan -9.42443269378637893396e+00+2.0e+00i) 2.4393395410402630273e-5+9.6402758819508310554e-1i)+(num-test (tan -9.42443269378637893396e+00-2.0e+00i) 2.4393395410402630273e-5-9.6402758819508310554e-1i)+(num-test (tan 9.42512322775237976202e+00+0.0e+00i) 3.4526699671972453911e-4+0.0i)+(num-test (tan -9.42512322775237976202e+00+0.0e+00i) -3.4526699671972453911e-4+0.0i)+(num-test (tan 9.42512322775237976202e+00+1.19209289550781250e-07i) 3.4526699671971963257e-4+1.1920930376163652979e-7i)+(num-test (tan 9.42512322775237976202e+00-1.19209289550781250e-07i) 3.4526699671971963257e-4-1.1920930376163652979e-7i)+(num-test (tan -9.42512322775237976202e+00+1.19209289550781250e-07i) -3.4526699671971963257e-4+1.1920930376163652979e-7i)+(num-test (tan -9.42512322775237976202e+00-1.19209289550781250e-07i) -3.4526699671971963257e-4-1.1920930376163652979e-7i)+(num-test (tan 9.42512322775237976202e+00+5.0e-01i) 2.7153443992561644811e-4+4.6211720058436229949e-1i)+(num-test (tan 9.42512322775237976202e+00-5.0e-01i) 2.7153443992561644811e-4-4.6211720058436229949e-1i)+(num-test (tan -9.42512322775237976202e+00+5.0e-01i) -2.7153443992561644811e-4+4.6211720058436229949e-1i)+(num-test (tan -9.42512322775237976202e+00-5.0e-01i) -2.7153443992561644811e-4-4.6211720058436229949e-1i)+(num-test (tan 9.42512322775237976202e+00+1.0e+00i) 1.450032696022467750e-4+7.6159419408485704810e-1i)+(num-test (tan 9.42512322775237976202e+00-1.0e+00i) 1.450032696022467750e-4-7.6159419408485704810e-1i)+(num-test (tan -9.42512322775237976202e+00+1.0e+00i) -1.450032696022467750e-4+7.6159419408485704810e-1i)+(num-test (tan -9.42512322775237976202e+00-1.0e+00i) -1.450032696022467750e-4-7.6159419408485704810e-1i)+(num-test (tan 9.42512322775237976202e+00+2.0e+00i) 2.439339541035071690e-5+9.6402758819508310550e-1i)+(num-test (tan 9.42512322775237976202e+00-2.0e+00i) 2.439339541035071690e-5-9.6402758819508310550e-1i)+(num-test (tan -9.42512322775237976202e+00+2.0e+00i) -2.439339541035071690e-5+9.6402758819508310550e-1i)+(num-test (tan -9.42512322775237976202e+00-2.0e+00i) -2.439339541035071690e-5-9.6402758819508310550e-1i)+++;; -------- asin+(num-test (asin 0) 0.0)+(num-test (asin 1) 1.57079632679490)+(num-test (asin -1) -1.57079632679490)+(num-test (asin 2) 1.57079632679490+1.31695789692482i)+(num-test (asin -2) -1.57079632679490+1.31695789692482i)+(num-test (asin 3) 1.57079632679490+1.76274717403909i)+(num-test (asin -3) -1.57079632679490+1.76274717403909i)+(num-test (asin 10) 1.57079632679490+2.99322284612638i)+(num-test (asin -10) -1.57079632679490+2.99322284612638i)+(num-test (asin 1234) 1.57079632679490+7.81116322068415i)+(num-test (asin -1234) -1.57079632679490+7.81116322068415i)+(num-test (asin 0/1) 0.0)+(num-test (asin 0/2) 0.0)+(num-test (asin 0/3) 0.0)+(num-test (asin 0/10) 0.0)+(num-test (asin 0/1234) 0.0)+(num-test (asin 0/1234000000) 0.0)+(num-test (asin 0/500029) 0.0)+(num-test (asin 0/362880) 0.0)+(num-test (asin 1/1) 1.57079632679490)+(num-test (asin -1/1) -1.57079632679490)+(num-test (asin 1/2) 0.52359877559830)+(num-test (asin -1/2) -0.52359877559830)+(num-test (asin 1/3) 0.33983690945412)+(num-test (asin -1/3) -0.33983690945412)+(num-test (asin 1/10) 0.10016742116156)+(num-test (asin -1/10) -0.10016742116156)+(num-test (asin 1/1234) 0.00081037286017)+(num-test (asin -1/1234) -0.00081037286017)+(num-test (asin 1/1234000000) 0.00000000081037)+(num-test (asin -1/1234000000) -0.00000000081037)+(num-test (asin 1/500029) 0.00000199988401)+(num-test (asin -1/500029) -0.00000199988401)+(num-test (asin 1/362880) 0.00000275573192)+(num-test (asin -1/362880) -0.00000275573192)+(num-test (asin 2/1) 1.57079632679490+1.31695789692482i)+(num-test (asin -2/1) -1.57079632679490+1.31695789692482i)+(num-test (asin 2/2) 1.57079632679490)+(num-test (asin -2/2) -1.57079632679490)+(num-test (asin 2/3) 0.72972765622697)+(num-test (asin -2/3) -0.72972765622697)+(num-test (asin 2/10) 0.20135792079033)+(num-test (asin -2/10) -0.20135792079033)+(num-test (asin 2/1234) 0.00162074625252)+(num-test (asin -2/1234) -0.00162074625252)+(num-test (asin 2/1234000000) 0.00000000162075)+(num-test (asin -2/1234000000) -0.00000000162075)+(num-test (asin 2/500029) 0.00000399976801)+(num-test (asin -2/500029) -0.00000399976801)+(num-test (asin 2/362880) 0.00000551146384)+(num-test (asin -2/362880) -0.00000551146384)+(num-test (asin 3/1) 1.57079632679490+1.76274717403909i)+(num-test (asin -3/1) -1.57079632679490+1.76274717403909i)+(num-test (asin 3/2) 1.57079632679490+0.96242365011921i)+(num-test (asin -3/2) -1.57079632679490+0.96242365011921i)+(num-test (asin 3/3) 1.57079632679490)+(num-test (asin -3/3) -1.57079632679490)+(num-test (asin 3/10) 0.30469265401540)+(num-test (asin -3/10) -0.30469265401540)+(num-test (asin 3/1234) 0.00243112070922)+(num-test (asin -3/1234) -0.00243112070922)+(num-test (asin 3/1234000000) 0.00000000243112)+(num-test (asin -3/1234000000) -0.00000000243112)+(num-test (asin 3/500029) 0.00000599965202)+(num-test (asin -3/500029) -0.00000599965202)+(num-test (asin 3/362880) 0.00000826719577+0.0i)+(num-test (asin -3/362880) -0.00000826719577+0.0i)+(num-test (asin 10/1) 1.57079632679490+2.99322284612638i)+(num-test (asin -10/1) -1.57079632679490+2.99322284612638i)+(num-test (asin 10/2) 1.57079632679490+2.29243166956117i)+(num-test (asin -10/2) -1.57079632679490+2.29243166956117i)+(num-test (asin 10/3) 1.57079632679490+1.87382024252741i)+(num-test (asin -10/3) -1.57079632679490+1.87382024252741i)+(num-test (asin 10/10) 1.57079632679490)+(num-test (asin -10/10) -1.57079632679490)+(num-test (asin 10/1234) 0.00810381641321)+(num-test (asin -10/1234) -0.00810381641321)+(num-test (asin 10/1234000000) 0.00000000810373)+(num-test (asin -10/1234000000) -0.00000000810373)+(num-test (asin 10/500029) 0.00001999884007)+(num-test (asin -10/500029) -0.00001999884007)+(num-test (asin 10/362880) 0.00002755731923)+(num-test (asin -10/362880) -0.00002755731923)+(num-test (asin 1234/1) 1.57079632679490+7.81116322068415i)+(num-test (asin -1234/1) -1.57079632679490+7.81116322068415i)+(num-test (asin 1234/2) 1.57079632679490+7.11801554770806i)+(num-test (asin -1234/2) -1.57079632679490+7.11801554770806i)+(num-test (asin 1234/3) 1.57079632679490+6.71254961876657i)+(num-test (asin -1234/3) -1.57079632679490+6.71254961876657i)+(num-test (asin 1234/10) 1.57079632679490+5.50856187402751i)+(num-test (asin -1234/10) -1.57079632679490+5.50856187402751i)+(num-test (asin 1234/1234) 1.57079632679490)+(num-test (asin -1234/1234) -1.57079632679490)+(num-test (asin 1234/1234000000) 0.00000100000000)+(num-test (asin -1234/1234000000) -0.00000100000000)+(num-test (asin 1234/500029) 0.00246785936931)+(num-test (asin -1234/500029) -0.00246785936931)+(num-test (asin 1234/362880) 0.00340057974625)+(num-test (asin -1234/362880) -0.00340057974625)+(num-test (asin 1234000000/1234000000) 1.57079632679490)+(num-test (asin -1234000000/1234000000) -1.57079632679490)+(num-test (asin 1234000000/500029) 1.57079632679490+8.50425252675189i)+(num-test (asin -1234000000/500029) -1.57079632679490+8.50425252675189i)+(num-test (asin 1234000000/362880) 1.57079632679490+8.82484644053502i)+(num-test (asin -1234000000/362880) -1.57079632679490+8.82484644053502i)+(num-test (asin 500029/3) 1.570796326794897-12.71695626760523i)+(num-test (asin -500029/3) -1.570796326794897+12.71695626760523i)+(num-test (asin 500029/10) 1.570796326794897-1.151298346318831e1i)+(num-test (asin -500029/10) -1.57079632679490+1.151298346318831e1i)+(num-test (asin 500029/1234) 1.57079632679490+6.69755082925184i)+(num-test (asin -500029/1234) -1.57079632679490+6.69755082925184i)+(num-test (asin 500029/1234000000) 0.00040520989764)+(num-test (asin -500029/1234000000) -0.00040520989764)+(num-test (asin 500029/500029) 1.57079632679490)+(num-test (asin -500029/500029) -1.57079632679490)+(num-test (asin 500029/362880) 1.57079632679490+0.84413377868249i)+(num-test (asin -500029/362880) -1.57079632679490+0.84413377868249i)+(num-test (asin 362880/2) 1.570796326794896619231321691639751442098E0-1.280182748007387555277950474671339683536E1i)+(num-test (asin -362880/2) -1.570796326794897+12.80182748007388i)+(num-test (asin 362880/3) 1.570796326794896619231321691639751442098E0-1.239636237195621859776598192721440899765E1i)+(num-test (asin -362880/3) -1.570796326794897+12.39636237195622i)+(num-test (asin 362880/10) 1.570796326794897-1.119238956745752e1i)+(num-test (asin -362880/10) -1.57079632679490+1.119238956745752e1i)+(num-test (asin 362880/1234) 1.57079632679490+6.37695556516894i)+(num-test (asin -362880/1234) -1.57079632679490+6.37695556516894i)+(num-test (asin 362880/1234000000) 0.00029406807555)+(num-test (asin -362880/1234000000) -0.00029406807555)+(num-test (asin 362880/500029) 0.81207730383580)+(num-test (asin -362880/500029) -0.81207730383580)+(num-test (asin 362880/362880) 1.57079632679490)+(num-test (asin -362880/362880) -1.57079632679490)+(num-test (asin 0.0) 0.0)+(num-test (asin 0.00000001) 0.00000001)+(num-test (asin -0.00000001) -0.00000001)+(num-test (asin 1.0) 1.57079632679490)+(num-test (asin -1.0) -1.57079632679490)+(num-test (asin our-pi) 1.57079632679490+1.81152627246085i)+(num-test (asin -3.14159265358979) -1.57079632679490+1.81152627246085i)+(num-test (asin 2.71828182845905) 1.57079632679490+1.65745445415308i)+(num-test (asin -2.71828182845905) -1.57079632679490+1.65745445415308i)+(num-test (asin 1234.0) 1.57079632679490+7.81116322068415i)+(num-test (asin -1234.0) -1.57079632679490+7.81116322068415i)+(num-test (asin 0.0+0.0i) 0.0)+(num-test (asin -0.0+0.0i) 0.0)+(num-test (asin 0.0-0.0i) 0.0)+(num-test (asin -0.0-0.0i) -0.0)+(num-test (asin 0.0+0.00000001i) 0.0+0.00000001i)+(num-test (asin -0.0+0.00000001i) 0.0+0.00000001i)+(num-test (asin 0.0-0.00000001i) 0.0-0.00000001i)+(num-test (asin -0.0-0.00000001i) -0.0-0.00000001i)+(num-test (asin 0.0+1.0i) 0.0+0.88137358701954i)+(num-test (asin -0.0+1.0i) 0.0+0.88137358701954i)+(num-test (asin 0.0-1.0i) 0.0-0.88137358701954i)+(num-test (asin -0.0-1.0i) -0.0-0.88137358701954i)+(num-test (asin 0.0+3.14159265358979i) 0.0+1.86229574331085i)+(num-test (asin -0.0+3.14159265358979i) 0.0+1.86229574331085i)+(num-test (asin 0.0-3.14159265358979i) 0.0-1.86229574331085i)+(num-test (asin -0.0-3.14159265358979i) -0.0-1.86229574331085i)+(num-test (asin 0.0+2.71828182845905i) 0.0+1.72538255885232i)+(num-test (asin -0.0+2.71828182845905i) 0.0+1.72538255885232i)+(num-test (asin 0.0-2.71828182845905i) 0.0-1.72538255885231i)+(num-test (asin -0.0-2.71828182845905i) -0.0-1.72538255885231i)+(num-test (asin 0.0+1234.0i) 0.0+7.81116354896171i)+(num-test (asin -0.0+1234.0i) 0.0+7.81116354896171i)+(num-test (asin 0.0-1234.0i) 0.0-7.81116354920125i)+(num-test (asin -0.0-1234.0i) -0.0-7.81116354920125i)+(num-test (asin 0.0-1234000000.0i) 0.0-21.62667394298955i)+(num-test (asin -0.0-1234000000.0i) -0.0-21.62667394298955i)+(num-test (asin 0.00000001+0.0i) 0.00000001)+(num-test (asin -0.00000001+0.0i) -0.00000001)+(num-test (asin 0.00000001-0.0i) 0.00000001)+(num-test (asin -0.00000001-0.0i) -0.00000001)+(num-test (asin 0.00000001+0.00000001i) 0.00000001+0.00000001i)+(num-test (asin -0.00000001+0.00000001i) -0.00000001+0.00000001i)+(num-test (asin 0.00000001-0.00000001i) 0.00000001-0.00000001i)+(num-test (asin -0.00000001-0.00000001i) -0.00000001-0.00000001i)+(num-test (asin 0.00000001+1.0i) 0.00000000707107+0.88137358701954i)+(num-test (asin -0.00000001+1.0i) -0.00000000707107+0.88137358701954i)+(num-test (asin 0.00000001-1.0i) 0.00000000707107-0.88137358701954i)+(num-test (asin -0.00000001-1.0i) -0.00000000707107-0.88137358701954i)+(num-test (asin 0.00000001+3.14159265358979i) 0.00000000303314+1.86229574331085i)+(num-test (asin -0.00000001+3.14159265358979i) -0.00000000303314+1.86229574331085i)+(num-test (asin 0.00000001-3.14159265358979i) 0.00000000303314-1.86229574331085i)+(num-test (asin -0.00000001-3.14159265358979i) -0.00000000303314-1.86229574331085i)+(num-test (asin 0.00000001+2.71828182845905i) 0.00000000345258+1.72538255885232i)+(num-test (asin -0.00000001+2.71828182845905i) -0.00000000345258+1.72538255885232i)+(num-test (asin 0.00000001-2.71828182845905i) 0.00000000345258-1.72538255885231i)+(num-test (asin -0.00000001-2.71828182845905i) -0.00000000345258-1.72538255885231i)+(num-test (asin 0.00000001+1234.0i) 0.00000000000810+7.81116354896171i)+(num-test (asin -0.00000001+1234.0i) -0.00000000000810+7.81116354896171i)+(num-test (asin 0.00000001-1234.0i) 0.00000000000810-7.81116354920125i)+(num-test (asin -0.00000001-1234.0i) -0.00000000000810-7.81116354920125i)+(num-test (asin 0.00000001-1234000000.0i) 0.0-21.62667394298955i)+(num-test (asin -0.00000001-1234000000.0i) -0.0-21.62667394298955i)+(num-test (asin 1.0+0.0i) 1.57079632679490)+(num-test (asin -1.0+0.0i) -1.57079632679490)+(num-test (asin 1.0-0.0i) 1.57079632679490)+(num-test (asin -1.0-0.0i) -1.57079632679490)+(num-test (asin 1.0+0.00000001i) 1.57069632679498+0.00010000000008i)+(num-test (asin -1.0+0.00000001i) -1.57069632679498+0.00010000000008i)+(num-test (asin 1.0-0.00000001i) 1.57069632679498-0.00010000000008i)+(num-test (asin -1.0-0.00000001i) -1.57069632679498-0.00010000000008i)+(num-test (asin 1.0+1.0i) 0.66623943249252+1.06127506190504i)+(num-test (asin -1.0+1.0i) -0.66623943249252+1.06127506190504i)+(num-test (asin 1.0-1.0i) 0.66623943249252-1.06127506190504i)+(num-test (asin -1.0-1.0i) -0.66623943249252-1.06127506190504i)+(num-test (asin 1.0+3.14159265358979i) 0.29558503421163+1.90462768697066i)+(num-test (asin -1.0+3.14159265358979i) -0.29558503421163+1.90462768697066i)+(num-test (asin 1.0-3.14159265358979i) 0.29558503421163-1.90462768697066i)+(num-test (asin -1.0-3.14159265358979i) -0.29558503421163-1.90462768697066i)+(num-test (asin 1.0+2.71828182845905i) 0.33444277187637+1.77905438385935i)+(num-test (asin -1.0+2.71828182845905i) -0.33444277187637+1.77905438385935i)+(num-test (asin 1.0-2.71828182845905i) 0.33444277187637-1.77905438385935i)+(num-test (asin -1.0-2.71828182845905i) -0.33444277187637-1.77905438385935i)+(num-test (asin 1.0+1234.0i) 0.00081037232806+7.81116387772663i)+(num-test (asin -1.0+1234.0i) -0.00081037232806+7.81116387772663i)+(num-test (asin 1.0-1234.0i) 0.00081037232800-7.81116387755283i)+(num-test (asin -1.0-1234.0i) -0.00081037232800-7.81116387755283i)+(num-test (asin 1.0-1234000000.0i) 0.00000000081037-21.62667394298955i)+(num-test (asin -1.0-1234000000.0i) -0.00000000081037-21.62667394298955i)+(num-test (asin 3.14159265358979+0.0i) 1.57079632679490+1.81152627246085i)+(num-test (asin -3.14159265358979+0.0i) -1.57079632679490+1.81152627246085i)+(num-test (asin 3.14159265358979-0.0i) 1.57079632679490+1.81152627246085i)+(num-test (asin -3.14159265358979-0.0i) -1.57079632679490+1.81152627246085i)+(num-test (asin 3.14159265358979+0.00000001i) 1.57079632343715+1.81152627246085i)+(num-test (asin -3.14159265358979+0.00000001i) -1.57079632343715+1.81152627246085i)+(num-test (asin 3.14159265358979-0.00000001i) 1.57079632343715-1.81152627246085i)+(num-test (asin -3.14159265358979-0.00000001i) -1.57079632343715-1.81152627246085i)+(num-test (asin 3.14159265358979+1.0i) 1.24854303281344+1.86711439316026i)+(num-test (asin -3.14159265358979+1.0i) -1.24854303281344+1.86711439316026i)+(num-test (asin 3.14159265358979-1.0i) 1.24854303281344-1.86711439316026i)+(num-test (asin -3.14159265358979-1.0i) -1.24854303281344-1.86711439316026i)+(num-test (asin 3.14159265358979+3.14159265358979i) 0.77273977912748+2.18469104082751i)+(num-test (asin -3.14159265358979+3.14159265358979i) -0.77273977912748+2.18469104082751i)+(num-test (asin 3.14159265358979-3.14159265358979i) 0.77273977912748-2.18469104082751i)+(num-test (asin -3.14159265358979-3.14159265358979i) -0.77273977912748-2.18469104082751i)+(num-test (asin 3.14159265358979+2.71828182845905i) 0.84309656416035+2.11552790803290i)+(num-test (asin -3.14159265358979+2.71828182845905i) -0.84309656416035+2.11552790803290i)+(num-test (asin 3.14159265358979-2.71828182845905i) 0.84309656416035-2.11552790803290i)+(num-test (asin -3.14159265358979-2.71828182845905i) -0.84309656416035-2.11552790803290i)+(num-test (asin 3.14159265358979+1234.0i) 0.00254585480900+7.81116678966949i)+(num-test (asin -3.14159265358979+1234.0i) -0.00254585480900+7.81116678966949i)+(num-test (asin 3.14159265358979-1234.0i) 0.00254585480937-7.81116678989204i)+(num-test (asin -3.14159265358979-1234.0i) -0.00254585480937-7.81116678989204i)+(num-test (asin 3.14159265358979-1234000000.0i) 0.00000000254586-21.62667394298955i)+(num-test (asin -3.14159265358979-1234000000.0i) -0.00000000254586-21.62667394298955i)+(num-test (asin 2.71828182845905+0.0i) 1.57079632679490+1.65745445415308i)+(num-test (asin -2.71828182845905+0.0i) -1.57079632679490+1.65745445415308i)+(num-test (asin 2.71828182845905-0.0i) 1.57079632679490+1.65745445415308i)+(num-test (asin -2.71828182845905-0.0i) -1.57079632679490+1.65745445415308i)+(num-test (asin 2.71828182845905+0.00000001i) 1.57079632283867+1.65745445415308i)+(num-test (asin -2.71828182845905+0.00000001i) -1.57079632283867+1.65745445415308i)+(num-test (asin 2.71828182845905-0.00000001i) 1.57079632283867-1.65745445415308i)+(num-test (asin -2.71828182845905-0.00000001i) -1.57079632283867-1.65745445415308i)+(num-test (asin 2.71828182845905+1.0i) 1.19757808518581+1.73375471569385i)+(num-test (asin -2.71828182845905+1.0i) -1.19757808518581+1.73375471569385i)+(num-test (asin 2.71828182845905-1.0i) 1.19757808518581-1.73375471569385i)+(num-test (asin -2.71828182845905-1.0i) -1.19757808518581-1.73375471569385i)+(num-test (asin 2.71828182845905+3.14159265358979i) 0.69904796994656+2.11968336368048i)+(num-test (asin -2.71828182845905+3.14159265358979i) -0.69904796994656+2.11968336368048i)+(num-test (asin 2.71828182845905-3.14159265358979i) 0.69904796994655-2.11968336368048i)+(num-test (asin -2.71828182845905-3.14159265358979i) -0.69904796994655-2.11968336368048i)+(num-test (asin 2.71828182845905+2.71828182845905i) 0.76849735588475+2.04014932880026i)+(num-test (asin -2.71828182845905+2.71828182845905i) -0.76849735588475+2.04014932880026i)+(num-test (asin 2.71828182845905-2.71828182845905i) 0.76849735588475-2.04014932880026i)+(num-test (asin -2.71828182845905-2.71828182845905i) -0.76849735588475-2.04014932880026i)+(num-test (asin 2.71828182845905+1234.0i) 0.00220281729236+7.81116597510553i)+(num-test (asin -2.71828182845905+1234.0i) -0.00220281729236+7.81116597510553i)+(num-test (asin 2.71828182845905-1234.0i) 0.00220281729269-7.81116597540442i)+(num-test (asin -2.71828182845905-1234.0i) -0.00220281729269-7.81116597540442i)+(num-test (asin 2.71828182845905-1234000000.0i) 0.00000000220282-21.62667394298955i)+(num-test (asin -2.71828182845905-1234000000.0i) -0.00000000220282-21.62667394298955i)+(num-test (asin 1234.0+0.0i) 1.57079632679490+7.81116322068415i)+(num-test (asin -1234.0+0.0i) -1.57079632679490+7.81116322068415i)+(num-test (asin 1234.0-0.0i) 1.57079632679490+7.81116322068415i)+(num-test (asin -1234.0-0.0i) -1.57079632679490+7.81116322068415i)+(num-test (asin 1234.0+0.00000001i) 1.57079632678679+7.81116322068415i)+(num-test (asin -1234.0+0.00000001i) -1.57079632678679+7.81116322068415i)+(num-test (asin 1234.0-0.00000001i) 1.57079632678679-7.81116322084923i)+(num-test (asin -1234.0-0.00000001i) -1.57079632678679-7.81116322084923i)+(num-test (asin 1234.0+1.0i) 1.56998595393442+7.81116354944842i)+(num-test (asin -1234.0+1.0i) -1.56998595393442+7.81116354944842i)+(num-test (asin 1234.0-1.0i) 1.56998595393473-7.81116354920146i)+(num-test (asin -1234.0-1.0i) -1.56998595393473-7.81116354920146i)+(num-test (asin 1234.0+3.14159265358979i) 1.56825047031506+7.81116646138554i)+(num-test (asin -1234.0+3.14159265358979i) -1.56825047031506+7.81116646138554i)+(num-test (asin 1234.0-3.14159265358979i) 1.56825047031367-7.81116646154641i)+(num-test (asin -1234.0-3.14159265358979i) -1.56825047031367-7.81116646154641i)+(num-test (asin 1234.0+2.71828182845905i) 1.56859350805543+7.81116564738434i)+(num-test (asin -1234.0+2.71828182845905i) -1.56859350805543+7.81116564738434i)+(num-test (asin 1234.0-2.71828182845905i) 1.56859350805562-7.81116564705719i)+(num-test (asin -1234.0-2.71828182845905i) -1.56859350805562-7.81116564705719i)+(num-test (asin 1234.0+1234.0i) 0.78539808146835+8.15773697538346i)+(num-test (asin -1234.0+1234.0i) -0.78539808146835+8.15773697538346i)+(num-test (asin 1234.0-1234.0i) 0.78539808130944-8.15773697530526i)+(num-test (asin -1234.0-1234.0i) -0.78539808130944-8.15773697530526i)+(num-test (asin 1234.0-1234000000.0i) 0.00000100000000-21.62667394299005i)+(num-test (asin -1234.0-1234000000.0i) -0.00000100000000-21.62667394299005i)+(num-test (asin 1234000000.0-0.00000001i) 1.57079632679490-21.62667394298955i)+(num-test (asin -1234000000.0-0.00000001i) -1.57079632679490-21.62667394298955i)+(num-test (asin 1234000000.0-1.0i) 1.57079632598452-21.62667394298955i)+(num-test (asin -1234000000.0-1.0i) -1.57079632598452-21.62667394298955i)+(num-test (asin 1234000000.0-3.14159265358979i) 1.57079632424904-21.62667394298955i)+(num-test (asin -1234000000.0-3.14159265358979i) -1.57079632424904-21.62667394298955i)+(num-test (asin 1234000000.0-2.71828182845905i) 1.57079632459208-21.62667394298955i)+(num-test (asin -1234000000.0-2.71828182845905i) -1.57079632459208-21.62667394298955i)+(num-test (asin 1234000000.0-1234.0i) 1.57079532679490-21.62667394299005i)+(num-test (asin -1234000000.0-1234.0i) -1.57079532679490-21.62667394299005i)+(num-test (asin 1234000000.0-1234000000.0i) 0.78539816339745-21.97324753326953i)+(num-test (asin -1234000000.0-1234000000.0i) -0.78539816339745-21.97324753326953i)+(num-test (asin 8.2729394e-17) 8.2729394e-17)+(num-test (asin 1.821832e-231) 1.821832e-231)+(num-test (asin 48983.30495194942-64983.97008730317i) 0.6459128607940432-12i)+(num-test (asin 1234000000/3) 1.570796326794897-20.52806165432143i)+(num-test (asin 500029/2) 1.570796326794897-13.12242137571839i)+(num-test (asin 0.00000001+1234000000.0i) +8.103725052149596E-18+21.62667380877375i)+(num-test (asin 3.14159265358979+1234000000.0i) +2.545860611523387E-9+21.62667380877375i)+(num-test (asin 2.71828182845905+1234000000.0i) +2.2028207814967068E-9+21.62667380877375i)+(num-test (asin 1234000000.0+0.00000001i) +1.570796327200083+21.62667394298955i)+(num-test (asin 1234000000.0+3.14159265358979i) +1.570796327200083+21.62667394298955i)+(num-test (asin 0.0e+00+0.0e+00i) 0e0+0.0i)+(num-test (asin 0.0e+00+1.19209289550781250e-07i) 0+1.1920928955078096766e-7i)+(num-test (asin 0.0e+00-1.19209289550781250e-07i) 0-1.1920928955078096766e-7i)+(num-test (asin 0.0e+00+5.0e-01i) 0+4.8121182505960344750e-1i)+(num-test (asin 0.0e+00-5.0e-01i) 0-4.8121182505960344750e-1i)+(num-test (asin 0.0e+00+1.0e+00i) 0+8.8137358701954302523e-1i)+(num-test (asin 0.0e+00-1.0e+00i) 0-8.8137358701954302523e-1i)+(num-test (asin 0.0e+00+2.0e+00i) 0+1.4436354751788103425e0i)+(num-test (asin 0.0e+00-2.0e+00i) 0-1.4436354751788103425e0i)+(num-test (asin 0.0e+00+8.3886080e+06i) 0+1.6635532333438690979e1i)+(num-test (asin 0.0e+00-8.3886080e+06i) 0-1.6635532333438690979e1i)+(num-test (asin 1.19209289550781250e-07+0.0e+00i) 1.1920928955078153234e-7+0.0i)+(num-test (asin -1.19209289550781250e-07+0.0e+00i) -1.1920928955078153234e-7+0.0i)+(num-test (asin 1.19209289550781250e-07+1.19209289550781250e-07i) 1.1920928955078068531e-7+1.1920928955078181469e-7i)+(num-test (asin 1.19209289550781250e-07-1.19209289550781250e-07i) 1.1920928955078068531e-7-1.1920928955078181469e-7i)+(num-test (asin -1.19209289550781250e-07+1.19209289550781250e-07i) -1.1920928955078068531e-7+1.1920928955078181469e-7i)+(num-test (asin -1.19209289550781250e-07-1.19209289550781250e-07i) -1.1920928955078068531e-7-1.1920928955078181469e-7i)+(num-test (asin 1.19209289550781250e-07+5.0e-01i) 1.0662402999400097805e-7+4.8121182505960598961e-1i)+(num-test (asin 1.19209289550781250e-07-5.0e-01i) 1.0662402999400097805e-7-4.8121182505960598961e-1i)+(num-test (asin -1.19209289550781250e-07+5.0e-01i) -1.0662402999400097805e-7+4.8121182505960598961e-1i)+(num-test (asin -1.19209289550781250e-07-5.0e-01i) -1.0662402999400097805e-7-4.8121182505960598961e-1i)+(num-test (asin 1.19209289550781250e-07+1.0e+00i) 8.4293697021788013662e-8+8.8137358701954553738e-1i)+(num-test (asin 1.19209289550781250e-07-1.0e+00i) 8.4293697021788013662e-8-8.8137358701954553738e-1i)+(num-test (asin -1.19209289550781250e-07+1.0e+00i) -8.4293697021788013662e-8+8.8137358701954553738e-1i)+(num-test (asin -1.19209289550781250e-07-1.0e+00i) -8.4293697021788013662e-8-8.8137358701954553738e-1i)+(num-test (asin 1.19209289550781250e-07+2.0e+00i) 5.3312014997000413263e-8+1.4436354751788116136e0i)+(num-test (asin 1.19209289550781250e-07-2.0e+00i) 5.3312014997000413263e-8-1.4436354751788116136e0i)+(num-test (asin -1.19209289550781250e-07+2.0e+00i) -5.3312014997000413263e-8+1.4436354751788116136e0i)+(num-test (asin -1.19209289550781250e-07-2.0e+00i) -5.3312014997000413263e-8-1.4436354751788116136e0i)+(num-test (asin 1.19209289550781250e-07+8.3886080e+06i) 1.4210854715201902743e-14+1.6635532333438690979e1i)+(num-test (asin 1.19209289550781250e-07-8.3886080e+06i) 1.4210854715201902743e-14-1.6635532333438690979e1i)+(num-test (asin -1.19209289550781250e-07+8.3886080e+06i) -1.4210854715201902743e-14+1.6635532333438690979e1i)+(num-test (asin -1.19209289550781250e-07-8.3886080e+06i) -1.4210854715201902743e-14-1.6635532333438690979e1i)+(num-test (asin 5.0e-01+0.0e+00i) 5.2359877559829887308e-1+0.0i)+(num-test (asin -5.0e-01+0.0e+00i) -5.2359877559829887308e-1+0.0i)+(num-test (asin 5.0e-01+1.19209289550781250e-07i) 5.2359877559829340332e-1+1.3765103082409432364e-7i)+(num-test (asin 5.0e-01-1.19209289550781250e-07i) 5.2359877559829340332e-1-1.3765103082409432364e-7i)+(num-test (asin -5.0e-01+1.19209289550781250e-07i) -5.2359877559829340332e-1+1.3765103082409432364e-7i)+(num-test (asin -5.0e-01-1.19209289550781250e-07i) -5.2359877559829340332e-1-1.3765103082409432364e-7i)+(num-test (asin 5.0e-01+5.0e-01i) 4.5227844715119068206e-1+5.3063753095251782602e-1i)+(num-test (asin 5.0e-01-5.0e-01i) 4.5227844715119068206e-1-5.3063753095251782602e-1i)+(num-test (asin -5.0e-01+5.0e-01i) -4.5227844715119068206e-1+5.3063753095251782602e-1i)+(num-test (asin -5.0e-01-5.0e-01i) -4.5227844715119068206e-1-5.3063753095251782602e-1i)+(num-test (asin 5.0e-01+1.0e+00i) 3.4943906285721329363e-1+9.2613303135018242455e-1i)+(num-test (asin 5.0e-01-1.0e+00i) 3.4943906285721329363e-1-9.2613303135018242455e-1i)+(num-test (asin -5.0e-01+1.0e+00i) -3.4943906285721329363e-1+9.2613303135018242455e-1i)+(num-test (asin -5.0e-01-1.0e+00i) -3.4943906285721329363e-1-9.2613303135018242455e-1i)+(num-test (asin 5.0e-01+2.0e+00i) 2.2101863562288385890e-1+1.4657153519472905218e0i)+(num-test (asin 5.0e-01-2.0e+00i) 2.2101863562288385890e-1-1.4657153519472905218e0i)+(num-test (asin -5.0e-01+2.0e+00i) -2.2101863562288385890e-1+1.4657153519472905218e0i)+(num-test (asin -5.0e-01-2.0e+00i) -2.2101863562288385890e-1-1.4657153519472905218e0i)+(num-test (asin 5.0e-01+8.3886080e+06i) 5.9604644775390130897e-8+1.6635532333438692755e1i)+(num-test (asin 5.0e-01-8.3886080e+06i) 5.9604644775390130897e-8-1.6635532333438692755e1i)+(num-test (asin -5.0e-01+8.3886080e+06i) -5.9604644775390130897e-8+1.6635532333438692755e1i)+(num-test (asin -5.0e-01-8.3886080e+06i) -5.9604644775390130897e-8-1.6635532333438692755e1i)+(num-test (asin 1.0e+00+0.0e+00i) 1.5707963267948966192e0+0.0i)+(num-test (asin -1.0e+00+0.0e+00i) -1.5707963267948966192e0+0.0i)+(num-test (asin 1.0e+00+1.19209289550781250e-07i) 1.5704510598153252947e0+3.4526698643116312881e-4i)+(num-test (asin 1.0e+00-1.19209289550781250e-07i) 1.5704510598153252947e0-3.4526698643116312881e-4i)+(num-test (asin -1.0e+00+1.19209289550781250e-07i) -1.5704510598153252947e0+3.4526698643116312881e-4i)+(num-test (asin -1.0e+00-1.19209289550781250e-07i) -1.5704510598153252947e0-3.4526698643116312881e-4i)+(num-test (asin 1.0e+00+5.0e-01i) 8.9590748120889023907e-1+7.3285767597364526089e-1i)+(num-test (asin 1.0e+00-5.0e-01i) 8.9590748120889023907e-1-7.3285767597364526089e-1i)+(num-test (asin -1.0e+00+5.0e-01i) -8.9590748120889023907e-1+7.3285767597364526089e-1i)+(num-test (asin -1.0e+00-5.0e-01i) -8.9590748120889023907e-1-7.3285767597364526089e-1i)+(num-test (asin 1.0e+00+1.0e+00i) 6.6623943249251525510e-1+1.0612750619050356520e0i)+(num-test (asin 1.0e+00-1.0e+00i) 6.6623943249251525510e-1-1.0612750619050356520e0i)+(num-test (asin -1.0e+00+1.0e+00i) -6.6623943249251525510e-1+1.0612750619050356520e0i)+(num-test (asin -1.0e+00-1.0e+00i) -6.6623943249251525510e-1-1.0612750619050356520e0i)+(num-test (asin 1.0e+00+2.0e+00i) 4.2707858639247612548e-1+1.5285709194809981613e0i)+(num-test (asin 1.0e+00-2.0e+00i) 4.2707858639247612548e-1-1.5285709194809981613e0i)+(num-test (asin -1.0e+00+2.0e+00i) -4.2707858639247612548e-1+1.5285709194809981613e0i)+(num-test (asin -1.0e+00-2.0e+00i) -4.2707858639247612548e-1-1.5285709194809981613e0i)+(num-test (asin 1.0e+00+8.3886080e+06i) 1.1920928955077983828e-7+1.6635532333438698084e1i)+(num-test (asin 1.0e+00-8.3886080e+06i) 1.1920928955077983828e-7-1.6635532333438698084e1i)+(num-test (asin -1.0e+00+8.3886080e+06i) -1.1920928955077983828e-7+1.6635532333438698084e1i)+(num-test (asin -1.0e+00-8.3886080e+06i) -1.1920928955077983828e-7-1.6635532333438698084e1i)+(num-test (asin 2.0e+00+0.0e+00i) 1.5707963267948966192e0-1.3169578969248167086e0i)+(num-test (asin -2.0e+00+0.0e+00i) -1.5707963267948966192e0+1.3169578969248167086e0i)+(num-test (asin 2.0e+00+1.19209289550781250e-07i) 1.5707962579693812072e0+1.3169578969248194435e0i)+(num-test (asin 2.0e+00-1.19209289550781250e-07i) 1.5707962579693812072e0-1.3169578969248194435e0i)+(num-test (asin -2.0e+00+1.19209289550781250e-07i) -1.5707962579693812072e0+1.3169578969248194435e0i)+(num-test (asin -2.0e+00-1.19209289550781250e-07i) -1.5707962579693812072e0-1.3169578969248194435e0i)+(num-test (asin 2.0e+00+5.0e-01i) 1.2930420702371826591e0+1.3618009008578457882e0i)+(num-test (asin 2.0e+00-5.0e-01i) 1.2930420702371826591e0-1.3618009008578457882e0i)+(num-test (asin -2.0e+00+5.0e-01i) -1.2930420702371826591e0+1.3618009008578457882e0i)+(num-test (asin -2.0e+00-5.0e-01i) -1.2930420702371826591e0-1.3618009008578457882e0i)+(num-test (asin 2.0e+00+1.0e+00i) 1.0634400235777520562e0+1.4693517443681852733e0i)+(num-test (asin 2.0e+00-1.0e+00i) 1.0634400235777520562e0-1.4693517443681852733e0i)+(num-test (asin -2.0e+00+1.0e+00i) -1.0634400235777520562e0+1.4693517443681852733e0i)+(num-test (asin -2.0e+00-1.0e+00i) -1.0634400235777520562e0-1.4693517443681852733e0i)+(num-test (asin 2.0e+00+2.0e+00i) 7.5424914469804604071e-1+1.7343245214879664480e0i)+(num-test (asin 2.0e+00-2.0e+00i) 7.5424914469804604071e-1-1.7343245214879664480e0i)+(num-test (asin -2.0e+00+2.0e+00i) -7.5424914469804604071e-1+1.7343245214879664480e0i)+(num-test (asin -2.0e+00-2.0e+00i) -7.5424914469804604071e-1-1.7343245214879664480e0i)+(num-test (asin 2.0e+00+8.3886080e+06i) 2.3841857910155628843e-7+1.663553233343871940e1i)+(num-test (asin 2.0e+00-8.3886080e+06i) 2.3841857910155628843e-7-1.663553233343871940e1i)+(num-test (asin -2.0e+00+8.3886080e+06i) -2.3841857910155628843e-7+1.663553233343871940e1i)+(num-test (asin -2.0e+00-8.3886080e+06i) -2.3841857910155628843e-7-1.663553233343871940e1i)+(num-test (asin 8.3886080e+06+0.0e+00i) 1.5707963267948966192e0-1.6635532333438683873e1i)+(num-test (asin -8.3886080e+06+0.0e+00i) -1.5707963267948966192e0+1.6635532333438683873e1i)+(num-test (asin 8.3886080e+06+1.19209289550781250e-07i) 1.5707963267948824084e0+1.6635532333438683873e1i)+(num-test (asin 8.3886080e+06-1.19209289550781250e-07i) 1.5707963267948824084e0-1.6635532333438683873e1i)+(num-test (asin -8.3886080e+06+1.19209289550781250e-07i) -1.5707963267948824084e0+1.6635532333438683873e1i)+(num-test (asin -8.3886080e+06-1.19209289550781250e-07i) -1.5707963267948824084e0-1.6635532333438683873e1i)+(num-test (asin 8.3886080e+06+5.0e-01i) 1.5707962671902518438e0+1.6635532333438685650e1i)+(num-test (asin 8.3886080e+06-5.0e-01i) 1.5707962671902518438e0-1.6635532333438685650e1i)+(num-test (asin -8.3886080e+06+5.0e-01i) -1.5707962671902518438e0+1.6635532333438685650e1i)+(num-test (asin -8.3886080e+06-5.0e-01i) -1.5707962671902518438e0-1.6635532333438685650e1i)+(num-test (asin 8.3886080e+06+1.0e+00i) 1.5707962075856070684e0+1.6635532333438690979e1i)+(num-test (asin 8.3886080e+06-1.0e+00i) 1.5707962075856070684e0-1.6635532333438690979e1i)+(num-test (asin -8.3886080e+06+1.0e+00i) -1.5707962075856070684e0+1.6635532333438690979e1i)+(num-test (asin -8.3886080e+06-1.0e+00i) -1.5707962075856070684e0-1.6635532333438690979e1i)+(num-test (asin 8.3886080e+06+2.0e+00i) 1.5707960883763175177e0+1.6635532333438712295e1i)+(num-test (asin 8.3886080e+06-2.0e+00i) 1.5707960883763175177e0-1.6635532333438712295e1i)+(num-test (asin -8.3886080e+06+2.0e+00i) -1.5707960883763175177e0+1.6635532333438712295e1i)+(num-test (asin -8.3886080e+06-2.0e+00i) -1.5707960883763175177e0-1.6635532333438712295e1i)+(num-test (asin 8.3886080e+06+8.3886080e+06i) 7.8539816339744653326e-1+1.6982105923718660081e1i)+(num-test (asin 8.3886080e+06-8.3886080e+06i) 7.8539816339744653326e-1-1.6982105923718660081e1i)+(num-test (asin -8.3886080e+06+8.3886080e+06i) -7.8539816339744653326e-1+1.6982105923718660081e1i)+(num-test (asin -8.3886080e+06-8.3886080e+06i) -7.8539816339744653326e-1-1.6982105923718660081e1i)+(num-test (asin -1.0e+01) -1.5707963267948966192e0+2.9932228461263808979e0i)+(num-test (asin -2.0e+00) -1.5707963267948966192e0+1.3169578969248167086e0i)+(num-test (asin -1.0e+00) -1.5707963267948966192e0+0.0i)+(num-test (asin -7.50e-01) -8.4806207898148100805e-1+0.0i)+(num-test (asin -5.0e-01) -5.2359877559829887308e-1+0.0i)+(num-test (asin -1.250e-01) -1.2532783116806539687e-1+0.0i)+(num-test (asin -3.45266983001243932001e-04) -3.4526698986108292481e-4+0.0i)+(num-test (asin -1.19209289550781250e-07) -1.1920928955078153234e-7+0.0i)+(num-test (asin 0.0e+00) 0e0+0.0i)+(num-test (asin 1.19209289550781250e-07) 1.1920928955078153234e-7+0.0i)+(num-test (asin 3.45266983001243932001e-04) 3.4526698986108292481e-4+0.0i)+(num-test (asin 1.250e-01) 1.2532783116806539687e-1+0.0i)+(num-test (asin 5.0e-01) 5.2359877559829887308e-1+0.0i)+(num-test (asin 7.50e-01) 8.4806207898148100805e-1+0.0i)+(num-test (asin 1.0e+00) 1.5707963267948966192e0+0.0i)+(num-test (asin 2.0e+00) 1.5707963267948966192e0-1.3169578969248167086e0i)+(num-test (asin 1.0e+01) 1.5707963267948966192e0-2.9932228461263808979e0i)+(num-test (asin 0) 0.0)+(num-test (asin 2) 1.570796326794897-1.316957896924817i)+(num-test (asin 3.0+70000000i) 4.2857142400327436E-8+18.7571529895002i)+(num-test (asin 70000000+3i) 1.570796279536826+18.75715298057358i)+(num-test (asin 3.0-70000000i) 4.2857142400327436E-8-18.7571529895002i)+(num-test (asin -70000000+3i) -1.570796279536826+18.75715298057358i)++(let ((err 0.0))+  (do ((i 0 (+ i 1))+       (x -10.0 (+ x .1)))+      ((= i 200))+    (let ((y (magnitude (- x (sin (asin x))))))+      (if (> y err) (set! err y))))+  (if (> err 1e-12)+      (begin (display "(sin (asin ...)) error: ") (display err) (newline))))++(let ((err 0.0))+  (do ((i 0 (+ i 1))+       (x 1.0-i (+ x -.1+i)))+      ((= i 100))+    (let ((y (magnitude (- x (sin (asin x))))))+      (if (> y err) (set! err y))))+  (if (> err 1e-9)+      (begin (display "(sin (asin [complex] ...)) error: ") (display err) (newline))))++++;; -------- acos+(num-test (acos 0) 1.57079632679490)+(num-test (acos 1) 0.0)+(num-test (acos -1) our-pi)+(num-test (acos 2) 0.0-1.31695789692482i)+(num-test (acos -2) 3.14159265358979-1.31695789692482i)+(num-test (acos 3) 0.0-1.76274717403909i)+(num-test (acos -3) 3.14159265358979-1.76274717403909i)+(num-test (acos 10) 0.0-2.99322284612638i)+(num-test (acos -10) 3.14159265358979-2.99322284612638i)+(num-test (acos 1234) 0.0-7.81116322068415i)+(num-test (acos -1234) 3.14159265358979-7.81116322068415i)+(num-test (acos 0/1) 1.57079632679490)+(num-test (acos 0/2) 1.57079632679490)+(num-test (acos 0/3) 1.57079632679490)+(num-test (acos 0/10) 1.57079632679490)+(num-test (acos 0/1234) 1.57079632679490)+(num-test (acos 0/1234000000) 1.57079632679490)+(num-test (acos 0/500029) 1.57079632679490)+(num-test (acos 0/362880) 1.57079632679490)+(num-test (acos 1/1) 0.0)+(num-test (acos -1/1) our-pi)+(num-test (acos 1/2) 1.04719755119660)+(num-test (acos -1/2) 2.09439510239320)+(num-test (acos 1/3) 1.23095941734077)+(num-test (acos -1/3) 1.91063323624902)+(num-test (acos 1/10) 1.47062890563334)+(num-test (acos -1/10) 1.67096374795646)+(num-test (acos 1/1234) 1.56998595393473)+(num-test (acos -1/1234) 1.57160669965507)+(num-test (acos 1/1234000000) 1.57079632598452)+(num-test (acos -1/1234000000) 1.57079632760527)+(num-test (acos 1/500029) 1.57079432691089)+(num-test (acos -1/500029) 1.57079832667890)+(num-test (acos 1/362880) 1.57079357106297)+(num-test (acos -1/362880) 1.57079908252682)+(num-test (acos 2/1) 0.0-1.31695789692482i)+(num-test (acos -2/1) 3.14159265358979-1.31695789692482i)+(num-test (acos 2/2) 0.0)+(num-test (acos -2/2) our-pi)+(num-test (acos 2/3) 0.84106867056793)+(num-test (acos -2/3) 2.30052398302186)+(num-test (acos 2/10) 1.36943840600457)+(num-test (acos -2/10) 1.77215424758523)+(num-test (acos 2/1234) 1.56917558054238)+(num-test (acos -2/1234) 1.57241707304741)+(num-test (acos 2/1234000000) 1.57079632517415)+(num-test (acos -2/1234000000) 1.57079632841564)+(num-test (acos 2/500029) 1.57079232702688)+(num-test (acos -2/500029) 1.57080032656291)+(num-test (acos 2/362880) 1.57079081533105)+(num-test (acos -2/362880) 1.57080183825874)+(num-test (acos 3/1) 0.0-1.76274717403909i)+(num-test (acos -3/1) 3.14159265358979-1.76274717403909i)+(num-test (acos 3/2) 0.0-0.96242365011921i)+(num-test (acos -3/2) 3.14159265358979-0.96242365011921i)+(num-test (acos 3/3) 0.0)+(num-test (acos -3/3) our-pi)+(num-test (acos 3/10) 1.26610367277950)+(num-test (acos -3/10) 1.87548898081029)+(num-test (acos 3/1234) 1.56836520608568)+(num-test (acos -3/1234) 1.57322744750412)+(num-test (acos 3/1234000000) 1.57079632436378)+(num-test (acos -3/1234000000) 1.57079632922601)+(num-test (acos 3/500029) 1.57079032714288)+(num-test (acos -3/500029) 1.57080232644692)+(num-test (acos 3/362880) 1.57078805959913-0.0i)+(num-test (acos -3/362880) 1.57080459399066-0.0i)+(num-test (acos 10/1) 0.0-2.99322284612638i)+(num-test (acos -10/1) 3.14159265358979-2.99322284612638i)+(num-test (acos 10/2) 0.0-2.29243166956117i)+(num-test (acos -10/2) 3.14159265358979-2.29243166956117i)+(num-test (acos 10/3) 0.0-1.87382024252741i)+(num-test (acos -10/3) 3.14159265358979-1.87382024252741i)+(num-test (acos 10/10) 0.0)+(num-test (acos -10/10) our-pi)+(num-test (acos 10/1234) 1.56269251038168)+(num-test (acos -10/1234) 1.57890014320811)+(num-test (acos 10/1234000000) 1.57079631869117)+(num-test (acos -10/1234000000) 1.57079633489862)+(num-test (acos 10/500029) 1.57077632795483)+(num-test (acos -10/500029) 1.57081632563497)+(num-test (acos 10/362880) 1.57076876947567)+(num-test (acos -10/362880) 1.57082388411412)+(num-test (acos 1234/1) 0.0-7.81116322068415i)+(num-test (acos -1234/1) 3.14159265358979-7.81116322068415i)+(num-test (acos 1234/2) 0.0-7.11801554770806i)+(num-test (acos -1234/2) 3.14159265358979-7.11801554770806i)+(num-test (acos 1234/3) 0.0-6.71254961876657i)+(num-test (acos -1234/3) 3.14159265358979-6.71254961876657i)+(num-test (acos 1234/10) 0.0-5.50856187402751i)+(num-test (acos -1234/10) 3.14159265358979-5.50856187402751i)+(num-test (acos 1234/1234) 0.0)+(num-test (acos -1234/1234) our-pi)+(num-test (acos 1234/1234000000) 1.57079532679490)+(num-test (acos -1234/1234000000) 1.57079732679490)+(num-test (acos 1234/500029) 1.56832846742558)+(num-test (acos -1234/500029) 1.57326418616421)+(num-test (acos 1234/362880) 1.56739574704864)+(num-test (acos -1234/362880) 1.57419690654115)+(num-test (acos 1234000000/1234000000) 0.0)+(num-test (acos -1234000000/1234000000) our-pi)+(num-test (acos 1234000000/500029) 0.0-8.50425252675189i)+(num-test (acos -1234000000/500029) 3.14159265358979-8.50425252675189i)+(num-test (acos 1234000000/362880) 0.0-8.82484644053502i)+(num-test (acos -1234000000/362880) 3.14159265358979-8.82484644053502i)+(num-test (acos 500029/3) 0+12.7169561400958i)+(num-test (acos -500029/3) 3.14159265358979-12.7169561400958i)+(num-test (acos 500029/10) 0.0+11.51298346318831i) ; maxima+(num-test (acos -500029/10) 3.14159265358979-11.51298333576987i)+(num-test (acos 500029/1234) 0.0-6.69755082925184i)+(num-test (acos -500029/1234) 3.14159265358979-6.69755082925184i)+(num-test (acos 500029/1234000000) 1.57039111689726)+(num-test (acos -500029/1234000000) 1.57120153669253)+(num-test (acos 500029/500029) 0.0)+(num-test (acos -500029/500029) our-pi)+(num-test (acos 500029/362880) 0.0-0.84413377868249i)+(num-test (acos -500029/362880) 3.14159265358979-0.84413377868249i)+(num-test (acos 362880/2) 0.0+1.280182724631953e1i)+(num-test (acos -362880/2) 3.141592653589793-12.80182748007388i)+(num-test (acos 362880/3) 0.0+12.39636237195622i)+(num-test (acos -362880/3) 3.141592653589793-12.39636237195622i)+(num-test (acos 362880/10) 0.0-11.19238956745752i)+(num-test (acos -362880/10) 3.14159265358979-11.19238956745752i)+(num-test (acos 362880/1234) 0.0-6.37695556516894i)+(num-test (acos -362880/1234) 3.14159265358979-6.37695556516894i)+(num-test (acos 362880/1234000000) 1.57050225871935)+(num-test (acos -362880/1234000000) 1.57109039487045)+(num-test (acos 362880/500029) 0.75871902295910)+(num-test (acos -362880/500029) 2.38287363063069)+(num-test (acos 362880/362880) 0.0)+(num-test (acos -362880/362880) our-pi)+(num-test (acos 0.0) 1.57079632679490)+(num-test (acos 0.00000001) 1.57079631679490)+(num-test (acos -0.00000001) 1.57079633679490)+(num-test (acos 1.0) 0.0)+(num-test (acos -1.0) our-pi)+(num-test (acos our-pi) 0.0-1.81152627246085i)+(num-test (acos -3.14159265358979) 3.14159265358979-1.81152627246085i)+(num-test (acos 2.71828182845905) 0.0-1.65745445415308i)+(num-test (acos -2.71828182845905) 3.14159265358979-1.65745445415308i)+(num-test (acos 1234.0) 0.0-7.81116322068415i)+(num-test (acos -1234.0) 3.14159265358979-7.81116322068415i)+(num-test (acos 0.0+0.0i) 1.57079632679490)+(num-test (acos -0.0+0.0i) 1.57079632679490)+(num-test (acos 0.0-0.0i) 1.57079632679490)+(num-test (acos -0.0-0.0i) 1.57079632679490)+(num-test (acos 0.0+0.00000001i) 1.57079632679490-0.00000001i)+(num-test (acos -0.0+0.00000001i) 1.57079632679490-0.00000001i)+(num-test (acos 0.0-0.00000001i) 1.57079632679490+0.00000001i)+(num-test (acos -0.0-0.00000001i) 1.57079632679490+0.00000001i)+(num-test (acos 0.0+1.0i) 1.57079632679490-0.88137358701954i)+(num-test (acos -0.0+1.0i) 1.57079632679490-0.88137358701954i)+(num-test (acos 0.0-1.0i) 1.57079632679490+0.88137358701954i)+(num-test (acos -0.0-1.0i) 1.57079632679490+0.88137358701954i)+(num-test (acos 0.0+3.14159265358979i) 1.57079632679490-1.86229574331085i)+(num-test (acos -0.0+3.14159265358979i) 1.57079632679490-1.86229574331085i)+(num-test (acos 0.0-3.14159265358979i) 1.57079632679490+1.86229574331085i)+(num-test (acos -0.0-3.14159265358979i) 1.57079632679490+1.86229574331085i)+(num-test (acos 0.0+2.71828182845905i) 1.57079632679490-1.72538255885232i)+(num-test (acos -0.0+2.71828182845905i) 1.57079632679490-1.72538255885232i)+(num-test (acos 0.0-2.71828182845905i) 1.57079632679490+1.72538255885231i)+(num-test (acos -0.0-2.71828182845905i) 1.57079632679490+1.72538255885231i)+(num-test (acos 0.0+1234.0i) 1.57079632679490-7.81116354896171i)+(num-test (acos -0.0+1234.0i) 1.57079632679490-7.81116354896171i)+(num-test (acos 0.0-1234.0i) 1.57079632679490+7.81116354920125i)+(num-test (acos -0.0-1234.0i) 1.57079632679490+7.81116354920125i)+(num-test (acos 0.0-1234000000.0i) 1.57079632679490+21.62667394298955i)+(num-test (acos -0.0-1234000000.0i) 1.57079632679490+21.62667394298955i)+(num-test (acos 0.00000001+0.0i) 1.57079631679490)+(num-test (acos -0.00000001+0.0i) 1.57079633679490)+(num-test (acos 0.00000001-0.0i) 1.57079631679490)+(num-test (acos -0.00000001-0.0i) 1.57079633679490)+(num-test (acos 0.00000001+0.00000001i) 1.57079631679490-0.00000001i)+(num-test (acos -0.00000001+0.00000001i) 1.57079633679490-0.00000001i)+(num-test (acos 0.00000001-0.00000001i) 1.57079631679490+0.00000001i)+(num-test (acos -0.00000001-0.00000001i) 1.57079633679490+0.00000001i)+(num-test (acos 0.00000001+1.0i) 1.57079631972383-0.88137358701954i)+(num-test (acos -0.00000001+1.0i) 1.57079633386596-0.88137358701954i)+(num-test (acos 0.00000001-1.0i) 1.57079631972383+0.88137358701954i)+(num-test (acos -0.00000001-1.0i) 1.57079633386596+0.88137358701954i)+(num-test (acos 0.00000001+3.14159265358979i) 1.57079632376175-1.86229574331085i)+(num-test (acos -0.00000001+3.14159265358979i) 1.57079632982804-1.86229574331085i)+(num-test (acos 0.00000001-3.14159265358979i) 1.57079632376175+1.86229574331085i)+(num-test (acos -0.00000001-3.14159265358979i) 1.57079632982804+1.86229574331085i)+(num-test (acos 0.00000001+2.71828182845905i) 1.57079632334232-1.72538255885232i)+(num-test (acos -0.00000001+2.71828182845905i) 1.57079633024747-1.72538255885232i)+(num-test (acos 0.00000001-2.71828182845905i) 1.57079632334232+1.72538255885231i)+(num-test (acos -0.00000001-2.71828182845905i) 1.57079633024747+1.72538255885231i)+(num-test (acos 0.00000001+1234.0i) 1.57079632678679-7.81116354896171i)+(num-test (acos -0.00000001+1234.0i) 1.57079632680300-7.81116354896171i)+(num-test (acos 0.00000001-1234.0i) 1.57079632678679+7.81116354920125i)+(num-test (acos -0.00000001-1234.0i) 1.57079632680300+7.81116354920125i)+(num-test (acos 0.00000001-1234000000.0i) 1.57079632679490+21.62667394298955i)+(num-test (acos -0.00000001-1234000000.0i) 1.57079632679490+21.62667394298955i)+(num-test (acos 1.0+0.0i) 0.0)+(num-test (acos -1.0+0.0i) our-pi)+(num-test (acos 1.0-0.0i) 0.0)+(num-test (acos -1.0-0.0i) our-pi)+(num-test (acos 1.0+0.00000001i) 0.00009999999992-0.00010000000008i)+(num-test (acos -1.0+0.00000001i) 3.14149265358988-0.00010000000008i)+(num-test (acos 1.0-0.00000001i) 0.00009999999992+0.00010000000008i)+(num-test (acos -1.0-0.00000001i) 3.14149265358988+0.00010000000008i)+(num-test (acos 1.0+1.0i) 0.90455689430238-1.06127506190504i)+(num-test (acos -1.0+1.0i) 2.23703575928741-1.06127506190504i)+(num-test (acos 1.0-1.0i) 0.90455689430238+1.06127506190504i)+(num-test (acos -1.0-1.0i) 2.23703575928741+1.06127506190504i)+(num-test (acos 1.0+3.14159265358979i) 1.27521129258327-1.90462768697066i)+(num-test (acos -1.0+3.14159265358979i) 1.86638136100653-1.90462768697066i)+(num-test (acos 1.0-3.14159265358979i) 1.27521129258327+1.90462768697066i)+(num-test (acos -1.0-3.14159265358979i) 1.86638136100653+1.90462768697066i)+(num-test (acos 1.0+2.71828182845905i) 1.23635355491853-1.77905438385935i)+(num-test (acos -1.0+2.71828182845905i) 1.90523909867127-1.77905438385935i)+(num-test (acos 1.0-2.71828182845905i) 1.23635355491853+1.77905438385935i)+(num-test (acos -1.0-2.71828182845905i) 1.90523909867127+1.77905438385935i)+(num-test (acos 1.0+1234.0i) 1.56998595446684-7.81116387772663i)+(num-test (acos -1.0+1234.0i) 1.57160669912296-7.81116387772663i)+(num-test (acos 1.0-1234.0i) 1.56998595446690+7.81116387755283i)+(num-test (acos -1.0-1234.0i) 1.57160669912289+7.81116387755283i)+(num-test (acos 1.0-1234000000.0i) 1.57079632598452+21.62667394298955i)+(num-test (acos -1.0-1234000000.0i) 1.57079632760527+21.62667394298955i)+(num-test (acos 3.14159265358979+0.0i) 0.0-1.81152627246085i)+(num-test (acos -3.14159265358979+0.0i) 3.14159265358979-1.81152627246085i)+(num-test (acos 3.14159265358979-0.0i) 0.0-1.81152627246085i)+(num-test (acos -3.14159265358979-0.0i) 3.14159265358979-1.81152627246085i)+(num-test (acos 3.14159265358979+0.00000001i) 0.00000000335775-1.81152627246085i)+(num-test (acos -3.14159265358979+0.00000001i) 3.14159265023205-1.81152627246085i)+(num-test (acos 3.14159265358979-0.00000001i) 0.00000000335775+1.81152627246085i)+(num-test (acos -3.14159265358979-0.00000001i) 3.14159265023205+1.81152627246085i)+(num-test (acos 3.14159265358979+1.0i) 0.32225329398146-1.86711439316026i)+(num-test (acos -3.14159265358979+1.0i) 2.81933935960833-1.86711439316026i)+(num-test (acos 3.14159265358979-1.0i) 0.32225329398146+1.86711439316026i)+(num-test (acos -3.14159265358979-1.0i) 2.81933935960833+1.86711439316026i)+(num-test (acos 3.14159265358979+3.14159265358979i) 0.79805654766741-2.18469104082751i)+(num-test (acos -3.14159265358979+3.14159265358979i) 2.34353610592238-2.18469104082751i)+(num-test (acos 3.14159265358979-3.14159265358979i) 0.79805654766741+2.18469104082751i)+(num-test (acos -3.14159265358979-3.14159265358979i) 2.34353610592238+2.18469104082751i)+(num-test (acos 3.14159265358979+2.71828182845905i) 0.72769976263454-2.11552790803290i)+(num-test (acos -3.14159265358979+2.71828182845905i) 2.41389289095525-2.11552790803290i)+(num-test (acos 3.14159265358979-2.71828182845905i) 0.72769976263454+2.11552790803290i)+(num-test (acos -3.14159265358979-2.71828182845905i) 2.41389289095525+2.11552790803290i)+(num-test (acos 3.14159265358979+1234.0i) 1.56825047198589-7.81116678966949i)+(num-test (acos -3.14159265358979+1234.0i) 1.57334218160390-7.81116678966949i)+(num-test (acos 3.14159265358979-1234.0i) 1.56825047198552+7.81116678989204i)+(num-test (acos -3.14159265358979-1234.0i) 1.57334218160427+7.81116678989204i)+(num-test (acos 3.14159265358979-1234000000.0i) 1.57079632424904+21.62667394298955i)+(num-test (acos -3.14159265358979-1234000000.0i) 1.57079632934076+21.62667394298955i)+(num-test (acos 2.71828182845905+0.0i) 0.0-1.65745445415308i)+(num-test (acos -2.71828182845905+0.0i) 3.14159265358979-1.65745445415308i)+(num-test (acos 2.71828182845905-0.0i) 0.0-1.65745445415308i)+(num-test (acos -2.71828182845905-0.0i) 3.14159265358979-1.65745445415308i)+(num-test (acos 2.71828182845905+0.00000001i) 0.00000000395623-1.65745445415308i)+(num-test (acos -2.71828182845905+0.00000001i) 3.14159264963356-1.65745445415308i)+(num-test (acos 2.71828182845905-0.00000001i) 0.00000000395623+1.65745445415308i)+(num-test (acos -2.71828182845905-0.00000001i) 3.14159264963356+1.65745445415308i)+(num-test (acos 2.71828182845905+1.0i) 0.37321824160908-1.73375471569385i)+(num-test (acos -2.71828182845905+1.0i) 2.76837441198071-1.73375471569385i)+(num-test (acos 2.71828182845905-1.0i) 0.37321824160908+1.73375471569385i)+(num-test (acos -2.71828182845905-1.0i) 2.76837441198071+1.73375471569385i)+(num-test (acos 2.71828182835905+3.14159265358979i) 0.87174835684834-2.11968336368048i)+(num-test (acos -2.71828182845905+3.14159265358979i) 2.26984429674145-2.11968336368048i)+(num-test (acos 2.71828182845905-3.14159265358979i) 0.87174835684834+2.11968336368048i)+(num-test (acos -2.71828182845905-3.14159265358979i) 2.26984429674145+2.11968336368048i)+(num-test (acos 2.71828182845905+2.71828182845905i) 0.80229897091015-2.04014932880026i)+(num-test (acos -2.71828182845905+2.71828182845905i) 2.33929368267965-2.04014932880026i)+(num-test (acos 2.71828182845905-2.71828182845905i) 0.80229897091014+2.04014932880026i)+(num-test (acos -2.71828182845905-2.71828182845905i) 2.33929368267965+2.04014932880026i)+(num-test (acos 2.71828182845905+1234.0i) 1.56859350950254-7.81116597510553i)+(num-test (acos -2.71828182845905+1234.0i) 1.57299914408725-7.81116597510553i)+(num-test (acos 2.71828182845905-1234.0i) 1.56859350950221+7.81116597540442i)+(num-test (acos -2.71828182845905-1234.0i) 1.57299914408758+7.81116597540442i)+(num-test (acos 2.71828182845905-1234000000.0i) 1.57079632459208+21.62667394298955i)+(num-test (acos -2.71828182845905-1234000000.0i) 1.57079632899772+21.62667394298955i)+(num-test (acos 1234.0+0.0i) 0.0-7.81116322068415i)+(num-test (acos -1234.0+0.0i) 3.14159265358979-7.81116322068415i)+(num-test (acos 1234.0-0.0i) 0.0-7.81116322068415i)+(num-test (acos -1234.0-0.0i) 3.14159265358979-7.81116322068415i)+(num-test (acos 1234.0+0.00000001i) 0.00000000000810-7.81116322068415i)+(num-test (acos -1234.0+0.00000001i) 3.14159265358169-7.81116322068415i)+(num-test (acos 1234.0-0.00000001i) 0.00000000000810+7.81116322084923i)+(num-test (acos -1234.0-0.00000001i) 3.14159265358169+7.81116322084923i)+(num-test (acos 1234.0+1.0i) 0.00081037286048-7.81116354944842i)+(num-test (acos -1234.0+1.0i) 3.14078228072931-7.81116354944842i)+(num-test (acos 1234.0-1.0i) 0.00081037286017+7.81116354920146i)+(num-test (acos -1234.0-1.0i) 3.14078228072962+7.81116354920146i)+(num-test (acos 1234.0+3.14159265358979i) 0.00254585647983-7.81116646138554i)+(num-test (acos -1234.0+3.14159265358979i) 3.13904679710996-7.81116646138554i)+(num-test (acos 1234.0-3.14159265358979i) 0.00254585648123+7.81116646154641i)+(num-test (acos -1234.0-3.14159265358979i) 3.13904679710856+7.81116646154641i)+(num-test (acos 1234.0+2.71828182845905i) 0.00220281873947-7.81116564738434i)+(num-test (acos -1234.0+2.71828182845905i) 3.13938983485033-7.81116564738434i)+(num-test (acos 1234.0-2.71828182845905i) 0.00220281873928+7.81116564705719i)+(num-test (acos -1234.0-2.71828182845905i) 3.13938983485052+7.81116564705719i)+(num-test (acos 1234.0+1234.0i) 0.78539824532655-8.15773697538346i)+(num-test (acos -1234.0+1234.0i) 2.35619440826324-8.15773697538346i)+(num-test (acos 1234.0-1234.0i) 0.78539824548545+8.15773697530526i)+(num-test (acos -1234.0-1234.0i) 2.35619440810434+8.15773697530526i)+(num-test (acos 1234.0-1234000000.0i) 1.57079532679490+21.62667394299005i)+(num-test (acos -1234.0-1234000000.0i) 1.57079732679490+21.62667394299005i)+(num-test (acos 1234000000.0-0.00000001i) 0.0+21.62667394298955i)+(num-test (acos -1234000000.0-0.00000001i) 3.14159265358979+21.62667394298955i)+(num-test (acos 1234000000.0-1.0i) 0.00000000081037+21.62667394298955i)+(num-test (acos -1234000000.0-1.0i) 3.14159265277942+21.62667394298955i)+(num-test (acos 1234000000.0-3.14159265358979i) 0.00000000254586+21.62667394298955i)+(num-test (acos -1234000000.0-3.14159265358979i) 3.14159265104393+21.62667394298955i)+(num-test (acos 1234000000.0-2.71828182845905i) 0.00000000220282+21.62667394298955i)+(num-test (acos -1234000000.0-2.71828182845905i) 3.14159265138697+21.62667394298955i)+(num-test (acos 1234000000.0-1234.0i) 0.00000100000000+21.62667394299005i)+(num-test (acos -1234000000.0-1234.0i) 3.14159165358979+21.62667394299005i)+(num-test (acos 1234000000.0-1234000000.0i) 0.78539816339745+21.97324753326953i)+(num-test (acos -1234000000.0-1234000000.0i) 2.35619449019234+21.97324753326953i)+(num-test (acos -2.0) 3.141592653589793-1.316957896924817i)+(num-test (acos 3.0+70000000i) 1.570796283937754-18.7571529895002i) ; C breaks near here+(num-test (acos 70000000+3i) 4.725807101202406E-8-18.75715298057358i)+(num-test (acos 3.0-70000000i) 1.570796283937754+18.7571529895002i)+(num-test (acos -70000000+3i) 3.141592606331722-18.75715298057358i)+(num-test (acos 1.5) 0.0+0.9624236501192069i)+(num-test (acos -1.5) 3.141592653589793-0.9624236501192069i)+(num-test (acos -1.0e+01) 3.1415926535897932385e0-2.9932228461263808979e0i)+(num-test (acos -2.0e+00) 3.1415926535897932385e0-1.3169578969248167086e0i)+(num-test (acos -1.0e+00) 3.1415926535897932385e0+0.0i)+(num-test (acos -7.50e-01) 2.4188584057763776273e0+0.0i)+(num-test (acos -5.0e-01) 2.0943951023931954923e0+0.0i)+(num-test (acos -1.250e-01) 1.6961241579629620161e0+0.0i)+(num-test (acos -3.45266983001243932001e-04) 1.5711415937847577022e0+0.0i)+(num-test (acos -1.19209289550781250e-07) 1.570796446004186170e0+0.0i)+(num-test (acos 0.0e+00) 1.5707963267948966192e0+0.0i)+(num-test (acos 1.19209289550781250e-07) 1.5707962075856070684e0+0.0i)+(num-test (acos 3.45266983001243932001e-04) 1.5704510598050355363e0+0.0i)+(num-test (acos 1.250e-01) 1.4454684956268312224e0+0.0i)+(num-test (acos 5.0e-01) 1.0471975511965977462e0+0.0i)+(num-test (acos 7.50e-01) 7.2273424781341561118e-1+0.0i)+(num-test (acos 1.0e+00) 0e0+0.0i)+(num-test (acos 2.0e+00) 0+1.3169578969248167086e0i)+(num-test (acos 1.0e+01) 0+2.9932228461263808979e0i)+(num-test (acos 0.0e+00+0.0e+00i) 1.5707963267948966192e0+0.0i)+(num-test (acos 0.0e+00+1.19209289550781250e-07i) 1.5707963267948966192e0-1.1920928955078096766e-7i)+(num-test (acos 0.0e+00-1.19209289550781250e-07i) 1.5707963267948966192e0+1.1920928955078096766e-7i)+(num-test (acos 0.0e+00+5.0e-01i) 1.5707963267948966192e0-4.8121182505960344750e-1i)+(num-test (acos 0.0e+00-5.0e-01i) 1.5707963267948966192e0+4.8121182505960344750e-1i)+(num-test (acos 0.0e+00+1.0e+00i) 1.5707963267948966192e0-8.8137358701954302523e-1i)+(num-test (acos 0.0e+00-1.0e+00i) 1.5707963267948966192e0+8.8137358701954302523e-1i)+(num-test (acos 0.0e+00+2.0e+00i) 1.5707963267948966192e0-1.4436354751788103425e0i)+(num-test (acos 0.0e+00-2.0e+00i) 1.5707963267948966192e0+1.4436354751788103425e0i)+(num-test (acos 0.0e+00+8.3886080e+06i) 1.5707963267948966192e0-1.6635532333438690979e1i)+(num-test (acos 0.0e+00-8.3886080e+06i) 1.5707963267948966192e0+1.6635532333438690979e1i)+(num-test (acos 1.19209289550781250e-07+0.0e+00i) 1.5707962075856070684e0+0.0i)+(num-test (acos -1.19209289550781250e-07+0.0e+00i) 1.570796446004186170e0+0.0i)+(num-test (acos 1.19209289550781250e-07+1.19209289550781250e-07i) 1.5707962075856070685e0-1.1920928955078181469e-7i)+(num-test (acos 1.19209289550781250e-07-1.19209289550781250e-07i) 1.5707962075856070685e0+1.1920928955078181469e-7i)+(num-test (acos -1.19209289550781250e-07+1.19209289550781250e-07i) 1.570796446004186170e0-1.1920928955078181469e-7i)+(num-test (acos -1.19209289550781250e-07-1.19209289550781250e-07i) 1.570796446004186170e0+1.1920928955078181469e-7i)+(num-test (acos 1.19209289550781250e-07+5.0e-01i) 1.5707962201708666252e0-4.8121182505960598961e-1i)+(num-test (acos 1.19209289550781250e-07-5.0e-01i) 1.5707962201708666252e0+4.8121182505960598961e-1i)+(num-test (acos -1.19209289550781250e-07+5.0e-01i) 1.5707964334189266132e0-4.8121182505960598961e-1i)+(num-test (acos -1.19209289550781250e-07-5.0e-01i) 1.5707964334189266132e0+4.8121182505960598961e-1i)+(num-test (acos 1.19209289550781250e-07+1.0e+00i) 1.5707962425011995974e0-8.8137358701954553738e-1i)+(num-test (acos 1.19209289550781250e-07-1.0e+00i) 1.5707962425011995974e0+8.8137358701954553738e-1i)+(num-test (acos -1.19209289550781250e-07+1.0e+00i) 1.5707964110885936410e0-8.8137358701954553738e-1i)+(num-test (acos -1.19209289550781250e-07-1.0e+00i) 1.5707964110885936410e0+8.8137358701954553738e-1i)+(num-test (acos 1.19209289550781250e-07+2.0e+00i) 1.5707962734828816222e0-1.4436354751788116136e0i)+(num-test (acos 1.19209289550781250e-07-2.0e+00i) 1.5707962734828816222e0+1.4436354751788116136e0i)+(num-test (acos -1.19209289550781250e-07+2.0e+00i) 1.5707963801069116162e0-1.4436354751788116136e0i)+(num-test (acos -1.19209289550781250e-07-2.0e+00i) 1.5707963801069116162e0+1.4436354751788116136e0i)+(num-test (acos 1.19209289550781250e-07+8.3886080e+06i) 1.5707963267948824084e0-1.6635532333438690979e1i)+(num-test (acos 1.19209289550781250e-07-8.3886080e+06i) 1.5707963267948824084e0+1.6635532333438690979e1i)+(num-test (acos -1.19209289550781250e-07+8.3886080e+06i) 1.5707963267949108301e0-1.6635532333438690979e1i)+(num-test (acos -1.19209289550781250e-07-8.3886080e+06i) 1.5707963267949108301e0+1.6635532333438690979e1i)+(num-test (acos 5.0e-01+0.0e+00i) 1.0471975511965977462e0+0.0i)+(num-test (acos -5.0e-01+0.0e+00i) 2.0943951023931954923e0+0.0i)+(num-test (acos 5.0e-01+1.19209289550781250e-07i) 1.0471975511966032159e0-1.3765103082409432364e-7i)+(num-test (acos 5.0e-01-1.19209289550781250e-07i) 1.0471975511966032159e0+1.3765103082409432364e-7i)+(num-test (acos -5.0e-01+1.19209289550781250e-07i) 2.0943951023931900225e0-1.3765103082409432364e-7i)+(num-test (acos -5.0e-01-1.19209289550781250e-07i) 2.0943951023931900225e0+1.3765103082409432364e-7i)+(num-test (acos 5.0e-01+5.0e-01i) 1.1185178796437059372e0-5.3063753095251782602e-1i)+(num-test (acos 5.0e-01-5.0e-01i) 1.1185178796437059372e0+5.3063753095251782602e-1i)+(num-test (acos -5.0e-01+5.0e-01i) 2.0230747739460873013e0-5.3063753095251782602e-1i)+(num-test (acos -5.0e-01-5.0e-01i) 2.0230747739460873013e0+5.3063753095251782602e-1i)+(num-test (acos 5.0e-01+1.0e+00i) 1.2213572639376833256e0-9.2613303135018242455e-1i)+(num-test (acos 5.0e-01-1.0e+00i) 1.2213572639376833256e0+9.2613303135018242455e-1i)+(num-test (acos -5.0e-01+1.0e+00i) 1.9202353896521099129e0-9.2613303135018242455e-1i)+(num-test (acos -5.0e-01-1.0e+00i) 1.9202353896521099129e0+9.2613303135018242455e-1i)+(num-test (acos 5.0e-01+2.0e+00i) 1.3497776911720127603e0-1.4657153519472905218e0i)+(num-test (acos 5.0e-01-2.0e+00i) 1.3497776911720127603e0+1.4657153519472905218e0i)+(num-test (acos -5.0e-01+2.0e+00i) 1.7918149624177804781e0-1.4657153519472905218e0i)+(num-test (acos -5.0e-01-2.0e+00i) 1.7918149624177804781e0+1.4657153519472905218e0i)+(num-test (acos 5.0e-01+8.3886080e+06i) 1.5707962671902518438e0-1.6635532333438692755e1i)+(num-test (acos 5.0e-01-8.3886080e+06i) 1.5707962671902518438e0+1.6635532333438692755e1i)+(num-test (acos -5.0e-01+8.3886080e+06i) 1.5707963863995413946e0-1.6635532333438692755e1i)+(num-test (acos -5.0e-01-8.3886080e+06i) 1.5707963863995413946e0+1.6635532333438692755e1i)+(num-test (acos 1.0e+00+0.0e+00i) 0e0+0.0i)+(num-test (acos -1.0e+00+0.0e+00i) 3.1415926535897932385e0+0.0i)+(num-test (acos 1.0e+00+1.19209289550781250e-07i) 3.4526697957132450399e-4-3.4526698643116312881e-4i)+(num-test (acos 1.0e+00-1.19209289550781250e-07i) 3.4526697957132450399e-4+3.4526698643116312881e-4i)+(num-test (acos -1.0e+00+1.19209289550781250e-07i) 3.1412473866102219140e0-3.4526698643116312881e-4i)+(num-test (acos -1.0e+00-1.19209289550781250e-07i) 3.1412473866102219140e0+3.4526698643116312881e-4i)+(num-test (acos 1.0e+00+5.0e-01i) 6.7488884558600638016e-1-7.3285767597364526089e-1i)+(num-test (acos 1.0e+00-5.0e-01i) 6.7488884558600638016e-1+7.3285767597364526089e-1i)+(num-test (acos -1.0e+00+5.0e-01i) 2.4667038080037868583e0-7.3285767597364526089e-1i)+(num-test (acos -1.0e+00-5.0e-01i) 2.4667038080037868583e0+7.3285767597364526089e-1i)+(num-test (acos 1.0e+00+1.0e+00i) 9.0455689430238136413e-1-1.0612750619050356520e0i)+(num-test (acos 1.0e+00-1.0e+00i) 9.0455689430238136413e-1+1.0612750619050356520e0i)+(num-test (acos -1.0e+00+1.0e+00i) 2.2370357592874118743e0-1.0612750619050356520e0i)+(num-test (acos -1.0e+00-1.0e+00i) 2.2370357592874118743e0+1.0612750619050356520e0i)+(num-test (acos 1.0e+00+2.0e+00i) 1.1437177404024204938e0-1.5285709194809981613e0i)+(num-test (acos 1.0e+00-2.0e+00i) 1.1437177404024204938e0+1.5285709194809981613e0i)+(num-test (acos -1.0e+00+2.0e+00i) 1.9978749131873727447e0-1.5285709194809981613e0i)+(num-test (acos -1.0e+00-2.0e+00i) 1.9978749131873727447e0+1.5285709194809981613e0i)+(num-test (acos 1.0e+00+8.3886080e+06i) 1.5707962075856070685e0-1.6635532333438698084e1i)+(num-test (acos 1.0e+00-8.3886080e+06i) 1.5707962075856070685e0+1.6635532333438698084e1i)+(num-test (acos -1.0e+00+8.3886080e+06i) 1.570796446004186170e0-1.6635532333438698084e1i)+(num-test (acos -1.0e+00-8.3886080e+06i) 1.570796446004186170e0+1.6635532333438698084e1i)+(num-test (acos 2.0e+00+0.0e+00i) 0+1.3169578969248167086e0i)+(num-test (acos -2.0e+00+0.0e+00i) 3.1415926535897932385e0-1.3169578969248167086e0i)+(num-test (acos 2.0e+00+1.19209289550781250e-07i) 6.8825515412047433504e-8-1.3169578969248194435e0i)+(num-test (acos 2.0e+00-1.19209289550781250e-07i) 6.8825515412047433504e-8+1.3169578969248194435e0i)+(num-test (acos -2.0e+00+1.19209289550781250e-07i) 3.1415925847642778264e0-1.3169578969248194435e0i)+(num-test (acos -2.0e+00-1.19209289550781250e-07i) 3.1415925847642778264e0+1.3169578969248194435e0i)+(num-test (acos 2.0e+00+5.0e-01i) 2.7775425655771396018e-1-1.3618009008578457882e0i)+(num-test (acos 2.0e+00-5.0e-01i) 2.7775425655771396018e-1+1.3618009008578457882e0i)+(num-test (acos -2.0e+00+5.0e-01i) 2.8638383970320792783e0-1.3618009008578457882e0i)+(num-test (acos -2.0e+00-5.0e-01i) 2.8638383970320792783e0+1.3618009008578457882e0i)+(num-test (acos 2.0e+00+1.0e+00i) 5.0735630321714456304e-1-1.4693517443681852733e0i)+(num-test (acos 2.0e+00-1.0e+00i) 5.0735630321714456304e-1+1.4693517443681852733e0i)+(num-test (acos -2.0e+00+1.0e+00i) 2.6342363503726486754e0-1.4693517443681852733e0i)+(num-test (acos -2.0e+00-1.0e+00i) 2.6342363503726486754e0+1.4693517443681852733e0i)+(num-test (acos 2.0e+00+2.0e+00i) 8.1654718209685057852e-1-1.7343245214879664480e0i)+(num-test (acos 2.0e+00-2.0e+00i) 8.1654718209685057852e-1+1.7343245214879664480e0i)+(num-test (acos -2.0e+00+2.0e+00i) 2.3250454714929426599e0-1.7343245214879664480e0i)+(num-test (acos -2.0e+00-2.0e+00i) 2.3250454714929426599e0+1.7343245214879664480e0i)+(num-test (acos 2.0e+00+8.3886080e+06i) 1.5707960883763175177e0-1.663553233343871940e1i)+(num-test (acos 2.0e+00-8.3886080e+06i) 1.5707960883763175177e0+1.663553233343871940e1i)+(num-test (acos -2.0e+00+8.3886080e+06i) 1.5707965652134757208e0-1.663553233343871940e1i)+(num-test (acos -2.0e+00-8.3886080e+06i) 1.5707965652134757208e0+1.663553233343871940e1i)+(num-test (acos 8.3886080e+06+0.0e+00i) 0+1.6635532333438683873e1i)+(num-test (acos -8.3886080e+06+0.0e+00i) 3.1415926535897932385e0-1.6635532333438683873e1i)+(num-test (acos 8.3886080e+06+1.19209289550781250e-07i) 1.4210854715202104692e-14-1.6635532333438683873e1i)+(num-test (acos 8.3886080e+06-1.19209289550781250e-07i) 1.4210854715202104692e-14+1.6635532333438683873e1i)+(num-test (acos -8.3886080e+06+1.19209289550781250e-07i) 3.1415926535897790276e0-1.6635532333438683873e1i)+(num-test (acos -8.3886080e+06-1.19209289550781250e-07i) 3.1415926535897790276e0+1.6635532333438683873e1i)+(num-test (acos 8.3886080e+06+5.0e-01i) 5.9604644775390977930e-8-1.6635532333438685650e1i)+(num-test (acos 8.3886080e+06-5.0e-01i) 5.9604644775390977930e-8+1.6635532333438685650e1i)+(num-test (acos -8.3886080e+06+5.0e-01i) 3.1415925939851484631e0-1.6635532333438685650e1i)+(num-test (acos -8.3886080e+06-5.0e-01i) 3.1415925939851484631e0+1.6635532333438685650e1i)+(num-test (acos 8.3886080e+06+1.0e+00i) 1.1920928955078153234e-7-1.6635532333438690979e1i)+(num-test (acos 8.3886080e+06-1.0e+00i) 1.1920928955078153234e-7+1.6635532333438690979e1i)+(num-test (acos -8.3886080e+06+1.0e+00i) 3.1415925343805036877e0-1.6635532333438690979e1i)+(num-test (acos -8.3886080e+06-1.0e+00i) 3.1415925343805036877e0+1.6635532333438690979e1i)+(num-test (acos 8.3886080e+06+2.0e+00i) 2.3841857910155967656e-7-1.6635532333438712295e1i)+(num-test (acos 8.3886080e+06-2.0e+00i) 2.3841857910155967656e-7+1.6635532333438712295e1i)+(num-test (acos -8.3886080e+06+2.0e+00i) 3.1415924151712141369e0-1.6635532333438712295e1i)+(num-test (acos -8.3886080e+06-2.0e+00i) 3.1415924151712141369e0+1.6635532333438712295e1i)+(num-test (acos 8.3886080e+06+8.3886080e+06i) 7.8539816339745008597e-1-1.6982105923718660081e1i)+(num-test (acos 8.3886080e+06-8.3886080e+06i) 7.8539816339745008597e-1+1.6982105923718660081e1i)+(num-test (acos -8.3886080e+06+8.3886080e+06i) 2.3561944901923431525e0-1.6982105923718660081e1i)+(num-test (acos -8.3886080e+06-8.3886080e+06i) 2.3561944901923431525e0+1.6982105923718660081e1i)+(num-test (acos 1234000000/3) 0+20.52806165432143i)+(num-test (acos 0.00000001+1234000000.0i) 1.570796326794897-21.62667380877375i)+(num-test (acos 3.14159265358979+1234000000.0i) 1.570796324249036-21.62667380877375i)+(num-test (acos 2.71828182845905+1234000000.0i) 1.570796324592076-21.62667380877375i)+(num-test (acos 1234000000.0+0.00000001i) -4.051865509779873E-10-21.62667394298955i)+(num-test (acos 1234000000.0+3.14159265358979i) -4.051865509779873E-10-21.62667394298955i)+(num-test (acos 1234000000.0+2.71828182845905i) -4.051865509779873E-10-21.62667394298955i)+(num-test (acos -64983.97009220963-48983.30494825104i) 2.495679792792491+12.0i)++(let ((err 0.0))+  (do ((i 0 (+ i 1))+       (x -10.0 (+ x .1)))+      ((= i 200))+    (let ((y (magnitude (- x (cos (acos x))))))+      (if (> y err) (set! err y))))+  (if (> err 1e-12)+      (begin (display "(cos (acos ...)) error: ") (display err) (newline))))++(let ((err 0.0))+  (do ((i 0 (+ i 1))+       (x 1.0-i (+ x -0.1+0.1i)))+      ((= i 200))+    (let ((y (magnitude (- x (cos (acos x))))))+      (if (> y err) (set! err y))))+  (if (> err 1e-10)+      (begin (display "(cos (acos [complex] ...)) error: ") (display err) (newline))))+++;; -------- atan+(num-test (atan 0) 0.0)+(num-test (atan 1) 0.78539816339745)+(num-test (atan -1) -0.78539816339745)+(num-test (atan 2) 1.10714871779409)+(num-test (atan -2) -1.10714871779409)+(num-test (atan 3) 1.24904577239825)+(num-test (atan -3) -1.24904577239825)+(num-test (atan 10) 1.47112767430373)+(num-test (atan -10) -1.47112767430373)+(num-test (atan 1234) 1.56998595420081)+(num-test (atan -1234) -1.56998595420081)+(num-test (atan 0/1) 0.0)+(num-test (atan 0/2) 0.0)+(num-test (atan 0/3) 0.0)+(num-test (atan 0/10) 0.0)+(num-test (atan 0/1234) 0.0)+(num-test (atan 0/1234000000) 0.0)+(num-test (atan 0/500029) 0.0)+(num-test (atan 0/362880) 0.0)+(num-test (atan 1/1) 0.78539816339745)+(num-test (atan -1/1) -0.78539816339745)+(num-test (atan 1/2) 0.46364760900081)+(num-test (atan -1/2) -0.46364760900081)+(num-test (atan 1/3) 0.32175055439664)+(num-test (atan -1/3) -0.32175055439664)+(num-test (atan 1/10) 0.09966865249116)+(num-test (atan -1/10) -0.09966865249116)+(num-test (atan 1/1234) 0.00081037259408)+(num-test (atan -1/1234) -0.00081037259408)+(num-test (atan 1/1234000000) 0.00000000081037)+(num-test (atan -1/1234000000) -0.00000000081037)+(num-test (atan 1/500029) 0.00000199988401)+(num-test (atan -1/500029) -0.00000199988401)+(num-test (atan 1/362880) 0.00000275573192)+(num-test (atan -1/362880) -0.00000275573192)+(num-test (atan 2/1) 1.10714871779409)+(num-test (atan -2/1) -1.10714871779409)+(num-test (atan 2/2) 0.78539816339745)+(num-test (atan -2/2) -0.78539816339745)+(num-test (atan 2/3) 0.58800260354757)+(num-test (atan -2/3) -0.58800260354757)+(num-test (atan 2/10) 0.19739555984988)+(num-test (atan -2/10) -0.19739555984988)+(num-test (atan 2/1234) 0.00162074412382)+(num-test (atan -2/1234) -0.00162074412382)+(num-test (atan 2/1234000000) 0.00000000162075)+(num-test (atan -2/1234000000) -0.00000000162075)+(num-test (atan 2/500029) 0.00000399976801)+(num-test (atan -2/500029) -0.00000399976801)+(num-test (atan 2/362880) 0.00000551146384)+(num-test (atan -2/362880) -0.00000551146384)+(num-test (atan 3/1) 1.24904577239825)+(num-test (atan -3/1) -1.24904577239825)+(num-test (atan 3/2) 0.98279372324733)+(num-test (atan -3/2) -0.98279372324733)+(num-test (atan 3/3) 0.78539816339745)+(num-test (atan -3/3) -0.78539816339745)+(num-test (atan 3/10) 0.29145679447787)+(num-test (atan -3/10) -0.29145679447787)+(num-test (atan 3/1234) 0.00243111352487)+(num-test (atan -3/1234) -0.00243111352487)+(num-test (atan 3/1234000000) 0.00000000243112)+(num-test (atan -3/1234000000) -0.00000000243112)+(num-test (atan 3/500029) 0.00000599965202)+(num-test (atan -3/500029) -0.00000599965202)+(num-test (atan 3/362880) 0.00000826719577)+(num-test (atan -3/362880) -0.00000826719577)+(num-test (atan 10/1) 1.47112767430373)+(num-test (atan -10/1) -1.47112767430373)+(num-test (atan 10/2) 1.37340076694502)+(num-test (atan -10/2) -1.37340076694502)+(num-test (atan 10/3) 1.27933953231703)+(num-test (atan -10/3) -1.27933953231703)+(num-test (atan 10/10) 0.78539816339745)+(num-test (atan -10/10) -0.78539816339745)+(num-test (atan 10/1234) 0.00810355033005)+(num-test (atan -10/1234) -0.00810355033005)+(num-test (atan 10/1234000000) 0.00000000810373)+(num-test (atan -10/1234000000) -0.00000000810373)+(num-test (atan 10/500029) 0.00001999884006)+(num-test (atan -10/500029) -0.00001999884006)+(num-test (atan 10/362880) 0.00002755731922)+(num-test (atan -10/362880) -0.00002755731922)+(num-test (atan 1234/1) 1.56998595420081)+(num-test (atan -1234/1) -1.56998595420081)+(num-test (atan 1234/2) 1.56917558267108)+(num-test (atan -1234/2) -1.56917558267108)+(num-test (atan 1234/3) 1.56836521327003)+(num-test (atan -1234/3) -1.56836521327003)+(num-test (atan 1234/10) 1.56269277646485)+(num-test (atan -1234/10) -1.56269277646485)+(num-test (atan 1234/1234) 0.78539816339745)+(num-test (atan -1234/1234) -0.78539816339745)+(num-test (atan 1234/1234000000) 0.00000100000000)+(num-test (atan -1234/1234000000) -0.00000100000000)+(num-test (atan 1234/500029) 0.00246785185431)+(num-test (atan -1234/500029) -0.00246785185431)+(num-test (atan 1234/362880) 0.00340056008437)+(num-test (atan -1234/362880) -0.00340056008437)+(num-test (atan 1234000000/1234000000) 0.78539816339745)+(num-test (atan -1234000000/1234000000) -0.78539816339745)+(num-test (atan 1234000000/500029) 1.57039111693053)+(num-test (atan -1234000000/500029) -1.57039111693053)+(num-test (atan 1234000000/362880) 1.57050225873206)+(num-test (atan -1234000000/362880) -1.57050225873206)+(num-test (atan 500029/2) 1.57079232702688)+(num-test (atan -500029/2) -1.57079232702688)+(num-test (atan 500029/3) 1.57079032714288)+(num-test (atan -500029/3) -1.57079032714288)+(num-test (atan 500029/10) 1.57077632795483)+(num-test (atan -500029/10) -1.57077632795483)+(num-test (atan 500029/1234) 1.56832847494059)+(num-test (atan -500029/1234) -1.56832847494059)+(num-test (atan 500029/1234000000) 0.00040520986437)+(num-test (atan -500029/1234000000) -0.00040520986437)+(num-test (atan 500029/500029) 0.78539816339745)+(num-test (atan -500029/500029) -0.78539816339745)+(num-test (atan 500029/362880) 0.94301772831206)+(num-test (atan -500029/362880) -0.94301772831206)+(num-test (atan 362880/2) 1.57079081533105)+(num-test (atan -362880/2) -1.57079081533105)+(num-test (atan 362880/3) 1.57078805959913)+(num-test (atan -362880/3) -1.57078805959913)+(num-test (atan 362880/10) 1.57076876947568)+(num-test (atan -362880/10) -1.57076876947568)+(num-test (atan 362880/1234) 1.56739576671053)+(num-test (atan -362880/1234) -1.56739576671053)+(num-test (atan 362880/1234000000) 0.00029406806284)+(num-test (atan -362880/1234000000) -0.00029406806284)+(num-test (atan 362880/500029) 0.62777859848283)+(num-test (atan -362880/500029) -0.62777859848283)+(num-test (atan 362880/362880) 0.78539816339745)+(num-test (atan -362880/362880) -0.78539816339745)+(num-test (atan 0.0) 0.0)+(num-test (atan 0.00000001) 0.00000001)+(num-test (atan -0.00000001) -0.00000001)+(num-test (atan 1.0) 0.78539816339745)+(num-test (atan -1.0) -0.78539816339745)+(num-test (atan our-pi) 1.26262725567891)+(num-test (atan -3.14159265358979) -1.26262725567891)+(num-test (atan 2.71828182845905) 1.21828290501728)+(num-test (atan -2.71828182845905) -1.21828290501728)+(num-test (atan 1234.0) 1.56998595420081)+(num-test (atan -1234.0) -1.56998595420081)+(num-test (atan 0.0+0.0i) 0.0)+(num-test (atan -0.0+0.0i) 0.0)+(num-test (atan 0.0-0.0i) 0.0)+(num-test (atan -0.0-0.0i) -0.0)+(num-test (atan 0.0+0.00000001i) 0.0+0.00000001i)+(num-test (atan -0.0+0.00000001i) 0.0+0.00000001i)+(num-test (atan 0.0-0.00000001i) 0.0-0.00000001i)+(num-test (atan -0.0-0.00000001i) -0.0-0.00000001i)+(num-test (atan 0.0+3.14159265358979i) 1.57079632679490+0.32976531495670i)+(num-test (atan -0.0+3.14159265358979i) 1.57079632679490+0.32976531495670i)+(num-test (atan 0.0-3.14159265358979i) 1.57079632679490-0.32976531495670i)+(num-test (atan -0.0-3.14159265358979i) -1.57079632679490-0.32976531495670i)+(num-test (atan 0.0+2.71828182845905i) 1.57079632679490+0.38596841645265i)+(num-test (atan -0.0+2.71828182845905i) 1.57079632679490+0.38596841645265i)+(num-test (atan 0.0-2.71828182845905i) 1.57079632679490-0.38596841645265i)+(num-test (atan -0.0-2.71828182845905i) -1.57079632679490-0.38596841645265i)+(num-test (atan 0.0+1234.0i) 1.57079632679490+0.00081037294887i)+(num-test (atan -0.0+1234.0i) 1.57079632679490+0.00081037294887i)+(num-test (atan 0.0-1234.0i) 1.57079632679490-0.00081037294887i)+(num-test (atan -0.0-1234.0i) -1.57079632679490-0.00081037294887i)+(num-test (atan 0.00000001+0.0i) 0.00000001)+(num-test (atan -0.00000001+0.0i) -0.00000001)+(num-test (atan 0.00000001-0.0i) 0.00000001)+(num-test (atan -0.00000001-0.0i) -0.00000001)+(num-test (atan 0.00000001+0.00000001i) 0.00000001+0.00000001i)+(num-test (atan -0.00000001+0.00000001i) -0.00000001+0.00000001i)+(num-test (atan 0.00000001-0.00000001i) 0.00000001-0.00000001i)+(num-test (atan -0.00000001-0.00000001i) -0.00000001-0.00000001i)+(num-test (atan 0.00000001+1.0i) 0.78539816589789+9.55691396225616i)+(num-test (atan -0.00000001+1.0i) -0.78539816589789+9.55691396225616i)+(num-test (atan 0.00000001-1.0i) 0.78539816589789-9.55691396225616i)+(num-test (atan -0.00000001-1.0i) -0.78539816589789-9.55691396225616i)+(num-test (atan 0.00000001+3.14159265358979i) 1.57079632566745+0.32976531495670i)+(num-test (atan -0.00000001+3.14159265358979i) -1.57079632566745+0.32976531495670i)+(num-test (atan 0.00000001-3.14159265358979i) 1.57079632566745-0.32976531495670i)+(num-test (atan -0.00000001-3.14159265358979i) -1.57079632566745-0.32976531495670i)+(num-test (atan 0.00000001+2.71828182845905i) 1.57079632522972+0.38596841645265i)+(num-test (atan -0.00000001+2.71828182845905i) -1.57079632522972+0.38596841645265i)+(num-test (atan 0.00000001-2.71828182845905i) 1.57079632522972-0.38596841645265i)+(num-test (atan -0.00000001-2.71828182845905i) -1.57079632522972-0.38596841645265i)+(num-test (atan 0.00000001+1234.0i) 1.57079632679489+0.00081037294887i)+(num-test (atan -0.00000001+1234.0i) -1.57079632679489+0.00081037294887i)+(num-test (atan 0.00000001-1234.0i) 1.57079632679489-0.00081037294887i)+(num-test (atan -0.00000001-1234.0i) -1.57079632679489-0.00081037294887i)+(num-test (atan 1.0+0.0i) 0.78539816339745)+(num-test (atan -1.0+0.0i) -0.78539816339745)+(num-test (atan 1.0-0.0i) 0.78539816339745)+(num-test (atan -1.0-0.0i) -0.78539816339745)+(num-test (atan 1.0+0.00000001i) 0.78539816339745+0.00000000500000i)+(num-test (atan -1.0+0.00000001i) -0.78539816339745+0.00000000500000i)+(num-test (atan 1.0-0.00000001i) 0.78539816339745-0.00000000500000i)+(num-test (atan -1.0-0.00000001i) -0.78539816339745-0.00000000500000i)+(num-test (atan 1.0+1.0i) 1.01722196789785+0.40235947810853i)+(num-test (atan -1.0+1.0i) -1.01722196789785+0.40235947810853i)+(num-test (atan 1.0-1.0i) 1.01722196789785-0.40235947810853i)+(num-test (atan -1.0-1.0i) -1.01722196789785-0.40235947810853i)+(num-test (atan 1.0+3.14159265358979i) 1.47082882591946+0.29462144034086i)+(num-test (atan -1.0+3.14159265358979i) -1.47082882591946+0.29462144034086i)+(num-test (atan 1.0-3.14159265358979i) 1.47082882591946-0.29462144034086i)+(num-test (atan -1.0-3.14159265358979i) -1.47082882591946-0.29462144034086i)+(num-test (atan 1.0+2.71828182845905i) 1.43862796047891+0.33050259272341i)+(num-test (atan -1.0+2.71828182845905i) -1.43862796047891+0.33050259272341i)+(num-test (atan 1.0-2.71828182845905i) 1.43862796047891-0.33050259272341i)+(num-test (atan -1.0-2.71828182845905i) -1.43862796047891-0.33050259272341i)+(num-test (atan 1.0+1234.0i) 1.57079567009087+0.00081037241669i)+(num-test (atan -1.0+1234.0i) -1.57079567009087+0.00081037241669i)+(num-test (atan 1.0-1234.0i) 1.57079567009087-0.00081037241669i)+(num-test (atan -1.0-1234.0i) -1.57079567009087-0.00081037241669i)+(num-test (atan 3.14159265358979+0.0i) 1.26262725567891)+(num-test (atan -3.14159265358979+0.0i) -1.26262725567891)+(num-test (atan 3.14159265358979-0.0i) 1.26262725567891)+(num-test (atan -3.14159265358979-0.0i) -1.26262725567891)+(num-test (atan 3.14159265358979+0.00000001i) 1.26262725567891+0.00000000092000i)+(num-test (atan -3.14159265358979+0.00000001i) -1.26262725567891+0.00000000092000i)+(num-test (atan 3.14159265358979-0.00000001i) 1.26262725567891-0.00000000092000i)+(num-test (atan -3.14159265358979-0.00000001i) -1.26262725567891-0.00000000092000i)+(num-test (atan 3.14159265358979+1.0i) 1.28734057432439+0.08505998507745i)+(num-test (atan -3.14159265358979+1.0i) -1.28734057432439+0.08505998507745i)+(num-test (atan 3.14159265358979-1.0i) 1.28734057432439-0.08505998507745i)+(num-test (atan -3.14159265358979-1.0i) -1.28734057432439-0.08505998507745i)+(num-test (atan 3.14159265358979+3.14159265358979i) 1.40903828502376+0.15638868878130i)+(num-test (atan -3.14159265358979+3.14159265358979i) -1.40903828502376+0.15638868878130i)+(num-test (atan 3.14159265358979-3.14159265358979i) 1.40903828502376-0.15638868878130i)+(num-test (atan -3.14159265358979-3.14159265358979i) -1.40903828502376-0.15638868878130i)+(num-test (atan 3.14159265358979+2.71828182845905i) 1.38641010899673+0.15352587926173i)+(num-test (atan -3.14159265358979+2.71828182845905i) -1.38641010899673+0.15352587926173i)+(num-test (atan 3.14159265358979-2.71828182845905i) 1.38641010899673-0.15352587926173i)+(num-test (atan -3.14159265358979-2.71828182845905i) -1.38641010899673-0.15352587926173i)+(num-test (atan 3.14159265358979+1234.0i) 1.57079426371036+0.00081036769654i)+(num-test (atan -3.14159265358979+1234.0i) -1.57079426371036+0.00081036769654i)+(num-test (atan 3.14159265358979-1234.0i) 1.57079426371036-0.00081036769654i)+(num-test (atan -3.14159265358979-1234.0i) -1.57079426371036-0.00081036769654i)+(num-test (atan 2.71828182845905+0.0i) 1.21828290501728)+(num-test (atan -2.71828182845905+0.0i) -1.21828290501728)+(num-test (atan 2.71828182845905-0.0i) 1.21828290501728)+(num-test (atan -2.71828182845905-0.0i) -1.21828290501728)+(num-test (atan 2.71828182845905+0.00000001i) 1.21828290501728+0.00000000119203i)+(num-test (atan -2.71828182845905+0.00000001i) -1.21828290501728+0.00000000119203i)+(num-test (atan 2.71828182845905-0.00000001i) 1.21828290501728-0.00000000119203i)+(num-test (atan -2.71828182845905-0.00000001i) -1.21828290501728-0.00000000119203i)+(num-test (atan 2.71828182845905+1.0i) 1.25363416718071+0.10816322574795i)+(num-test (atan -2.71828182845905+1.0i) -1.25363416718071+0.10816322574795i)+(num-test (atan 2.71828182845905-1.0i) 1.25363416718071-0.10816322574795i)+(num-test (atan -2.71828182845905-1.0i) -1.25363416718071-0.10816322574795i)+(num-test (atan 2.71828182845905+3.14159265358979i) 1.40945039787275+0.17937970703436i)+(num-test (atan -2.71828182845905+3.14159265358979i) -1.40945039787275+0.17937970703436i)+(num-test (atan 2.71828182845905-3.14159265358979i) 1.40945039787275-0.17937970703436i)+(num-test (atan -2.71828182845905-3.14159265358979i) -1.40945039787275-0.17937970703436i)+(num-test (atan 2.71828182845905+2.71828182845905i) 1.38288382352616+0.17963089485802i)+(num-test (atan -2.71828182845905+2.71828182845905i) -1.38288382352616+0.17963089485802i)+(num-test (atan 2.71828182845905-2.71828182845905i) 1.38288382352616-0.17963089485802i)+(num-test (atan -2.71828182845905-2.71828182845905i) -1.38288382352616-0.17963089485802i)+(num-test (atan 2.71828182845905+1234.0i) 1.57079454169576+0.00081036901661i)+(num-test (atan -2.71828182845905+1234.0i) -1.57079454169576+0.00081036901661i)+(num-test (atan 2.71828182845905-1234.0i) 1.57079454169576-0.00081036901661i)+(num-test (atan -2.71828182845905-1234.0i) -1.57079454169576-0.00081036901661i)+(num-test (atan 1234.0+0.0i) 1.56998595420081)+(num-test (atan -1234.0+0.0i) -1.56998595420081)+(num-test (atan 1234.0-0.0i) 1.56998595420081)+(num-test (atan -1234.0-0.0i) -1.56998595420081)+(num-test (atan 1234.0+0.00000001i) 1.56998595420081+0.00000000000001i)+(num-test (atan -1234.0+0.00000001i) -1.56998595420081+0.00000000000001i)+(num-test (atan 1234.0-0.00000001i) 1.56998595420081-0.00000000000001i)+(num-test (atan -1234.0-0.00000001i) -1.56998595420081-0.00000000000001i)+(num-test (atan 1234.0+1.0i) 1.56998595473299+0.00000065670317i)+(num-test (atan -1234.0+1.0i) -1.56998595473299+0.00000065670317i)+(num-test (atan 1234.0-1.0i) 1.56998595473299-0.00000065670317i)+(num-test (atan -1234.0-1.0i) -1.56998595473299-0.00000065670317i)+(num-test (atan 1234.0+3.14159265358979i) 1.56998595945313+0.00000206308183i)+(num-test (atan -1234.0+3.14159265358979i) -1.56998595945313+0.00000206308183i)+(num-test (atan 1234.0-3.14159265358979i) 1.56998595945313-0.00000206308183i)+(num-test (atan -1234.0-3.14159265358979i) -1.56998595945313-0.00000206308183i)+(num-test (atan 1234.0+2.71828182845905i) 1.56998595813306+0.00000178509679i)+(num-test (atan -1234.0+2.71828182845905i) -1.56998595813306+0.00000178509679i)+(num-test (atan 1234.0-2.71828182845905i) 1.56998595813306-0.00000178509679i)+(num-test (atan -1234.0-2.71828182845905i) -1.56998595813306-0.00000178509679i)+(num-test (atan 1234.0+1234.0i) 1.57039114036481+0.00040518634139i)+(num-test (atan -1234.0+1234.0i) -1.57039114036481+0.00040518634139i)+(num-test (atan 1234.0-1234.0i) 1.57039114036481-0.00040518634139i)+(num-test (atan -1234.0-1234.0i) -1.57039114036481-0.00040518634139i)+(num-test (atan 6.9279836e-17) 6.9279836e-17)+(num-test (atan 1.7976931e+308) 1.5707963267949)+(num-test (atan 0 0) 0.0)+(num-test (atan 0 1.0) 0.0)+(num-test (atan 0 -1.0) our-pi)+(num-test (atan 1.0 0) (/ our-pi 2))+(num-test (atan -1.0 0) (/ our-pi -2))+(num-test (atan 0.0 0.0) 0.0)+(num-test (atan 0.0 0.00000001) 0.0)+(num-test (atan 0.0 1.0) 0.0)+(num-test (atan 0.0 our-pi) 0.0)+(num-test (atan 0.0 2.71828182845905) 0.0)+(num-test (atan 0.0 1234.0) 0.0)+(num-test (atan 0.0 1234000000.0) 0.0)+(num-test (atan 0.00000001 0.0) 1.57079632679490)+(num-test (atan 0.00000001 0.00000001) 0.78539816339745)+(num-test (atan 0.00000001 1.0) 0.00000001)+(num-test (atan 0.00000001 our-pi) 0.00000000318310)+(num-test (atan 0.00000001 2.71828182845905) 0.00000000367879)+(num-test (atan 0.00000001 1234.0) 0.00000000000810)+(num-test (atan 0.00000001 1234000000.0) 0.0)+(num-test (atan 1.0 0.0) 1.57079632679490)+(num-test (atan 1.0 0.00000001) 1.57079631679490)+(num-test (atan 1.0 1.0) 0.78539816339745)+(num-test (atan 1.0 our-pi) 0.30816907111598)+(num-test (atan 1.0 2.71828182845905) 0.35251342177762)+(num-test (atan 1.0 1234.0) 0.00081037259408)+(num-test (atan 1.0 1234000000.0) 0.00000000081037)+(num-test (atan 3.14159265358979 0.0) 1.57079632679490)+(num-test (atan 3.14159265358979 0.00000001) 1.57079632361180)+(num-test (atan 3.14159265358979 1.0) 1.26262725567891)+(num-test (atan 3.14159265358979 our-pi) 0.78539816339745)+(num-test (atan 3.14159265358979 2.71828182845905) 0.85751178635585)+(num-test (atan 3.14159265358979 1234.0) 0.00254585564530)+(num-test (atan 3.14159265358979 1234000000.0) 0.00000000254586)+(num-test (atan 2.71828182845905 0.0) 1.57079632679490)+(num-test (atan 2.71828182845905 0.00000001) 1.57079632311610)+(num-test (atan 2.71828182845905 1.0) 1.21828290501728)+(num-test (atan 2.71828182845905 our-pi) 0.71328454043905)+(num-test (atan 2.71828182845905 2.71828182845905) 0.78539816339745)+(num-test (atan 2.71828182845905 1234.0) 0.00220281801598)+(num-test (atan 2.71828182845905 1234000000.0) 0.00000000220282)+(num-test (atan 1234.0 0.0) 1.57079632679490)+(num-test (atan 1234.0 0.00000001) 1.57079632678679)+(num-test (atan 1234.0 1.0) 1.56998595420081)+(num-test (atan 1234.0 our-pi) 1.56825047114960)+(num-test (atan 1234.0 2.71828182845905) 1.56859350877892)+(num-test (atan 1234.0 1234.0) 0.78539816339745)+(num-test (atan 1234.0 1234000000.0) 0.00000100000000)+(num-test (atan 1234000000.0 0.0) 1.57079632679490)+(num-test (atan 1234000000.0 0.00000001) 1.57079632679490)+(num-test (atan 1234000000.0 1.0) 1.57079632598452)+(num-test (atan 1234000000.0 our-pi) 1.57079632424904)+(num-test (atan 1234000000.0 2.71828182845905) 1.57079632459208)+(num-test (atan 1234000000.0 1234.0) 1.57079532679490)+(num-test (atan 1234000000.0 1234000000.0) 0.78539816339745)+(num-test (atan 1234000000/3) 1.570796324363778)+(num-test (atan 0.00000001+1234000000.0i) +1.570796326794897+8.103727714748784E-10i)+(num-test (atan 3.14159265358979+1234000000.0i) +1.570796326794897+8.103727714748784E-10i)+(num-test (atan 2.71828182845905+1234000000.0i) +1.570796326794897+8.103727714748784E-10i)+(num-test (atan 1234000000.0+0.00000001i) +1.570796325984524+6.567040287478756E-27i)+(num-test (atan 1234000000.0+3.14159265358979i) +1.570796325984524+2.063096552297151E-18i)+(num-test (atan 1234000000.0+2.71828182845905i) +1.570796325984524+1.785106628021167E-18i)+(num-test (atan 1) 0.7853981633974483)+(num-test (atan 0.0e+00+0.0e+00i) 0e0+0.0i)+(num-test (atan 0.0e+00+1.19209289550781250e-07i) 0+1.1920928955078181469e-7i)+(num-test (atan 0.0e+00-1.19209289550781250e-07i) 0-1.1920928955078181469e-7i)+(num-test (atan 0.0e+00+5.0e-01i) 0+5.4930614433405484570e-1i)+(num-test (atan 0.0e+00-5.0e-01i) 0-5.4930614433405484570e-1i)+(num-test (atan 0.0e+00+2.0e+00i) 1.5707963267948966192e0+5.4930614433405484570e-1i)+(num-test (atan 0.0e+00-2.0e+00i) -1.5707963267948966192e0-5.4930614433405484570e-1i)+(num-test (atan 0.0e+00+8.3886080e+06i) 1.5707963267948966192e0+1.1920928955078181469e-7i)+(num-test (atan 0.0e+00-8.3886080e+06i) -1.5707963267948966192e0-1.1920928955078181469e-7i)+(num-test (atan 1.19209289550781250e-07+0.0e+00i) 1.1920928955078068531e-7+0.0i)+(num-test (atan -1.19209289550781250e-07+0.0e+00i) -1.1920928955078068531e-7+0.0i)+(num-test (atan 1.19209289550781250e-07+1.19209289550781250e-07i) 1.1920928955078237938e-7+1.1920928955078012062e-7i)+(num-test (atan 1.19209289550781250e-07-1.19209289550781250e-07i) 1.1920928955078237938e-7-1.1920928955078012062e-7i)+(num-test (atan -1.19209289550781250e-07+1.19209289550781250e-07i) -1.1920928955078237938e-7+1.1920928955078012062e-7i)+(num-test (atan -1.19209289550781250e-07-1.19209289550781250e-07i) -1.1920928955078237938e-7-1.1920928955078012062e-7i)+(num-test (atan 1.19209289550781250e-07+5.0e-01i) 1.5894571940103932425e-7+5.4930614433404221383e-1i)+(num-test (atan 1.19209289550781250e-07-5.0e-01i) 1.5894571940103932425e-7-5.4930614433404221383e-1i)+(num-test (atan -1.19209289550781250e-07+5.0e-01i) -1.5894571940103932425e-7+5.4930614433404221383e-1i)+(num-test (atan -1.19209289550781250e-07-5.0e-01i) -1.5894571940103932425e-7-5.4930614433404221383e-1i)+(num-test (atan 1.19209289550781250e-07+1.0e+00i) 7.8539819319977069731e-1+8.3177661667193446012e0i)+(num-test (atan 1.19209289550781250e-07-1.0e+00i) 7.8539819319977069731e-1-8.3177661667193446012e0i)+(num-test (atan -1.19209289550781250e-07+1.0e+00i) -7.8539819319977069731e-1+8.3177661667193446012e0i)+(num-test (atan -1.19209289550781250e-07-1.0e+00i) -7.8539819319977069731e-1-8.3177661667193446012e0i)+(num-test (atan 1.19209289550781250e-07+2.0e+00i) 1.5707962870584667690e0+5.4930614433405168773e-1i)+(num-test (atan 1.19209289550781250e-07-2.0e+00i) 1.5707962870584667690e0-5.4930614433405168773e-1i)+(num-test (atan -1.19209289550781250e-07+2.0e+00i) -1.5707962870584667690e0+5.4930614433405168773e-1i)+(num-test (atan -1.19209289550781250e-07-2.0e+00i) -1.5707962870584667690e0-5.4930614433405168773e-1i)+(num-test (atan 1.19209289550781250e-07+8.3886080e+06i) 1.5707963267948966192e0+1.1920928955078181469e-7i)+(num-test (atan 1.19209289550781250e-07-8.3886080e+06i) 1.5707963267948966192e0-1.1920928955078181469e-7i)+(num-test (atan -1.19209289550781250e-07+8.3886080e+06i) -1.5707963267948966192e0+1.1920928955078181469e-7i)+(num-test (atan -1.19209289550781250e-07-8.3886080e+06i) -1.5707963267948966192e0-1.1920928955078181469e-7i)+(num-test (atan 5.0e-01+0.0e+00i) 4.6364760900080611621e-1+0.0i)+(num-test (atan -5.0e-01+0.0e+00i) -4.6364760900080611621e-1+0.0i)+(num-test (atan 5.0e-01+1.19209289550781250e-07i) 4.6364760900081066369e-1+9.5367431640625072280e-8i)+(num-test (atan 5.0e-01-1.19209289550781250e-07i) 4.6364760900081066369e-1-9.5367431640625072280e-8i)+(num-test (atan -5.0e-01+1.19209289550781250e-07i) -4.6364760900081066369e-1+9.5367431640625072280e-8i)+(num-test (atan -5.0e-01-1.19209289550781250e-07i) -4.6364760900081066369e-1-9.5367431640625072280e-8i)+(num-test (atan 5.0e-01+5.0e-01i) 5.5357435889704525151e-1+4.0235947810852509365e-1i)+(num-test (atan 5.0e-01-5.0e-01i) 5.5357435889704525151e-1-4.0235947810852509365e-1i)+(num-test (atan -5.0e-01+5.0e-01i) -5.5357435889704525151e-1+4.0235947810852509365e-1i)+(num-test (atan -5.0e-01-5.0e-01i) -5.5357435889704525151e-1-4.0235947810852509365e-1i)+(num-test (atan 5.0e-01+1.0e+00i) 9.0788749496088038670e-1+7.0830333601405402006e-1i)+(num-test (atan 5.0e-01-1.0e+00i) 9.0788749496088038670e-1-7.0830333601405402006e-1i)+(num-test (atan -5.0e-01+1.0e+00i) -9.0788749496088038670e-1+7.0830333601405402006e-1i)+(num-test (atan -5.0e-01-1.0e+00i) -9.0788749496088038670e-1-7.0830333601405402006e-1i)+(num-test (atan 5.0e-01+2.0e+00i) 1.4215468610018069803e0+5.0037000005253101744e-1i)+(num-test (atan 5.0e-01-2.0e+00i) 1.4215468610018069803e0-5.0037000005253101744e-1i)+(num-test (atan -5.0e-01+2.0e+00i) -1.4215468610018069803e0+5.0037000005253101744e-1i)+(num-test (atan -5.0e-01-2.0e+00i) -1.4215468610018069803e0-5.0037000005253101744e-1i)+(num-test (atan 5.0e-01+8.3886080e+06i) 1.5707963267948895138e0+1.1920928955078139117e-7i)+(num-test (atan 5.0e-01-8.3886080e+06i) 1.5707963267948895138e0-1.1920928955078139117e-7i)+(num-test (atan -5.0e-01+8.3886080e+06i) -1.5707963267948895138e0+1.1920928955078139117e-7i)+(num-test (atan -5.0e-01-8.3886080e+06i) -1.5707963267948895138e0-1.1920928955078139117e-7i)+(num-test (atan 1.0e+00+0.0e+00i) 7.8539816339744830962e-1+0.0i)+(num-test (atan -1.0e+00+0.0e+00i) -7.8539816339744830962e-1+0.0i)+(num-test (atan 1.0e+00+1.19209289550781250e-07i) 7.8539816339745186233e-1+5.9604644775390483828e-8i)+(num-test (atan 1.0e+00-1.19209289550781250e-07i) 7.8539816339745186233e-1-5.9604644775390483828e-8i)+(num-test (atan -1.0e+00+1.19209289550781250e-07i) -7.8539816339745186233e-1+5.9604644775390483828e-8i)+(num-test (atan -1.0e+00-1.19209289550781250e-07i) -7.8539816339745186233e-1-5.9604644775390483828e-8i)+(num-test (atan 1.0e+00+5.0e-01i) 8.4757566067082902713e-1+2.3887786125685909036e-1i)+(num-test (atan 1.0e+00-5.0e-01i) 8.4757566067082902713e-1-2.3887786125685909036e-1i)+(num-test (atan -1.0e+00+5.0e-01i) -8.4757566067082902713e-1+2.3887786125685909036e-1i)+(num-test (atan -1.0e+00-5.0e-01i) -8.4757566067082902713e-1-2.3887786125685909036e-1i)+(num-test (atan 1.0e+00+1.0e+00i) 1.0172219678978513677e0+4.0235947810852509365e-1i)+(num-test (atan 1.0e+00-1.0e+00i) 1.0172219678978513677e0-4.0235947810852509365e-1i)+(num-test (atan -1.0e+00+1.0e+00i) -1.0172219678978513677e0+4.0235947810852509365e-1i)+(num-test (atan -1.0e+00-1.0e+00i) -1.0172219678978513677e0-4.0235947810852509365e-1i)+(num-test (atan 1.0e+00+2.0e+00i) 1.3389725222944935611e0+4.0235947810852509365e-1i)+(num-test (atan 1.0e+00-2.0e+00i) 1.3389725222944935611e0-4.0235947810852509365e-1i)+(num-test (atan -1.0e+00+2.0e+00i) -1.3389725222944935611e0+4.0235947810852509365e-1i)+(num-test (atan -1.0e+00-2.0e+00i) -1.3389725222944935611e0-4.0235947810852509365e-1i)+(num-test (atan 1.0e+00+8.3886080e+06i) 1.5707963267948824084e0+1.1920928955078012062e-7i)+(num-test (atan 1.0e+00-8.3886080e+06i) 1.5707963267948824084e0-1.1920928955078012062e-7i)+(num-test (atan -1.0e+00+8.3886080e+06i) -1.5707963267948824084e0+1.1920928955078012062e-7i)+(num-test (atan -1.0e+00-8.3886080e+06i) -1.5707963267948824084e0-1.1920928955078012062e-7i)+(num-test (atan 2.0e+00+0.0e+00i) 1.1071487177940905030e0+0.0i)+(num-test (atan -2.0e+00+0.0e+00i) -1.1071487177940905030e0+0.0i)+(num-test (atan 2.0e+00+1.19209289550781250e-07i) 1.1071487177940916399e0+2.3841857910156200307e-8i)+(num-test (atan 2.0e+00-1.19209289550781250e-07i) 1.1071487177940916399e0-2.3841857910156200307e-8i)+(num-test (atan -2.0e+00+1.19209289550781250e-07i) -1.1071487177940916399e0+2.3841857910156200307e-8i)+(num-test (atan -2.0e+00-1.19209289550781250e-07i) -1.1071487177940916399e0-2.3841857910156200307e-8i)+(num-test (atan 2.0e+00+5.0e-01i) 1.1265564408348223487e0+9.6415620202996167238e-2i)+(num-test (atan 2.0e+00-5.0e-01i) 1.1265564408348223487e0-9.6415620202996167238e-2i)+(num-test (atan -2.0e+00+5.0e-01i) -1.1265564408348223487e0+9.6415620202996167238e-2i)+(num-test (atan -2.0e+00-5.0e-01i) -1.1265564408348223487e0-9.6415620202996167238e-2i)+(num-test (atan 2.0e+00+1.0e+00i) 1.1780972450961724644e0+1.7328679513998632735e-1i)+(num-test (atan 2.0e+00-1.0e+00i) 1.1780972450961724644e0-1.7328679513998632735e-1i)+(num-test (atan -2.0e+00+1.0e+00i) -1.1780972450961724644e0+1.7328679513998632735e-1i)+(num-test (atan -2.0e+00-1.0e+00i) -1.1780972450961724644e0-1.7328679513998632735e-1i)+(num-test (atan 2.0e+00+2.0e+00i) 1.3112232696716351433e0+2.3887786125685909036e-1i)+(num-test (atan 2.0e+00-2.0e+00i) 1.3112232696716351433e0-2.3887786125685909036e-1i)+(num-test (atan -2.0e+00+2.0e+00i) -1.3112232696716351433e0+2.3887786125685909036e-1i)+(num-test (atan -2.0e+00-2.0e+00i) -1.3112232696716351433e0-2.3887786125685909036e-1i)+(num-test (atan 2.0e+00+8.3886080e+06i) 1.5707963267948681975e0+1.1920928955077503843e-7i)+(num-test (atan 2.0e+00-8.3886080e+06i) 1.5707963267948681975e0-1.1920928955077503843e-7i)+(num-test (atan -2.0e+00+8.3886080e+06i) -1.5707963267948681975e0+1.1920928955077503843e-7i)+(num-test (atan -2.0e+00-8.3886080e+06i) -1.5707963267948681975e0-1.1920928955077503843e-7i)+(num-test (atan 8.3886080e+06+0.0e+00i) 1.5707962075856070685e0+0.0i)+(num-test (atan -8.3886080e+06+0.0e+00i) -1.5707962075856070685e0+0.0i)+(num-test (atan 8.3886080e+06+1.19209289550781250e-07i) 1.5707962075856070685e0+1.6940658945085766040e-21i)+(num-test (atan 8.3886080e+06-1.19209289550781250e-07i) 1.5707962075856070685e0-1.6940658945085766040e-21i)+(num-test (atan -8.3886080e+06+1.19209289550781250e-07i) -1.5707962075856070685e0+1.6940658945085766040e-21i)+(num-test (atan -8.3886080e+06-1.19209289550781250e-07i) -1.5707962075856070685e0-1.6940658945085766040e-21i)+(num-test (atan 8.3886080e+06+5.0e-01i) 1.5707962075856070685e0+7.1054273576008756410e-15i)+(num-test (atan 8.3886080e+06-5.0e-01i) 1.5707962075856070685e0-7.1054273576008756410e-15i)+(num-test (atan -8.3886080e+06+5.0e-01i) -1.5707962075856070685e0+7.1054273576008756410e-15i)+(num-test (atan -8.3886080e+06-5.0e-01i) -1.5707962075856070685e0-7.1054273576008756410e-15i)+(num-test (atan 8.3886080e+06+1.0e+00i) 1.5707962075856070685e0+1.4210854715201599821e-14i)+(num-test (atan 8.3886080e+06-1.0e+00i) 1.5707962075856070685e0-1.4210854715201599821e-14i)+(num-test (atan -8.3886080e+06+1.0e+00i) -1.5707962075856070685e0+1.4210854715201599821e-14i)+(num-test (atan -8.3886080e+06-1.0e+00i) -1.5707962075856070685e0-1.4210854715201599821e-14i)+(num-test (atan 8.3886080e+06+2.0e+00i) 1.5707962075856070685e0+2.8421709430401987951e-14i)+(num-test (atan 8.3886080e+06-2.0e+00i) 1.5707962075856070685e0-2.8421709430401987951e-14i)+(num-test (atan -8.3886080e+06+2.0e+00i) -1.5707962075856070685e0+2.8421709430401987951e-14i)+(num-test (atan -8.3886080e+06-2.0e+00i) -1.5707962075856070685e0-2.8421709430401987951e-14i)+(num-test (atan 8.3886080e+06+8.3886080e+06i) 1.5707962671902518438e0+5.9604644775390483828e-8i)+(num-test (atan 8.3886080e+06-8.3886080e+06i) 1.5707962671902518438e0-5.9604644775390483828e-8i)+(num-test (atan -8.3886080e+06+8.3886080e+06i) -1.5707962671902518438e0+5.9604644775390483828e-8i)+(num-test (atan -8.3886080e+06-8.3886080e+06i) -1.5707962671902518438e0-5.9604644775390483828e-8i)+++;; -------- sqrt+(num-test (sqrt 0) 0)+(num-test (sqrt 1) 1)+(num-test (sqrt -1) 0.0+1.0i)+(num-test (sqrt 2) 1.41421356237310)+(num-test (sqrt -2) 0.0+1.41421356237310i)+(num-test (sqrt 3) 1.73205080756888)+(num-test (sqrt -3) 0.0+1.73205080756888i)+(num-test (sqrt 10) 3.16227766016838)+(num-test (sqrt -10) 0.0+3.16227766016838i)+(num-test (sqrt 1234) 35.12833614050059)+(num-test (sqrt -1234) 0.0+35.12833614050059i)+(num-test (sqrt 1234000000) 35128.33614050059259)+(num-test (sqrt -1234000000) 0.0+35128.33614050059259i)+(num-test (sqrt 500029) 707.12728698587216)+(num-test (sqrt -500029) 0.0+707.12728698587216i)+(num-test (sqrt 362880) 602.39521910453436)+(num-test (sqrt -362880) 0.0+602.39521910453436i)+(num-test (sqrt 0/1) 0)+(num-test (sqrt 0/2) 0)+(num-test (sqrt 0/3) 0)+(num-test (sqrt 0/10) 0)+(num-test (sqrt 0/1234) 0)+(num-test (sqrt 0/1234000000) 0)+(num-test (sqrt 0/500029) 0)+(num-test (sqrt 0/362880) 0)+(num-test (sqrt 1/1) 1)+(num-test (sqrt -1/1) 0.0+1.0i)+(num-test (sqrt 1/2) 0.70710678118655)+(num-test (sqrt -1/2) 0.0+0.70710678118655i)+(num-test (sqrt 1/3) 0.57735026918963)+(num-test (sqrt -1/3) 0.0+0.57735026918963i)+(num-test (sqrt 1/10) 0.31622776601684)+(num-test (sqrt -1/10) 0.0+0.31622776601684i)+(num-test (sqrt 1/1234) 0.02846704711548)+(num-test (sqrt -1/1234) 0.0+0.02846704711548i)+(num-test (sqrt 1/1234000000) 0.00002846704712)+(num-test (sqrt -1/1234000000) 0.0+0.00002846704712i)+(num-test (sqrt 1/500029) 0.00141417255196)+(num-test (sqrt -1/500029) 0.0+0.00141417255196i)+(num-test (sqrt 1/362880) 0.00166003973519)+(num-test (sqrt -1/362880) 0.0+0.00166003973519i)+(num-test (sqrt 2/1) 1.41421356237310)+(num-test (sqrt -2/1) 0.0+1.41421356237310i)+(num-test (sqrt 2/2) 1)+(num-test (sqrt -2/2) 0.0+1.0i)+(num-test (sqrt 2/3) 0.81649658092773)+(num-test (sqrt -2/3) 0.0+0.81649658092773i)+(num-test (sqrt 2/10) 0.44721359549996)+(num-test (sqrt -2/10) 0.0+0.44721359549996i)+(num-test (sqrt 2/1234) 0.04025848411142)+(num-test (sqrt -2/1234) 0.0+0.04025848411142i)+(num-test (sqrt 2/1234000000) 0.00004025848411)+(num-test (sqrt -2/1234000000) 0.0+0.00004025848411i)+(num-test (sqrt 2/500029) 0.00199994200252)+(num-test (sqrt -2/500029) 0.0+0.00199994200252i)+(num-test (sqrt 2/362880) 0.00234765070758)+(num-test (sqrt -2/362880) 0.0+0.00234765070758i)+(num-test (sqrt 3/1) 1.73205080756888)+(num-test (sqrt -3/1) 0.0+1.73205080756888i)+(num-test (sqrt 3/2) 1.22474487139159)+(num-test (sqrt -3/2) 0.0+1.22474487139159i)+(num-test (sqrt 3/3) 1)+(num-test (sqrt -3/3) 0.0+1.0i)+(num-test (sqrt 3/10) 0.54772255750517)+(num-test (sqrt -3/10) 0.0+0.54772255750517i)+(num-test (sqrt 3/1234) 0.04930637194547)+(num-test (sqrt -3/1234) 0.0+0.04930637194547i)+(num-test (sqrt 3/1234000000) 0.00004930637195)+(num-test (sqrt -3/1234000000) 0.0+0.00004930637195i)+(num-test (sqrt 3/500029) 0.00244941871067)+(num-test (sqrt -3/500029) 0.0+0.00244941871067i)+(num-test (sqrt 3/362880) 0.00287527316393)+(num-test (sqrt -3/362880) 0.0+0.00287527316393i)+(num-test (sqrt 10/1) 3.16227766016838)+(num-test (sqrt -10/1) 0.0+3.16227766016838i)+(num-test (sqrt 10/2) 2.23606797749979)+(num-test (sqrt -10/2) 0.0+2.23606797749979i)+(num-test (sqrt 10/3) 1.82574185835055)+(num-test (sqrt -10/3) 0.0+1.82574185835055i)+(num-test (sqrt 10/10) 1)+(num-test (sqrt -10/10) 0.0+1.0i)+(num-test (sqrt 10/1234) 0.09002070714424)+(num-test (sqrt -10/1234) 0.0+0.09002070714424i)+(num-test (sqrt 10/1234000000) 0.00009002070714)+(num-test (sqrt -10/1234000000) 0.0+0.00009002070714i)+(num-test (sqrt 10/500029) 0.00447200626870)+(num-test (sqrt -10/500029) 0.0+0.00447200626870i)+(num-test (sqrt 10/362880) 0.00524950656957)+(num-test (sqrt -10/362880) 0.0+0.00524950656957i)+(num-test (sqrt 1234/1) 35.12833614050059)+(num-test (sqrt -1234/1) 0.0+35.12833614050059i)+(num-test (sqrt 1234/2) 24.83948469674844)+(num-test (sqrt -1234/2) 0.0+24.83948469674844i)+(num-test (sqrt 1234/3) 20.28135432690167)+(num-test (sqrt -1234/3) 0.0+20.28135432690167i)+(num-test (sqrt 1234/10) 11.10855526159905)+(num-test (sqrt -1234/10) 0.0+11.10855526159905i)+(num-test (sqrt 1234/1234) 1)+(num-test (sqrt -1234/1234) 0.0+1.0i)+(num-test (sqrt 1234/1234000000) 0.001)+(num-test (sqrt -1234/1234000000) 0.0+0.001i)+(num-test (sqrt 1234/500029) 0.04967752876605)+(num-test (sqrt -1234/500029) 0.0+0.04967752876605i)+(num-test (sqrt 1234/362880) 0.05831443382422)+(num-test (sqrt -1234/362880) 0.0+0.05831443382422i)+(num-test (sqrt 1234000000/1) 35128.33614050059259)+(num-test (sqrt -1234000000/1) 0.0+35128.33614050059259i)+(num-test (sqrt 1234000000/2) 24839.48469674844091)+(num-test (sqrt -1234000000/2) 0.0+24839.48469674844091i)+(num-test (sqrt 1234000000/3) 20281.35432690167727)+(num-test (sqrt -1234000000/3) 0.0+20281.35432690167727i)+(num-test (sqrt 1234000000/10) 11108.55526159905276)+(num-test (sqrt -1234000000/10) 0.0+11108.55526159905276i)+(num-test (sqrt 1234000000/1234) 1000)+(num-test (sqrt -1234000000/1234) 0.0+1000.0i)+(num-test (sqrt 1234000000/1234000000) 1)+(num-test (sqrt -1234000000/1234000000) 0.0+1.0i)+(num-test (sqrt 1234000000/500029) 49.67752876605147)+(num-test (sqrt -1234000000/500029) 0.0+49.67752876605147i)+(num-test (sqrt 1234000000/362880) 58.31443382422451)+(num-test (sqrt -1234000000/362880) 0.0+58.31443382422451i)+(num-test (sqrt 500029/1) 707.12728698587216)+(num-test (sqrt -500029/1) 0.0+707.12728698587216i)+(num-test (sqrt 500029/2) 500.01449978975609)+(num-test (sqrt -500029/2) 0.0+500.01449978975609i)+(num-test (sqrt 500029/3) 408.26012949262304)+(num-test (sqrt -500029/3) 0.0+408.26012949262304i)+(num-test (sqrt 500029/10) 223.61328225308978)+(num-test (sqrt -500029/10) 0.0+223.61328225308978i)+(num-test (sqrt 500029/1234) 20.12982579526738)+(num-test (sqrt -500029/1234) 0.0+20.12982579526738i)+(num-test (sqrt 500029/1234000000) 0.02012982579527)+(num-test (sqrt -500029/1234000000) 0.0+0.02012982579527i)+(num-test (sqrt 500029/500029) 1)+(num-test (sqrt -500029/500029) 0.0+1.0i)+(num-test (sqrt 500029/362880) 1.17385939423129)+(num-test (sqrt -500029/362880) 0.0+1.17385939423129i)+(num-test (sqrt 362880/1) 602.39521910453436)+(num-test (sqrt -362880/1) 0.0+602.39521910453436i)+(num-test (sqrt 362880/2) 425.95774438317238)+(num-test (sqrt -362880/2) 0.0+425.95774438317238i)+(num-test (sqrt 362880/3) 347.79304190854651)+(num-test (sqrt -362880/3) 0.0+347.79304190854651i)+(num-test (sqrt 362880/10) 190.49409439665052)+(num-test (sqrt -362880/10) 0.0+190.49409439665052i)+(num-test (sqrt 362880/1234) 17.14841308438784)+(num-test (sqrt -362880/1234) 0.0+17.14841308438784i)+(num-test (sqrt 362880/1234000000) 0.01714841308439)+(num-test (sqrt -362880/1234000000) 0.0+0.01714841308439i)+(num-test (sqrt 362880/500029) 0.85189078429181)+(num-test (sqrt -362880/500029) 0.0+0.85189078429181i)+(num-test (sqrt 362880/362880) 1)+(num-test (sqrt -362880/362880) 0.0+1.0i)+(num-test (sqrt 0.0) 0.0)+(num-test (sqrt 0.00000001) 0.00010000000000)+(num-test (sqrt -0.00000001) 0.0+0.00010000000000i)+(num-test (sqrt 1.0) 1.0)+(num-test (sqrt -1.0) 0.0+1.0i)+(num-test (sqrt our-pi) 1.77245385090552)+(num-test (sqrt -3.14159265358979) 0.0+1.77245385090552i)+(num-test (sqrt 2.71828182845905) 1.64872127070013)+(num-test (sqrt -2.71828182845905) 0.0+1.64872127070013i)+(num-test (sqrt 1234.0) 35.12833614050059)+(num-test (sqrt -1234.0) 0.0+35.12833614050059i)+(num-test (sqrt 1234000000.0) 35128.33614050059259)+(num-test (sqrt -1234000000.0) 0.0+35128.33614050059259i)+(num-test (sqrt 0.0+0.0i) 0.0)+(num-test (sqrt -0.0+0.0i) 0.0)+(num-test (sqrt 0.0-0.0i) 0.0)+(num-test (sqrt -0.0-0.0i) 0.0)+(num-test (sqrt 0.0+0.00000001i) 0.00007071067812+0.00007071067812i)+(num-test (sqrt -0.0+0.00000001i) 0.00007071067812+0.00007071067812i)+(num-test (sqrt 0.0-0.00000001i) 0.00007071067812-0.00007071067812i)+(num-test (sqrt -0.0-0.00000001i) 0.00007071067812-0.00007071067812i)+(num-test (sqrt 0.0+1.0i) 0.70710678118655+0.70710678118655i)+(num-test (sqrt -0.0+1.0i) 0.70710678118655+0.70710678118655i)+(num-test (sqrt 0.0-1.0i) 0.70710678118655-0.70710678118655i)+(num-test (sqrt -0.0-1.0i) 0.70710678118655-0.70710678118655i)+(num-test (sqrt 0.0+3.14159265358979i) 1.25331413731550+1.25331413731550i)+(num-test (sqrt -0.0+3.14159265358979i) 1.25331413731550+1.25331413731550i)+(num-test (sqrt 0.0-3.14159265358979i) 1.25331413731550-1.25331413731550i)+(num-test (sqrt -0.0-3.14159265358979i) 1.25331413731550-1.25331413731550i)+(num-test (sqrt 0.0+2.71828182845905i) 1.16582199079856+1.16582199079856i)+(num-test (sqrt -0.0+2.71828182845905i) 1.16582199079856+1.16582199079856i)+(num-test (sqrt 0.0-2.71828182845905i) 1.16582199079856-1.16582199079856i)+(num-test (sqrt -0.0-2.71828182845905i) 1.16582199079856-1.16582199079856i)+(num-test (sqrt 0.0+1234.0i) 24.83948469674844+24.83948469674844i)+(num-test (sqrt -0.0+1234.0i) 24.83948469674844+24.83948469674844i)+(num-test (sqrt 0.0-1234.0i) 24.83948469674844-24.83948469674844i)+(num-test (sqrt -0.0-1234.0i) 24.83948469674844-24.83948469674844i)+(num-test (sqrt 0.0+1234000000.0i) 24839.48469674844091+24839.48469674844091i)+(num-test (sqrt -0.0+1234000000.0i) 24839.48469674844091+24839.48469674844091i)+(num-test (sqrt 0.0-1234000000.0i) 24839.48469674844091-24839.48469674844091i)+(num-test (sqrt -0.0-1234000000.0i) 24839.48469674844091-24839.48469674844091i)+(num-test (sqrt 0.00000001+0.0i) 0.00010000000000)+(num-test (sqrt -0.00000001+0.0i) 0.0+0.00010000000000i)+(num-test (sqrt 0.00000001-0.0i) 0.00010000000000)+(num-test (sqrt -0.00000001-0.0i) 0.0+0.00010000000000i)+(num-test (sqrt 0.00000001+0.00000001i) 0.00010986841135+0.00004550898606i)+(num-test (sqrt -0.00000001+0.00000001i) 0.00004550898606+0.00010986841135i)+(num-test (sqrt 0.00000001-0.00000001i) 0.00010986841135-0.00004550898606i)+(num-test (sqrt -0.00000001-0.00000001i) 0.00004550898606-0.00010986841135i)+(num-test (sqrt 0.00000001+1.0i) 0.70710678472208+0.70710677765101i)+(num-test (sqrt -0.00000001+1.0i) 0.70710677765101+0.70710678472208i)+(num-test (sqrt 0.00000001-1.0i) 0.70710678472208-0.70710677765101i)+(num-test (sqrt -0.00000001-1.0i) 0.70710677765101-0.70710678472208i)+(num-test (sqrt 0.00000001+3.14159265358979i) 1.25331413931021+1.25331413532079i)+(num-test (sqrt -0.00000001+3.14159265358979i) 1.25331413532079+1.25331413931021i)+(num-test (sqrt 0.00000001-3.14159265358979i) 1.25331413931021-1.25331413532079i)+(num-test (sqrt -0.00000001-3.14159265358979i) 1.25331413532079-1.25331413931021i)+(num-test (sqrt 0.00000001+2.71828182845905i) 1.16582199294297+1.16582198865415i)+(num-test (sqrt -0.00000001+2.71828182845905i) 1.16582198865415+1.16582199294297i)+(num-test (sqrt 0.00000001-2.71828182845905i) 1.16582199294297-1.16582198865415i)+(num-test (sqrt -0.00000001-2.71828182845905i) 1.16582198865415-1.16582199294297i)+(num-test (sqrt 0.00000001+1234.0i) 24.83948469684909+24.83948469664779i)+(num-test (sqrt -0.00000001+1234.0i) 24.83948469664779+24.83948469684909i)+(num-test (sqrt 0.00000001-1234.0i) 24.83948469684909-24.83948469664779i)+(num-test (sqrt -0.00000001-1234.0i) 24.83948469664779-24.83948469684909i)+(num-test (sqrt 0.00000001+1234000000.0i) 24839.48469674844091+24839.48469674844091i)+(num-test (sqrt -0.00000001+1234000000.0i) 24839.48469674844091+24839.48469674844091i)+(num-test (sqrt 0.00000001-1234000000.0i) 24839.48469674844091-24839.48469674844091i)+(num-test (sqrt -0.00000001-1234000000.0i) 24839.48469674844091-24839.48469674844091i)+(num-test (sqrt 1.0+0.0i) 1.0)+(num-test (sqrt -1.0+0.0i) 0.0+1.0i)+(num-test (sqrt 1.0-0.0i) 1.0)+(num-test (sqrt -1.0-0.0i) 0.0+1.0i)+(num-test (sqrt 1.0+0.00000001i) 1.0+0.00000000500000i)+(num-test (sqrt -1.0+0.00000001i) 0.00000000500000+1.0i)+(num-test (sqrt 1.0-0.00000001i) 1.0-0.00000000500000i)+(num-test (sqrt -1.0-0.00000001i) 0.00000000500000-1.0i)+(num-test (sqrt 1.0+1.0i) 1.09868411346781+0.45508986056223i)+(num-test (sqrt -1.0+1.0i) 0.45508986056223+1.09868411346781i)+(num-test (sqrt 1.0-1.0i) 1.09868411346781-0.45508986056223i)+(num-test (sqrt -1.0-1.0i) 0.45508986056223-1.09868411346781i)+(num-test (sqrt 1.0+3.14159265358979i) 1.46576060621706+1.07165953303174i)+(num-test (sqrt -1.0+3.14159265358979i) 1.07165953303174+1.46576060621706i)+(num-test (sqrt 1.0-3.14159265358979i) 1.46576060621706-1.07165953303174i)+(num-test (sqrt -1.0-3.14159265358979i) 1.07165953303174-1.46576060621706i)+(num-test (sqrt 1.0+2.71828182845905i) 1.39577697566445+0.97375220964833i)+(num-test (sqrt -1.0+2.71828182845905i) 0.97375220964833+1.39577697566445i)+(num-test (sqrt 1.0-2.71828182845905i) 1.39577697566445-0.97375220964833i)+(num-test (sqrt -1.0-2.71828182845905i) 0.97375220964833-1.39577697566445i)+(num-test (sqrt 1.0+1234.0i) 24.84955135597340+24.82942211557006i)+(num-test (sqrt -1.0+1234.0i) 24.82942211557006+24.84955135597340i)+(num-test (sqrt 1.0-1234.0i) 24.84955135597340-24.82942211557006i)+(num-test (sqrt -1.0-1234.0i) 24.82942211557006-24.84955135597340i)+(num-test (sqrt 1.0+1234000000.0i) 24839.48470681306208+24839.48468668381975i)+(num-test (sqrt -1.0+1234000000.0i) 24839.48468668381975+24839.48470681306208i)+(num-test (sqrt 1.0-1234000000.0i) 24839.48470681306208-24839.48468668381975i)+(num-test (sqrt -1.0-1234000000.0i) 24839.48468668381975-24839.48470681306208i)+(num-test (sqrt 3.14159265358979+0.0i) 1.77245385090552)+(num-test (sqrt -3.14159265358979+0.0i) 0.0+1.77245385090552i)+(num-test (sqrt 3.14159265358979-0.0i) 1.77245385090552)+(num-test (sqrt -3.14159265358979-0.0i) 0.0+1.77245385090552i)+(num-test (sqrt 3.14159265358979+0.00000001i) 1.77245385090552+0.00000000282095i)+(num-test (sqrt -3.14159265358979+0.00000001i) 0.00000000282095+1.77245385090552i)+(num-test (sqrt 3.14159265358979-0.00000001i) 1.77245385090552-0.00000000282095i)+(num-test (sqrt -3.14159265358979-0.00000001i) 0.00000000282095-1.77245385090552i)+(num-test (sqrt 3.14159265358979+1.0i) 1.79422698718214+0.27867154132224i)+(num-test (sqrt -3.14159265358979+1.0i) 0.27867154132224+1.79422698718214i)+(num-test (sqrt 3.14159265358979-1.0i) 1.79422698718214-0.27867154132224i)+(num-test (sqrt -3.14159265358979-1.0i) 0.27867154132224-1.79422698718214i)+(num-test (sqrt 3.14159265358979+3.14159265358979i) 1.94736688784473+0.80662577586157i)+(num-test (sqrt -3.14159265358979+3.14159265358979i) 0.80662577586157+1.94736688784473i)+(num-test (sqrt 3.14159265358979-3.14159265358979i) 1.94736688784473-0.80662577586157i)+(num-test (sqrt -3.14159265358979-3.14159265358979i) 0.80662577586157-1.94736688784473i)+(num-test (sqrt 3.14159265358979+2.71828182845905i) 1.90996689184696+0.71160443672153i)+(num-test (sqrt -3.14159265358979+2.71828182845905i) 0.71160443672153+1.90996689184696i)+(num-test (sqrt 3.14159265358979-2.71828182845905i) 1.90996689184696-0.71160443672153i)+(num-test (sqrt -3.14159265358979-2.71828182845905i) 0.71160443672153-1.90996689184696i)+(num-test (sqrt 3.14159265358979+1234.0i) 24.87112373493049+24.80788590719961i)+(num-test (sqrt -3.14159265358979+1234.0i) 24.80788590719961+24.87112373493049i)+(num-test (sqrt 3.14159265358979-1234.0i) 24.87112373493049-24.80788590719961i)+(num-test (sqrt -3.14159265358979-1234.0i) 24.80788590719961-24.87112373493049i)+(num-test (sqrt 3.14159265358979+1234000000.0i) 24839.48472836738074+24839.48466512950108i)+(num-test (sqrt -3.14159265358979+1234000000.0i) 24839.48466512950108+24839.48472836738074i)+(num-test (sqrt 3.14159265358979-1234000000.0i) 24839.48472836738074-24839.48466512950108i)+(num-test (sqrt -3.14159265358979-1234000000.0i) 24839.48466512950108-24839.48472836738074i)+(num-test (sqrt 2.71828182845905+0.0i) 1.64872127070013)+(num-test (sqrt -2.71828182845905+0.0i) 0.0+1.64872127070013i)+(num-test (sqrt 2.71828182845905-0.0i) 1.64872127070013)+(num-test (sqrt -2.71828182845905-0.0i) 0.0+1.64872127070013i)+(num-test (sqrt 2.71828182845905+0.00000001i) 1.64872127070013+0.00000000303265i)+(num-test (sqrt -2.71828182845905+0.00000001i) 0.00000000303265+1.64872127070013i)+(num-test (sqrt 2.71828182845905-0.00000001i) 1.64872127070013-0.00000000303265i)+(num-test (sqrt -2.71828182845905-0.00000001i) 0.00000000303265-1.64872127070013i)+(num-test (sqrt 2.71828182845905+1.0i) 1.67551015515410+0.29841657387867i)+(num-test (sqrt -2.71828182845905+1.0i) 0.29841657387867+1.67551015515410i)+(num-test (sqrt 2.71828182845905-1.0i) 1.67551015515410-0.29841657387867i)+(num-test (sqrt -2.71828182845905-1.0i) 0.29841657387867-1.67551015515410i)+(num-test (sqrt 2.71828182845905+3.14159265358979i) 1.85373086379501+0.84737021833856i)+(num-test (sqrt -2.71828182845905+3.14159265358979i) 0.84737021833856+1.85373086379501i)+(num-test (sqrt 2.71828182845905-3.14159265358979i) 1.85373086379501-0.84737021833856i)+(num-test (sqrt -2.71828182845905-3.14159265358979i) 0.84737021833856-1.85373086379501i)+(num-test (sqrt 2.71828182845905+2.71828182845905i) 1.81142386765469+0.75031633318890i)+(num-test (sqrt -2.71828182845905+2.71828182845905i) 0.75031633318890+1.81142386765469i)+(num-test (sqrt 2.71828182845905-2.71828182845905i) 1.81142386765469-0.75031633318890i)+(num-test (sqrt -2.71828182845905-2.71828182845905i) 0.75031633318890-1.81142386765469i)+(num-test (sqrt 2.71828182845905+1234.0i) 24.86685822304219+24.81214130333015i)+(num-test (sqrt -2.71828182845905+1234.0i) 24.81214130333015+24.86685822304219i)+(num-test (sqrt 2.71828182845905-1234.0i) 24.86685822304219-24.81214130333015i)+(num-test (sqrt -2.71828182845905-1234.0i) 24.81214130333015-24.86685822304219i)+(num-test (sqrt 2.71828182845905+1234000000.0i) 24839.48472410691829+24839.48466938996353i)+(num-test (sqrt -2.71828182845905+1234000000.0i) 24839.48466938996353+24839.48472410691829i)+(num-test (sqrt 2.71828182845905-1234000000.0i) 24839.48472410691829-24839.48466938996353i)+(num-test (sqrt -2.71828182845905-1234000000.0i) 24839.48466938996353-24839.48472410691829i)+(num-test (sqrt 1234.0+0.0i) 35.12833614050059)+(num-test (sqrt -1234.0+0.0i) 0.0+35.12833614050059i)+(num-test (sqrt 1234.0-0.0i) 35.12833614050059)+(num-test (sqrt -1234.0-0.0i) 0.0+35.12833614050059i)+(num-test (sqrt 1234.0+0.00000001i) 35.12833614050059+0.00000000014234i)+(num-test (sqrt -1234.0+0.00000001i) 0.00000000014234+35.12833614050059i)+(num-test (sqrt 1234.0-0.00000001i) 35.12833614050059-0.00000000014234i)+(num-test (sqrt -1234.0-0.00000001i) 0.00000000014234-35.12833614050059i)+(num-test (sqrt 1234.0+1.0i) 35.12833902411499+0.01423352238934i)+(num-test (sqrt -1234.0+1.0i) 0.01423352238934+35.12833902411499i)+(num-test (sqrt 1234.0-1.0i) 35.12833902411499-0.01423352238934i)+(num-test (sqrt -1234.0-1.0i) 0.01423352238934-35.12833902411499i)+(num-test (sqrt 1234.0+3.14159265358979i) 35.12836460058208+0.04471589681601i)+(num-test (sqrt -1234.0+3.14159265358979i) 0.04471589681601+35.12836460058208i)+(num-test (sqrt 1234.0-3.14159265358979i) 35.12836460058208-0.04471589681601i)+(num-test (sqrt -1234.0-3.14159265358979i) 0.04471589681601-35.12836460058208i)+(num-test (sqrt 1234.0+2.71828182845905i) 35.12835744766116+0.03869070497402i)+(num-test (sqrt -1234.0+2.71828182845905i) 0.03869070497402+35.12835744766116i)+(num-test (sqrt 1234.0-2.71828182845905i) 35.12835744766116-0.03869070497402i)+(num-test (sqrt -1234.0-2.71828182845905i) 0.03869070497402-35.12835744766116i)+(num-test (sqrt 1234.0+1234.0i) 38.59494485012512+15.98654959596347i)+(num-test (sqrt -1234.0+1234.0i) 15.98654959596347+38.59494485012512i)+(num-test (sqrt 1234.0-1234.0i) 38.59494485012512-15.98654959596347i)+(num-test (sqrt -1234.0-1234.0i) 15.98654959596347-38.59494485012512i)+(num-test (sqrt 1234.0+1234000000.0i) 24839.49711649389428+24839.47227700919757i)+(num-test (sqrt -1234.0+1234000000.0i) 24839.47227700919757+24839.49711649389428i)+(num-test (sqrt 1234.0-1234000000.0i) 24839.49711649389428-24839.47227700919757i)+(num-test (sqrt -1234.0-1234000000.0i) 24839.47227700919757-24839.49711649389428i)+(num-test (sqrt 1234000000.0+0.0i) 35128.33614050059259)+(num-test (sqrt -1234000000.0+0.0i) 0.0+35128.33614050059259i)+(num-test (sqrt 1234000000.0-0.0i) 35128.33614050059259)+(num-test (sqrt -1234000000.0-0.0i) 0.0+35128.33614050059259i)+(num-test (sqrt 1234000000.0+0.00000001i) 35128.33614050059259+0.00000000000014i)+(num-test (sqrt -1234000000.0+0.00000001i) 0.00000000000014+35128.33614050059259i)+(num-test (sqrt 1234000000.0-0.00000001i) 35128.33614050059259-0.00000000000014i)+(num-test (sqrt -1234000000.0-0.00000001i) 0.00000000000014-35128.33614050059259i)+(num-test (sqrt 1234000000.0+1.0i) 35128.33614050059259+0.00001423352356i)+(num-test (sqrt -1234000000.0+1.0i) 0.00001423352356+35128.33614050059259i)+(num-test (sqrt 1234000000.0-1.0i) 35128.33614050059259-0.00001423352356i)+(num-test (sqrt -1234000000.0-1.0i) 0.00001423352356-35128.33614050059259i)+(num-test (sqrt 1234000000.0+3.14159265358979i) 35128.33614050059259+0.00004471593304i)+(num-test (sqrt -1234000000.0+3.14159265358979i) 0.00004471593304+35128.33614050059259i)+(num-test (sqrt 1234000000.0-3.14159265358979i) 35128.33614050059259-0.00004471593304i)+(num-test (sqrt -1234000000.0-3.14159265358979i) 0.00004471593304-35128.33614050059259i)+(num-test (sqrt 1234000000.0+2.71828182845905i) 35128.33614050059259+0.00003869072844i)+(num-test (sqrt -1234000000.0+2.71828182845905i) 0.00003869072844+35128.33614050059259i)+(num-test (sqrt 1234000000.0-2.71828182845905i) 35128.33614050059259-0.00003869072844i)+(num-test (sqrt -1234000000.0-2.71828182845905i) 0.00003869072844-35128.33614050059259i)+(num-test (sqrt 1234000000.0+1234.0i) 35128.33614050497999+0.01756416807025i)+(num-test (sqrt -1234000000.0+1234.0i) 0.01756416807025+35128.33614050497999i)+(num-test (sqrt 1234000000.0-1234.0i) 35128.33614050497999-0.01756416807025i)+(num-test (sqrt -1234000000.0-1234.0i) 0.01756416807025-35128.33614050497999i)+(num-test (sqrt 1234000000.0+1234000000.0i) 38594.94485012512450+15986.54959596346634i)+(num-test (sqrt -1234000000.0+1234000000.0i) 15986.54959596346634+38594.94485012512450i)+(num-test (sqrt 1234000000.0-1234000000.0i) 38594.94485012512450-15986.54959596346634i)+(num-test (sqrt -1234000000.0-1234000000.0i) 15986.54959596346634-38594.94485012512450i)+(num-test (sqrt 2.2250739e-308) 1.4916681e-154)+(num-test (sqrt 1.7976931e+308) 1.3407808e+154)+(num-test (sqrt 0.0e+00+0.0e+00i) 0e0+0.0i)+(num-test (sqrt 0.0e+00+1.19209289550781250e-07i) 2.44140625e-4+2.44140625e-4i)+(num-test (sqrt 0.0e+00-1.19209289550781250e-07i) 2.44140625e-4-2.44140625e-4i)+(num-test (sqrt 0.0e+00+5.0e-01i) 5e-1+5e-1i)+(num-test (sqrt 0.0e+00-5.0e-01i) 5e-1-5e-1i)+(num-test (sqrt 0.0e+00+1.0e+00i) 7.0710678118654752440e-1+7.0710678118654752440e-1i)+(num-test (sqrt 0.0e+00-1.0e+00i) 7.0710678118654752440e-1-7.0710678118654752440e-1i)+(num-test (sqrt 0.0e+00+2.0e+00i) 1+1i)+(num-test (sqrt 0.0e+00-2.0e+00i) 1-1i)+(num-test (sqrt 0.0e+00+8.3886080e+06i) 2048+2048i)+(num-test (sqrt 0.0e+00-8.3886080e+06i) 2048-2048i)+(num-test (sqrt 1.19209289550781250e-07+0.0e+00i) 3.4526698300124390840e-4+0.0i)+(num-test (sqrt -1.19209289550781250e-07+0.0e+00i) 0+3.4526698300124390840e-4i)+(num-test (sqrt 1.19209289550781250e-07+1.19209289550781250e-07i) 3.7933934912842707699e-4+1.5712750315077700799e-4i)+(num-test (sqrt 1.19209289550781250e-07-1.19209289550781250e-07i) 3.7933934912842707699e-4-1.5712750315077700799e-4i)+(num-test (sqrt -1.19209289550781250e-07+1.19209289550781250e-07i) 1.5712750315077700799e-4+3.7933934912842707699e-4i)+(num-test (sqrt -1.19209289550781250e-07-1.19209289550781250e-07i) 1.5712750315077700799e-4-3.7933934912842707699e-4i)+(num-test (sqrt 1.19209289550781250e-07+5.0e-01i) 5.0000005960464832810e-1+4.9999994039535877732e-1i)+(num-test (sqrt 1.19209289550781250e-07-5.0e-01i) 5.0000005960464832810e-1-4.9999994039535877732e-1i)+(num-test (sqrt -1.19209289550781250e-07+5.0e-01i) 4.9999994039535877732e-1+5.0000005960464832810e-1i)+(num-test (sqrt -1.19209289550781250e-07-5.0e-01i) 4.9999994039535877732e-1-5.0000005960464832810e-1i)+(num-test (sqrt 1.19209289550781250e-07+1.0e+00i) 7.0710682333339729137e-1+7.0710673903970026958e-1i)+(num-test (sqrt 1.19209289550781250e-07-1.0e+00i) 7.0710682333339729137e-1-7.0710673903970026958e-1i)+(num-test (sqrt -1.19209289550781250e-07+1.0e+00i) 7.0710673903970026958e-1+7.0710682333339729137e-1i)+(num-test (sqrt -1.19209289550781250e-07-1.0e+00i) 7.0710673903970026958e-1-7.0710682333339729137e-1i)+(num-test (sqrt 1.19209289550781250e-07+2.0e+00i) 1.0000000298023228318e0+9.9999997019767805639e-1i)+(num-test (sqrt 1.19209289550781250e-07-2.0e+00i) 1.0000000298023228318e0-9.9999997019767805639e-1i)+(num-test (sqrt -1.19209289550781250e-07+2.0e+00i) 9.9999997019767805639e-1+1.0000000298023228318e0i)+(num-test (sqrt -1.19209289550781250e-07-2.0e+00i) 9.9999997019767805639e-1-1.0000000298023228318e0i)+(num-test (sqrt 1.19209289550781250e-07+8.3886080e+06i) 2.0480000000000145519e3+2.0479999999999854481e3i)+(num-test (sqrt 1.19209289550781250e-07-8.3886080e+06i) 2.0480000000000145519e3-2.0479999999999854481e3i)+(num-test (sqrt -1.19209289550781250e-07+8.3886080e+06i) 2.0479999999999854481e3+2.0480000000000145519e3i)+(num-test (sqrt -1.19209289550781250e-07-8.3886080e+06i) 2.0479999999999854481e3-2.0480000000000145519e3i)+(num-test (sqrt 5.0e-01+0.0e+00i) 7.0710678118654752440e-1+0.0i)+(num-test (sqrt -5.0e-01+0.0e+00i) 0+7.0710678118654752440e-1i)+(num-test (sqrt 5.0e-01+1.19209289550781250e-07i) 7.0710678118655254870e-1+8.4293697021787464631e-8i)+(num-test (sqrt 5.0e-01-1.19209289550781250e-07i) 7.0710678118655254870e-1-8.4293697021787464631e-8i)+(num-test (sqrt -5.0e-01+1.19209289550781250e-07i) 8.4293697021787464631e-8+7.0710678118655254870e-1i)+(num-test (sqrt -5.0e-01-1.19209289550781250e-07i) 8.4293697021787464631e-8-7.0710678118655254870e-1i)+(num-test (sqrt 5.0e-01+5.0e-01i) 7.7688698701501865367e-1+3.2179712645279131237e-1i)+(num-test (sqrt 5.0e-01-5.0e-01i) 7.7688698701501865367e-1-3.2179712645279131237e-1i)+(num-test (sqrt -5.0e-01+5.0e-01i) 3.2179712645279131237e-1+7.7688698701501865367e-1i)+(num-test (sqrt -5.0e-01-5.0e-01i) 3.2179712645279131237e-1-7.7688698701501865367e-1i)+(num-test (sqrt 5.0e-01+1.0e+00i) 8.9945371997393363613e-1+5.5589297025142117199e-1i)+(num-test (sqrt 5.0e-01-1.0e+00i) 8.9945371997393363613e-1-5.5589297025142117199e-1i)+(num-test (sqrt -5.0e-01+1.0e+00i) 5.5589297025142117199e-1+8.9945371997393363613e-1i)+(num-test (sqrt -5.0e-01-1.0e+00i) 5.5589297025142117199e-1-8.9945371997393363613e-1i)+(num-test (sqrt 5.0e-01+2.0e+00i) 1.1317139242778694103e0+8.8361553087551326576e-1i)+(num-test (sqrt 5.0e-01-2.0e+00i) 1.1317139242778694103e0-8.8361553087551326576e-1i)+(num-test (sqrt -5.0e-01+2.0e+00i) 8.8361553087551326576e-1+1.1317139242778694103e0i)+(num-test (sqrt -5.0e-01-2.0e+00i) 8.8361553087551326576e-1-1.1317139242778694103e0i)+(num-test (sqrt 5.0e-01+8.3886080e+06i) 2.0480000610351571595e3+2.0479999389648446595e3i)+(num-test (sqrt 5.0e-01-8.3886080e+06i) 2.0480000610351571595e3-2.0479999389648446595e3i)+(num-test (sqrt -5.0e-01+8.3886080e+06i) 2.0479999389648446595e3+2.0480000610351571595e3i)+(num-test (sqrt -5.0e-01-8.3886080e+06i) 2.0479999389648446595e3-2.0480000610351571595e3i)+(num-test (sqrt 1.0e+00+0.0e+00i) 1e0+0.0i)+(num-test (sqrt -1.0e+00+0.0e+00i) 0+1i)+(num-test (sqrt 1.0e+00+1.19209289550781250e-07i) 1.0000000000000017764e0+5.9604644775390519121e-8i)+(num-test (sqrt 1.0e+00-1.19209289550781250e-07i) 1.0000000000000017764e0-5.9604644775390519121e-8i)+(num-test (sqrt -1.0e+00+1.19209289550781250e-07i) 5.9604644775390519121e-8+1.0000000000000017764e0i)+(num-test (sqrt -1.0e+00-1.19209289550781250e-07i) 5.9604644775390519121e-8-1.0000000000000017764e0i)+(num-test (sqrt 1.0e+00+5.0e-01i) 1.0290855136357461252e0+2.4293413587832283909e-1i)+(num-test (sqrt 1.0e+00-5.0e-01i) 1.0290855136357461252e0-2.4293413587832283909e-1i)+(num-test (sqrt -1.0e+00+5.0e-01i) 2.4293413587832283909e-1+1.0290855136357461252e0i)+(num-test (sqrt -1.0e+00-5.0e-01i) 2.4293413587832283909e-1-1.0290855136357461252e0i)+(num-test (sqrt 1.0e+00+1.0e+00i) 1.0986841134678099660e0+4.5508986056222734130e-1i)+(num-test (sqrt 1.0e+00-1.0e+00i) 1.0986841134678099660e0-4.5508986056222734130e-1i)+(num-test (sqrt -1.0e+00+1.0e+00i) 4.5508986056222734130e-1+1.0986841134678099660e0i)+(num-test (sqrt -1.0e+00-1.0e+00i) 4.5508986056222734130e-1-1.0986841134678099660e0i)+(num-test (sqrt 1.0e+00+2.0e+00i) 1.2720196495140689643e0+7.8615137775742328607e-1i)+(num-test (sqrt 1.0e+00-2.0e+00i) 1.2720196495140689643e0-7.8615137775742328607e-1i)+(num-test (sqrt -1.0e+00+2.0e+00i) 7.8615137775742328607e-1+1.2720196495140689643e0i)+(num-test (sqrt -1.0e+00-2.0e+00i) 7.8615137775742328607e-1-1.2720196495140689643e0i)+(num-test (sqrt 1.0e+00+8.3886080e+06i) 2.0480001220703161380e3+2.0479998779296911380e3i)+(num-test (sqrt 1.0e+00-8.3886080e+06i) 2.0480001220703161380e3-2.0479998779296911380e3i)+(num-test (sqrt -1.0e+00+8.3886080e+06i) 2.0479998779296911380e3+2.0480001220703161380e3i)+(num-test (sqrt -1.0e+00-8.3886080e+06i) 2.0479998779296911380e3-2.0480001220703161380e3i)+(num-test (sqrt 2.0e+00+0.0e+00i) 1.4142135623730950488e0+0.0i)+(num-test (sqrt -2.0e+00+0.0e+00i) 0+1.4142135623730950488e0i)+(num-test (sqrt 2.0e+00+1.19209289550781250e-07i) 1.4142135623730956768e0+4.2146848510894013070e-8i)+(num-test (sqrt 2.0e+00-1.19209289550781250e-07i) 1.4142135623730956768e0-4.2146848510894013070e-8i)+(num-test (sqrt -2.0e+00+1.19209289550781250e-07i) 4.2146848510894013070e-8+1.4142135623730956768e0i)+(num-test (sqrt -2.0e+00-1.19209289550781250e-07i) 4.2146848510894013070e-8-1.4142135623730956768e0i)+(num-test (sqrt 2.0e+00+5.0e-01i) 1.4250531240639470060e0+1.7543205637629383228e-1i)+(num-test (sqrt 2.0e+00-5.0e-01i) 1.4250531240639470060e0-1.7543205637629383228e-1i)+(num-test (sqrt -2.0e+00+5.0e-01i) 1.7543205637629383228e-1+1.4250531240639470060e0i)+(num-test (sqrt -2.0e+00-5.0e-01i) 1.7543205637629383228e-1-1.4250531240639470060e0i)+(num-test (sqrt 2.0e+00+1.0e+00i) 1.4553466902253548081e0+3.4356074972251246414e-1i)+(num-test (sqrt 2.0e+00-1.0e+00i) 1.4553466902253548081e0-3.4356074972251246414e-1i)+(num-test (sqrt -2.0e+00+1.0e+00i) 3.4356074972251246414e-1+1.4553466902253548081e0i)+(num-test (sqrt -2.0e+00-1.0e+00i) 3.4356074972251246414e-1-1.4553466902253548081e0i)+(num-test (sqrt 2.0e+00+2.0e+00i) 1.5537739740300373073e0+6.4359425290558262474e-1i)+(num-test (sqrt 2.0e+00-2.0e+00i) 1.5537739740300373073e0-6.4359425290558262474e-1i)+(num-test (sqrt -2.0e+00+2.0e+00i) 6.4359425290558262474e-1+1.5537739740300373073e0i)+(num-test (sqrt -2.0e+00-2.0e+00i) 6.4359425290558262474e-1-1.5537739740300373073e0i)+(num-test (sqrt 2.0e+00+8.3886080e+06i) 2.0480002441406395519e3+2.0479997558593895519e3i)+(num-test (sqrt 2.0e+00-8.3886080e+06i) 2.0480002441406395519e3-2.0479997558593895519e3i)+(num-test (sqrt -2.0e+00+8.3886080e+06i) 2.0479997558593895519e3+2.0480002441406395519e3i)+(num-test (sqrt -2.0e+00-8.3886080e+06i) 2.0479997558593895519e3-2.0480002441406395519e3i)+(num-test (sqrt 8.3886080e+06+0.0e+00i) 2.8963093757400986599e3+0.0i)+(num-test (sqrt -8.3886080e+06+0.0e+00i) 0+2.8963093757400986599e3i)+(num-test (sqrt 8.3886080e+06+1.19209289550781250e-07i) 2.8963093757400986599e3+2.0579515874459976458e-11i)+(num-test (sqrt 8.3886080e+06-1.19209289550781250e-07i) 2.8963093757400986599e3-2.0579515874459976458e-11i)+(num-test (sqrt -8.3886080e+06+1.19209289550781250e-07i) 2.0579515874459976458e-11+2.8963093757400986599e3i)+(num-test (sqrt -8.3886080e+06-1.19209289550781250e-07i) 2.0579515874459976458e-11-2.8963093757400986599e3i)+(num-test (sqrt 8.3886080e+06+5.0e-01i) 2.8963093757400999462e3+8.6316745750310938767e-5i)+(num-test (sqrt 8.3886080e+06-5.0e-01i) 2.8963093757400999462e3-8.6316745750310938767e-5i)+(num-test (sqrt -8.3886080e+06+5.0e-01i) 8.6316745750310938767e-5+2.8963093757400999462e3i)+(num-test (sqrt -8.3886080e+06-5.0e-01i) 8.6316745750310938767e-5-2.8963093757400999462e3i)+(num-test (sqrt 8.3886080e+06+1.0e+00i) 2.8963093757401038048e3+1.7263349150062164754e-4i)+(num-test (sqrt 8.3886080e+06-1.0e+00i) 2.8963093757401038048e3-1.7263349150062164754e-4i)+(num-test (sqrt -8.3886080e+06+1.0e+00i) 1.7263349150062164754e-4+2.8963093757401038048e3i)+(num-test (sqrt -8.3886080e+06-1.0e+00i) 1.7263349150062164754e-4-2.8963093757401038048e3i)+(num-test (sqrt 8.3886080e+06+2.0e+00i) 2.8963093757401192395e3+3.4526698300124145513e-4i)+(num-test (sqrt 8.3886080e+06-2.0e+00i) 2.8963093757401192395e3-3.4526698300124145513e-4i)+(num-test (sqrt -8.3886080e+06+2.0e+00i) 3.4526698300124145513e-4+2.8963093757401192395e3i)+(num-test (sqrt -8.3886080e+06-2.0e+00i) 3.4526698300124145513e-4-2.8963093757401192395e3i)+(num-test (sqrt 8.3886080e+06+8.3886080e+06i) 3.1821290988135164054e3+1.3180810299506332155e3i)+(num-test (sqrt 8.3886080e+06-8.3886080e+06i) 3.1821290988135164054e3-1.3180810299506332155e3i)+(num-test (sqrt -8.3886080e+06+8.3886080e+06i) 1.3180810299506332155e3+3.1821290988135164054e3i)+(num-test (sqrt -8.3886080e+06-8.3886080e+06i) 1.3180810299506332155e3-3.1821290988135164054e3i)+(num-test (sqrt -1.0e+01) 0+3.1622776601683793320e0i)+(num-test (sqrt -2.0e+00) 0+1.4142135623730950488e0i)+(num-test (sqrt -1.0e+00) 0+1i)+(num-test (sqrt -7.50e-01) 0+8.6602540378443864676e-1i)+(num-test (sqrt -5.0e-01) 0+7.0710678118654752440e-1i)+(num-test (sqrt -1.250e-01) 0+3.5355339059327376220e-1i)+(num-test (sqrt -3.45266983001243932001e-04) 0+1.8581361171917517303e-2i)+(num-test (sqrt -1.19209289550781250e-07) 0+3.4526698300124390840e-4i)+(num-test (sqrt 0.0e+00) 0e0+0.0i)+(num-test (sqrt 1.19209289550781250e-07) 3.4526698300124390840e-4+0.0i)+(num-test (sqrt 3.45266983001243932001e-04) 1.8581361171917517303e-2+0.0i)+(num-test (sqrt 1.250e-01) 3.5355339059327376220e-1+0.0i)+(num-test (sqrt 5.0e-01) 7.0710678118654752440e-1+0.0i)+(num-test (sqrt 7.50e-01) 8.6602540378443864676e-1+0.0i)+(num-test (sqrt 1.0e+00) 1e0+0.0i)+(num-test (sqrt 2.0e+00) 1.4142135623730950488e0+0.0i)+(num-test (sqrt 1.0e+01) 3.1622776601683793320e0+0.0i)+(num-test (sqrt 9) 3)+(num-test (sqrt -9.0) 0.0+3.0i)+(num-test (sqrt (sqrt (sqrt 256))) 2)+(num-test (sqrt (sqrt (sqrt 1/256))) 1/2)++(if (and (integer? (sqrt 4))+	 (exact? (sqrt 4)))+    (begin+      (for-each+       (lambda (n sqn)+	 (if (positive? n) ; in case 32 bit int+	     (let ((val (sqrt n)))+	       (if (or (not (integer? val))+		       (not (eqv? sqn val)))+		   (begin+		     (display "(sqrt ") (display n) (display ") expected ")+		     (display sqn) (display " but got ") (display val) (newline))))))+       (list 9 491401 19439281 1248844921 235565593201)+       (list 3 701 4409 35339 485351))++      (for-each+       (lambda (n)+	 (if (positive? n)+	     (let ((val (sqrt n)))+	       (if (or (integer? val)+		       (> (abs (- (* val val) n)) .001))+		   (begin+		     (display "(sqrt ") (display n) (display ") expected ")+		     (display (sqrt (exact->inexact n))) (display " but got ") (display val) (newline))))))+       (list 10 491400 19439282 1248844920 235565593200))++      (test (eqv? (expt 2 3) 8) #t)+      ;(test (eqv? (log 8 2) 3) #t) ; optimization in C (-O2) changes this+      (num-test (log 8 2) 3)+      (num-test (log 1/8 2) -3)+      (test (eqv? (expt 701 2) 491401) #t)+      (test (eqv? (log 491401 701) 2) #t)+      ))++(let ((err 0.0))+  (do ((i 0 (+ i 1))+       (x -10.0 (+ x .1)))+      ((= i 200))+    (let ((y (magnitude (- x (* (sqrt x) (sqrt x))))))+      (if (> y err) (set! err y))))+  (if (> err 1e-14)+      (begin (display "(sqr (sqrt ...)) error: ") (display err) (newline))))++(let ((err 0.0))+  (do ((i 0 (+ i 1))+       (x -10.0+i (+ x .1+i)))+      ((= i 200))+    (let ((y (magnitude (- x (* (sqrt x) (sqrt x))))))+      (if (> y err) (set! err y))))+  (if (> err 1e-12)+      (begin (display "(sqr (sqrt [complex] ...)) error: ") (display err) (newline))))++++;; -------- exp+(num-test (exp 0) 1.0)+(num-test (exp 1) 2.71828182845905)+(num-test (exp -1) 0.36787944117144)+(num-test (exp 2) 7.38905609893065)+(num-test (exp -2) 0.13533528323661)+(num-test (exp 3) 20.08553692318767)+(num-test (exp -3) 0.04978706836786)+(num-test (exp 10) 22026.46579480671789)+(num-test (exp -10) 0.00004539992976)+(num-test (exp 0/1) 1.0)+(num-test (exp 0/2) 1.0)+(num-test (exp 0/3) 1.0)+(num-test (exp 0/10) 1.0)+(num-test (exp 0/1234) 1.0)+(num-test (exp 0/1234000000) 1.0)+(num-test (exp 0/500029) 1.0)+(num-test (exp 0/362880) 1.0)+(num-test (exp 1/1) 2.71828182845905)+(num-test (exp -1/1) 0.36787944117144)+(num-test (exp 1/2) 1.64872127070013)+(num-test (exp -1/2) 0.60653065971263)+(num-test (exp 1/3) 1.39561242508609)+(num-test (exp -1/3) 0.71653131057379)+(num-test (exp 1/10) 1.10517091807565)+(num-test (exp -1/10) 0.90483741803596)+(num-test (exp 1/1234) 1.00081070121220)+(num-test (exp -1/1234) 0.99918995549186)+(num-test (exp 1/1234000000) 1.00000000081037)+(num-test (exp -1/1234000000) 0.99999999918963)+(num-test (exp 1/500029) 1.00000199988601)+(num-test (exp -1/500029) 0.99999800011799)+(num-test (exp 1/362880) 1.00000275573572)+(num-test (exp -1/362880) 0.99999724427187)+(num-test (exp 2/1) 7.38905609893065)+(num-test (exp -2/1) 0.13533528323661)+(num-test (exp 2/2) 2.71828182845905)+(num-test (exp -2/2) 0.36787944117144)+(num-test (exp 2/3) 1.94773404105468)+(num-test (exp -2/3) 0.51341711903259)+(num-test (exp 2/10) 1.22140275816017)+(num-test (exp -2/10) 0.81873075307798)+(num-test (exp 2/1234) 1.00162205966086)+(num-test (exp -2/1234) 0.99838056715583)+(num-test (exp 2/1234000000) 1.00000000162075)+(num-test (exp -2/1234000000) 0.99999999837925)+(num-test (exp 2/500029) 1.00000399977601)+(num-test (exp -2/500029) 0.99999600023999)+(num-test (exp 2/362880) 1.00000551147903)+(num-test (exp -2/362880) 0.99999448855134)+(num-test (exp 3/1) 20.08553692318767)+(num-test (exp -3/1) 0.04978706836786)+(num-test (exp 3/2) 4.48168907033806)+(num-test (exp -3/2) 0.22313016014843)+(num-test (exp 3/3) 2.71828182845905)+(num-test (exp -3/3) 0.36787944117144)+(num-test (exp 3/10) 1.34985880757600)+(num-test (exp -3/10) 0.74081822068172)+(num-test (exp 3/1234) 1.00243407587880)+(num-test (exp -3/1234) 0.99757183446037)+(num-test (exp 3/1234000000) 1.00000000243112)+(num-test (exp -3/1234000000) 0.99999999756888)+(num-test (exp 3/500029) 1.00000599967002)+(num-test (exp -3/500029) 0.99999400036598)+(num-test (exp 3/362880) 1.00000826722994)+(num-test (exp -3/362880) 0.99999173283841)+(num-test (exp 10/1) 22026.46579480671789)+(num-test (exp -10/1) 0.00004539992976)+(num-test (exp 10/2) 148.41315910257660)+(num-test (exp -10/2) 0.00673794699909)+(num-test (exp 10/3) 28.03162489452614)+(num-test (exp -10/3) 0.03567399334725)+(num-test (exp 10/10) 2.71828182845905)+(num-test (exp -10/10) 0.36787944117144)+(num-test (exp 10/1234) 1.00813665179201)+(num-test (exp -10/1234) 0.99192901897025)+(num-test (exp 10/1234000000) 1.00000000810373)+(num-test (exp -10/1234000000) 0.99999999189627)+(num-test (exp 10/500029) 1.00001999904005)+(num-test (exp -10/500029) 0.99998000135991)+(num-test (exp 10/362880) 1.00002755769893)+(num-test (exp -10/362880) 0.99997244306048)+(num-test (exp 1234/1234) 2.71828182845905)+(num-test (exp -1234/1234) 0.36787944117144)+(num-test (exp 1234/1234000000) 1.00000100000050)+(num-test (exp -1234/1234000000) 0.99999900000050)+(num-test (exp 1234/500029) 1.00247090452960)+(num-test (exp -1234/500029) 0.99753518579099)+(num-test (exp 1234/362880) 1.00340636170081)+(num-test (exp -1234/362880) 0.99660520220837)+(num-test (exp 1234000000/1234000000) 2.71828182845905)+(num-test (exp -1234000000/1234000000) 0.36787944117144)+(num-test (exp 500029/1234000000) 1.00040529199516)+(num-test (exp -500029/1234000000) 0.99959487219989)+(num-test (exp 500029/500029) 2.71828182845905)+(num-test (exp -500029/500029) 0.36787944117144)+(num-test (exp 500029/362880) 3.96674507247837)+(num-test (exp -500029/362880) 0.25209585736630)+(num-test (exp 362880/1234000000) 1.00029411131357)+(num-test (exp -362880/1234000000) 0.99970597516246)+(num-test (exp 362880/500029) 2.06621391988774)+(num-test (exp -362880/500029) 0.48397699307646)+(num-test (exp 362880/362880) 2.71828182845905)+(num-test (exp -362880/362880) 0.36787944117144)+(num-test (exp 0.0) 1.0)+(num-test (exp 0.00000001) 1.00000001)+(num-test (exp -0.00000001) 0.99999999000000)+(num-test (exp 1.0) 2.71828182845905)+(num-test (exp -1.0) 0.36787944117144)+(num-test (exp our-pi) 23.14069263277927)+(num-test (exp -3.14159265358979) 0.04321391826377)+(num-test (exp 2.71828182845905) 15.15426224147926)+(num-test (exp -2.71828182845905) 0.06598803584531)+(num-test (exp 0.0+0.0i) 1.0)+(num-test (exp -0.0+0.0i) 1.0)+(num-test (exp 0.0-0.0i) 1.0)+(num-test (exp -0.0-0.0i) 1.0)+(num-test (exp 0.0+0.00000001i) 1.0+0.00000001i)+(num-test (exp -0.0+0.00000001i) 1.0+0.00000001i)+(num-test (exp 0.0-0.00000001i) 1.0-0.00000001i)+(num-test (exp -0.0-0.00000001i) 1.0-0.00000001i)+(num-test (exp 0.0+1.0i) 0.54030230586814+0.84147098480790i)+(num-test (exp -0.0+1.0i) 0.54030230586814+0.84147098480790i)+(num-test (exp 0.0-1.0i) 0.54030230586814-0.84147098480790i)+(num-test (exp -0.0-1.0i) 0.54030230586814-0.84147098480790i)+(num-test (exp 0.0+3.14159265358979i) -1.0+0.0i)+(num-test (exp -0.0+3.14159265358979i) -1.0+0.0i)+(num-test (exp 0.0-3.14159265358979i) -1.0-0.0i)+(num-test (exp -0.0-3.14159265358979i) -1.0-0.0i)+(num-test (exp 0.0+2.71828182845905i) -0.91173391478697+0.41078129050291i)+(num-test (exp -0.0+2.71828182845905i) -0.91173391478697+0.41078129050291i)+(num-test (exp 0.0-2.71828182845905i) -0.91173391478697-0.41078129050291i)+(num-test (exp -0.0-2.71828182845905i) -0.91173391478697-0.41078129050291i)+(num-test (exp 0.00000001+0.0i) 1.00000001)+(num-test (exp -0.00000001+0.0i) 0.99999999000000)+(num-test (exp 0.00000001-0.0i) 1.00000001)+(num-test (exp -0.00000001-0.0i) 0.99999999000000)+(num-test (exp 0.00000001+0.00000001i) 1.00000001+0.00000001i)+(num-test (exp -0.00000001+0.00000001i) 0.99999999000000+0.00000001i)+(num-test (exp 0.00000001-0.00000001i) 1.00000001-0.00000001i)+(num-test (exp -0.00000001-0.00000001i) 0.99999999000000-0.00000001i)+(num-test (exp 0.00000001+1.0i) 0.54030231127116+0.84147099322261i)+(num-test (exp -0.00000001+1.0i) 0.54030230046512+0.84147097639319i)+(num-test (exp 0.00000001-1.0i) 0.54030231127116-0.84147099322261i)+(num-test (exp -0.00000001-1.0i) 0.54030230046512-0.84147097639319i)+(num-test (exp 0.00000001+3.14159265358979i) -1.00000001+0.0i)+(num-test (exp -0.00000001+3.14159265358979i) -0.99999999000000+0.0i)+(num-test (exp 0.00000001-3.14159265358979i) -1.00000001-0.0i)+(num-test (exp -0.00000001-3.14159265358979i) -0.99999999000000-0.0i)+(num-test (exp 0.00000001+2.71828182845905i) -0.91173392390430+0.41078129461072i)+(num-test (exp -0.00000001+2.71828182845905i) -0.91173390566963+0.41078128639510i)+(num-test (exp 0.00000001-2.71828182845905i) -0.91173392390430-0.41078129461072i)+(num-test (exp -0.00000001-2.71828182845905i) -0.91173390566963-0.41078128639510i)+(num-test (exp 1.0+0.0i) 2.71828182845905)+(num-test (exp -1.0+0.0i) 0.36787944117144)+(num-test (exp 1.0-0.0i) 2.71828182845905)+(num-test (exp -1.0-0.0i) 0.36787944117144)+(num-test (exp 1.0+0.00000001i) 2.71828182845905+0.00000002718282i)+(num-test (exp -1.0+0.00000001i) 0.36787944117144+0.00000000367879i)+(num-test (exp 1.0-0.00000001i) 2.71828182845905-0.00000002718282i)+(num-test (exp -1.0-0.00000001i) 0.36787944117144-0.00000000367879i)+(num-test (exp 1.0+1.0i) 1.46869393991589+2.28735528717884i)+(num-test (exp -1.0+1.0i) 0.19876611034641+0.30955987565311i)+(num-test (exp 1.0-1.0i) 1.46869393991589-2.28735528717884i)+(num-test (exp -1.0-1.0i) 0.19876611034641-0.30955987565311i)+(num-test (exp 1.0+3.14159265358979i) -2.71828182845905+0.0i)+(num-test (exp -1.0+3.14159265358979i) -0.36787944117144+0.0i)+(num-test (exp 1.0-3.14159265358979i) -2.71828182845905-0.0i)+(num-test (exp -1.0-3.14159265358979i) -0.36787944117144-0.0i)+(num-test (exp 1.0+2.71828182845905i) -2.47834973295523+1.11661931744501i)+(num-test (exp -1.0+2.71828182845905i) -0.33540816306888+0.15111799159389i)+(num-test (exp 1.0-2.71828182845905i) -2.47834973295523-1.11661931744501i)+(num-test (exp -1.0-2.71828182845905i) -0.33540816306888-0.15111799159389i)+(num-test (exp 3.14159265358979+0.0i) 23.14069263277927)+(num-test (exp -3.14159265358979+0.0i) 0.04321391826377)+(num-test (exp 3.14159265358979-0.0i) 23.14069263277927)+(num-test (exp -3.14159265358979-0.0i) 0.04321391826377)+(num-test (exp 3.14159265358979+0.00000001i) 23.14069263277926+0.00000023140693i)+(num-test (exp -3.14159265358979+0.00000001i) 0.04321391826377+0.00000000043214i)+(num-test (exp 3.14159265358979-0.00000001i) 23.14069263277926-0.00000023140693i)+(num-test (exp -3.14159265358979-0.00000001i) 0.04321391826377-0.00000000043214i)+(num-test (exp 3.14159265358979+1.0i) 12.50296958887651+19.47222141884161i)+(num-test (exp -3.14159265358979+1.0i) 0.02334857968351+0.03636325835882i)+(num-test (exp 3.14159265358979-1.0i) 12.50296958887651-19.47222141884161i)+(num-test (exp -3.14159265358979-1.0i) 0.02334857968351-0.03636325835882i)+(num-test (exp 3.14159265358979+3.14159265358979i) -23.14069263277927+0.0i)+(num-test (exp -3.14159265358979+3.14159265358979i) -0.04321391826377+0.0i)+(num-test (exp 3.14159265358979-3.14159265358979i) -23.14069263277927-0.0i)+(num-test (exp -3.14159265358979-3.14159265358979i) -0.04321391826377-0.0i)+(num-test (exp 3.14159265358979+2.71828182845905i) -21.09815428496572+9.50576358282422i)+(num-test (exp -3.14159265358979+2.71828182845905i) -0.03939959487191+0.01775146911208i)+(num-test (exp 3.14159265358979-2.71828182845905i) -21.09815428496572-9.50576358282422i)+(num-test (exp -3.14159265358979-2.71828182845905i) -0.03939959487191-0.01775146911208i)+(num-test (exp 2.71828182845905+0.0i) 15.15426224147926)+(num-test (exp -2.71828182845905+0.0i) 0.06598803584531)+(num-test (exp 2.71828182845905-0.0i) 15.15426224147926)+(num-test (exp -2.71828182845905-0.0i) 0.06598803584531)+(num-test (exp 2.71828182845905+0.00000001i) 15.15426224147926+0.00000015154262i)+(num-test (exp -2.71828182845905+0.00000001i) 0.06598803584531+0.00000000065988i)+(num-test (exp 2.71828182845905-0.00000001i) 15.15426224147926-0.00000015154262i)+(num-test (exp -2.71828182845905-0.00000001i) 0.06598803584531-0.00000000065988i)+(num-test (exp 2.71828182845905+1.0i) 8.18788283280173+12.75187197237468i)+(num-test (exp -2.71828182845905+1.0i) 0.03565348792693+0.05552701750829i)+(num-test (exp 2.71828182845905-1.0i) 8.18788283280173-12.75187197237468i)+(num-test (exp -2.71828182845905-1.0i) 0.03565348792693-0.05552701750829i)+(num-test (exp 2.71828182845905+3.14159265358979i) -15.15426224147926+0.0i)+(num-test (exp -2.71828182845905+3.14159265358979i) -0.06598803584531+0.0i)+(num-test (exp 2.71828182845905-3.14159265358979i) -15.15426224147926-0.0i)+(num-test (exp -2.71828182845905-3.14159265358979i) -0.06598803584531-0.0i)+(num-test (exp 2.71828182845905+2.71828182845905i) -13.81665483913218+6.22508740017436i)+(num-test (exp -2.71828182845905+2.71828182845905i) -0.06016353025035+0.02710665052229i)+(num-test (exp 2.71828182845905-2.71828182845905i) -13.81665483913218-6.22508740017436i)+(num-test (exp -2.71828182845905-2.71828182845905i) -0.06016353025035-0.02710665052229i)+(num-test (exp -1234.0+0.0i) 0.0)+(num-test (exp -1234.0-0.0i) 0.0)+(num-test (exp -1234.0+0.00000001i) 0.0)+(num-test (exp -1234.0-0.00000001i) 0.0)+(num-test (exp -1234.0+3.14159265358979i) -0.0)+(num-test (exp -1234.0-3.14159265358979i) -0.0)+(num-test (exp -1234.0+2.71828182845905i) -0.0)+(num-test (exp -1234.0-2.71828182845905i) -0.0)+(num-test (exp -1234000000.0+0.0i) 0.0)+(num-test (exp -1234000000.0-0.0i) 0.0)+(num-test (exp -1234000000.0+0.00000001i) 0.0)+(num-test (exp -1234000000.0-0.00000001i) 0.0)+(num-test (exp -1234000000.0+3.14159265358979i) -0.0)+(num-test (exp -1234000000.0-3.14159265358979i) -0.0)+(num-test (exp -1234000000.0+2.71828182845905i) -0.0)+(num-test (exp -1234000000.0-2.71828182845905i) -0.0)+(num-test (exp 10.0) 22026.46579480672)+(num-test (exp 100.0) 2.688117141816135E+43)+(num-test (exp -10.0) 4.5399929762484853E-5)+(num-test (exp -100.0) 3.720075976020836E-44)+(num-test (exp -7.080000e+02) 3.307553e-308)+(num-test (exp 7.090000e+02) 8.218407461554972189241372386597816393254E307)+(num-test (exp 0.00000001+1234.0i) -0.7985506315730906+0.601927660781774i)+(num-test (exp 0.00000001+1234000000.0i) .1589091324793142-0.987293222712823i)+(num-test (exp 3.14159265358979+1234.0i) -18.47901453215463+13.92902284602872i)+(num-test (exp 3.14159265358979+1234000000.0i) 3.677267354472762-22.8466487767572i)+(num-test (exp 2.71828182845905+1234.0i) -12.1014455629425+9.121769530669065i)+(num-test (exp 2.71828182845905+1234000000.0i) 2.408150642075881-14.96170025660763i)+(num-test (exp 0.0e+00-3.45266983001243932001e-04i) 9.9999994039535581673e-1-3.4526697614140534807e-4i)+(num-test (exp 0.0e+00+3.45266983001243932001e-04i) 9.9999994039535581673e-1+3.4526697614140534807e-4i)+(num-test (exp 0.0e+00+1.57045105981189525579e+00i) 3.4526697614152485627e-4+9.9999994039535581669e-1i)+(num-test (exp 0.0e+00-1.57045105981189525579e+00i) 3.4526697614152485627e-4-9.9999994039535581669e-1i)+(num-test (exp 0.0e+00+1.57114159377789786021e+00i) -3.4526697614140239160e-4+9.9999994039535581673e-1i)+(num-test (exp 0.0e+00-1.57114159377789786021e+00i) -3.4526697614140239160e-4-9.9999994039535581673e-1i)+(num-test (exp 0.0e+00+3.14124738660679181379e+00i) -9.9999994039535581667e-1+3.4526697614158608860e-4i)+(num-test (exp 0.0e+00-3.14124738660679181379e+00i) -9.9999994039535581667e-1-3.4526697614158608860e-4i)+(num-test (exp 0.0e+00+3.14193792057279441821e+00i) -9.9999994039535581675e-1-3.4526697614134115926e-4i)+(num-test (exp 0.0e+00-3.14193792057279441821e+00i) -9.9999994039535581675e-1+3.4526697614134115926e-4i)+(num-test (exp 0.0e+00+4.71204371340168837179e+00i) -3.4526697614164732094e-4-9.9999994039535581664e-1i)+(num-test (exp 0.0e+00-4.71204371340168837179e+00i) -3.4526697614164732094e-4+9.9999994039535581664e-1i)+(num-test (exp 0.0e+00+4.71273424736769097620e+00i) 3.4526697614127992692e-4-9.9999994039535581677e-1i)+(num-test (exp 0.0e+00-4.71273424736769097620e+00i) 3.4526697614127992692e-4+9.9999994039535581677e-1i)+(num-test (exp 0.0e+00+6.28284004019658492979e+00i) 9.9999994039535581662e-1-3.4526697614170855328e-4i)+(num-test (exp 0.0e+00-6.28284004019658492979e+00i) 9.9999994039535581662e-1+3.4526697614170855328e-4i)+(num-test (exp 0.0e+00+6.28353057416258753420e+00i) 9.9999994039535581679e-1+3.4526697614121869459e-4i)+(num-test (exp 0.0e+00-6.28353057416258753420e+00i) 9.9999994039535581679e-1-3.4526697614121869459e-4i)+(num-test (exp 0.0e+00+9.42443269378637893396e+00i) -9.9999994039535581689e-1+3.4526697614094283958e-4i)+(num-test (exp 0.0e+00-9.42443269378637893396e+00i) -9.9999994039535581689e-1-3.4526697614094283958e-4i)+(num-test (exp 0.0e+00+9.42512322775237976202e+00i) -9.9999994039535581714e-1-3.4526697614020805155e-4i)+(num-test (exp 0.0e+00-9.42512322775237976202e+00i) -9.9999994039535581714e-1+3.4526697614020805155e-4i)+(num-test (exp 1.19209289550781250e-07-3.45266983001243932001e-04i) 1.0000000596046453675e0-3.4526701730043873250e-4i)+(num-test (exp 1.19209289550781250e-07+3.45266983001243932001e-04i) 1.0000000596046453675e0+3.4526701730043873250e-4i)+(num-test (exp -1.19209289550781250e-07-3.45266983001243932001e-04i) 9.9999982118608047680e-1-3.4526693498237687017e-4i)+(num-test (exp -1.19209289550781250e-07+3.45266983001243932001e-04i) 9.9999982118608047680e-1+3.4526693498237687017e-4i)+(num-test (exp 1.19209289550781250e-07+1.57045105981189525579e+00i) 3.4526701730055824072e-4+1.0000000596046453675e0i)+(num-test (exp 1.19209289550781250e-07-1.57045105981189525579e+00i) 3.4526701730055824072e-4-1.0000000596046453675e0i)+(num-test (exp -1.19209289550781250e-07+1.57045105981189525579e+00i) 3.4526693498249637836e-4+9.9999982118608047676e-1i)+(num-test (exp -1.19209289550781250e-07-1.57045105981189525579e+00i) 3.4526693498249637836e-4-9.9999982118608047676e-1i)+(num-test (exp 1.19209289550781250e-07+1.57114159377789786021e+00i) -3.4526701730043577603e-4+1.0000000596046453675e0i)+(num-test (exp 1.19209289550781250e-07-1.57114159377789786021e+00i) -3.4526701730043577603e-4-1.0000000596046453675e0i)+(num-test (exp -1.19209289550781250e-07+1.57114159377789786021e+00i) -3.4526693498237391370e-4+9.9999982118608047680e-1i)+(num-test (exp -1.19209289550781250e-07-1.57114159377789786021e+00i) -3.4526693498237391370e-4-9.9999982118608047680e-1i)+(num-test (exp 1.19209289550781250e-07+3.14124738660679181379e+00i) -1.0000000596046453674e0+3.4526701730061947306e-4i)+(num-test (exp 1.19209289550781250e-07-3.14124738660679181379e+00i) -1.0000000596046453674e0-3.4526701730061947306e-4i)+(num-test (exp -1.19209289550781250e-07+3.14124738660679181379e+00i) -9.9999982118608047674e-1+3.4526693498255761069e-4i)+(num-test (exp -1.19209289550781250e-07-3.14124738660679181379e+00i) -9.9999982118608047674e-1-3.4526693498255761069e-4i)+(num-test (exp 1.19209289550781250e-07+3.14193792057279441821e+00i) -1.0000000596046453675e0-3.4526701730037454368e-4i)+(num-test (exp 1.19209289550781250e-07-3.14193792057279441821e+00i) -1.0000000596046453675e0+3.4526701730037454368e-4i)+(num-test (exp -1.19209289550781250e-07+3.14193792057279441821e+00i) -9.9999982118608047682e-1-3.4526693498231268137e-4i)+(num-test (exp -1.19209289550781250e-07-3.14193792057279441821e+00i) -9.9999982118608047682e-1+3.4526693498231268137e-4i)+(num-test (exp 1.19209289550781250e-07+4.71204371340168837179e+00i) -3.4526701730068070540e-4-1.0000000596046453674e0i)+(num-test (exp 1.19209289550781250e-07-4.71204371340168837179e+00i) -3.4526701730068070540e-4+1.0000000596046453674e0i)+(num-test (exp -1.19209289550781250e-07+4.71204371340168837179e+00i) -3.4526693498261884302e-4-9.9999982118608047672e-1i)+(num-test (exp -1.19209289550781250e-07-4.71204371340168837179e+00i) -3.4526693498261884302e-4+9.9999982118608047672e-1i)+(num-test (exp 1.19209289550781250e-07+4.71273424736769097620e+00i) 3.4526701730031331134e-4-1.0000000596046453676e0i)+(num-test (exp 1.19209289550781250e-07-4.71273424736769097620e+00i) 3.4526701730031331134e-4+1.0000000596046453676e0i)+(num-test (exp -1.19209289550781250e-07+4.71273424736769097620e+00i) 3.4526693498225144904e-4-9.9999982118608047684e-1i)+(num-test (exp -1.19209289550781250e-07-4.71273424736769097620e+00i) 3.4526693498225144904e-4+9.9999982118608047684e-1i)+(num-test (exp 1.19209289550781250e-07+6.28284004019658492979e+00i) 1.0000000596046453674e0-3.4526701730074193775e-4i)+(num-test (exp 1.19209289550781250e-07-6.28284004019658492979e+00i) 1.0000000596046453674e0+3.4526701730074193775e-4i)+(num-test (exp -1.19209289550781250e-07+6.28284004019658492979e+00i) 9.9999982118608047670e-1-3.4526693498268007535e-4i)+(num-test (exp -1.19209289550781250e-07-6.28284004019658492979e+00i) 9.9999982118608047670e-1+3.4526693498268007535e-4i)+(num-test (exp 1.19209289550781250e-07+6.28353057416258753420e+00i) 1.0000000596046453676e0+3.452670173002520790e-4i)+(num-test (exp 1.19209289550781250e-07-6.28353057416258753420e+00i) 1.0000000596046453676e0-3.452670173002520790e-4i)+(num-test (exp -1.19209289550781250e-07+6.28353057416258753420e+00i) 9.9999982118608047687e-1+3.4526693498219021671e-4i)+(num-test (exp -1.19209289550781250e-07-6.28353057416258753420e+00i) 9.9999982118608047687e-1-3.4526693498219021671e-4i)+(num-test (exp 1.19209289550781250e-07+9.42443269378637893396e+00i) -1.0000000596046453677e0+3.4526701729997622396e-4i)+(num-test (exp 1.19209289550781250e-07-9.42443269378637893396e+00i) -1.0000000596046453677e0-3.4526701729997622396e-4i)+(num-test (exp -1.19209289550781250e-07+9.42443269378637893396e+00i) -9.9999982118608047696e-1+3.4526693498191436174e-4i)+(num-test (exp -1.19209289550781250e-07-9.42443269378637893396e+00i) -9.9999982118608047696e-1-3.4526693498191436174e-4i)+(num-test (exp 1.19209289550781250e-07+9.42512322775237976202e+00i) -1.0000000596046453679e0-3.4526701729924143584e-4i)+(num-test (exp 1.19209289550781250e-07-9.42512322775237976202e+00i) -1.0000000596046453679e0+3.4526701729924143584e-4i)+(num-test (exp -1.19209289550781250e-07+9.42512322775237976202e+00i) -9.9999982118608047721e-1-3.4526693498117957380e-4i)+(num-test (exp -1.19209289550781250e-07-9.42512322775237976202e+00i) -9.9999982118608047721e-1+3.4526693498117957380e-4i)+(num-test (exp 5.0e-01-3.45266983001243932001e-04i) 1.6487211724286834494e0-5.6924900763464865323e-4i)+(num-test (exp 5.0e-01+3.45266983001243932001e-04i) 1.6487211724286834494e0+5.6924900763464865323e-4i)+(num-test (exp -5.0e-01-3.45266983001243932001e-04i) 6.0653062356058926519e-1-2.0941500681603265022e-4i)+(num-test (exp -5.0e-01+3.45266983001243932001e-04i) 6.0653062356058926519e-1+2.0941500681603265022e-4i)+(num-test (exp 5.0e-01+1.57045105981189525579e+00i) 5.6924900763484568894e-4+1.6487211724286834493e0i)+(num-test (exp 5.0e-01-1.57045105981189525579e+00i) 5.6924900763484568894e-4-1.6487211724286834493e0i)+(num-test (exp -5.0e-01+1.57045105981189525579e+00i) 2.0941500681610513560e-4+6.0653062356058926516e-1i)+(num-test (exp -5.0e-01-1.57045105981189525579e+00i) 2.0941500681610513560e-4-6.0653062356058926516e-1i)+(num-test (exp 5.0e-01+1.57114159377789786021e+00i) -5.6924900763464377883e-4+1.6487211724286834494e0i)+(num-test (exp 5.0e-01-1.57114159377789786021e+00i) -5.6924900763464377883e-4-1.6487211724286834494e0i)+(num-test (exp -5.0e-01+1.57114159377789786021e+00i) -2.0941500681603085702e-4+6.0653062356058926519e-1i)+(num-test (exp -5.0e-01-1.57114159377789786021e+00i) -2.0941500681603085702e-4-6.0653062356058926519e-1i)+(num-test (exp 5.0e-01+3.14124738660679181379e+00i) -1.6487211724286834493e0+5.6924900763494664399e-4i)+(num-test (exp 5.0e-01-3.14124738660679181379e+00i) -1.6487211724286834493e0-5.6924900763494664399e-4i)+(num-test (exp -5.0e-01+3.14124738660679181379e+00i) -6.0653062356058926515e-1+2.0941500681614227489e-4i)+(num-test (exp -5.0e-01-3.14124738660679181379e+00i) -6.0653062356058926515e-1-2.0941500681614227489e-4i)+(num-test (exp 5.0e-01+3.14193792057279441821e+00i) -1.6487211724286834494e0-5.6924900763454282377e-4i)+(num-test (exp 5.0e-01-3.14193792057279441821e+00i) -1.6487211724286834494e0+5.6924900763454282377e-4i)+(num-test (exp -5.0e-01+3.14193792057279441821e+00i) -6.0653062356058926520e-1-2.0941500681599371773e-4i)+(num-test (exp -5.0e-01-3.14193792057279441821e+00i) -6.0653062356058926520e-1+2.0941500681599371773e-4i)+(num-test (exp 5.0e-01+4.71204371340168837179e+00i) -5.6924900763504759905e-4-1.6487211724286834492e0i)+(num-test (exp 5.0e-01-4.71204371340168837179e+00i) -5.6924900763504759905e-4+1.6487211724286834492e0i)+(num-test (exp -5.0e-01+4.71204371340168837179e+00i) -2.0941500681617941418e-4-6.0653062356058926514e-1i)+(num-test (exp -5.0e-01-4.71204371340168837179e+00i) -2.0941500681617941418e-4+6.0653062356058926514e-1i)+(num-test (exp 5.0e-01+4.71273424736769097620e+00i) 5.6924900763444186872e-4-1.6487211724286834494e0i)+(num-test (exp 5.0e-01-4.71273424736769097620e+00i) 5.6924900763444186872e-4+1.6487211724286834494e0i)+(num-test (exp -5.0e-01+4.71273424736769097620e+00i) 2.0941500681595657844e-4-6.0653062356058926521e-1i)+(num-test (exp -5.0e-01-4.71273424736769097620e+00i) 2.0941500681595657844e-4+6.0653062356058926521e-1i)+(num-test (exp 5.0e-01+6.28284004019658492979e+00i) 1.6487211724286834492e0-5.6924900763514855410e-4i)+(num-test (exp 5.0e-01-6.28284004019658492979e+00i) 1.6487211724286834492e0+5.6924900763514855410e-4i)+(num-test (exp -5.0e-01+6.28284004019658492979e+00i) 6.0653062356058926512e-1-2.0941500681621655347e-4i)+(num-test (exp -5.0e-01-6.28284004019658492979e+00i) 6.0653062356058926512e-1+2.0941500681621655347e-4i)+(num-test (exp 5.0e-01+6.28353057416258753420e+00i) 1.6487211724286834495e0+5.6924900763434091366e-4i)+(num-test (exp 5.0e-01-6.28353057416258753420e+00i) 1.6487211724286834495e0-5.6924900763434091366e-4i)+(num-test (exp -5.0e-01+6.28353057416258753420e+00i) 6.0653062356058926523e-1+2.0941500681591943916e-4i)+(num-test (exp -5.0e-01-6.28353057416258753420e+00i) 6.0653062356058926523e-1-2.0941500681591943916e-4i)+(num-test (exp 5.0e-01+9.42443269378637893396e+00i) -1.6487211724286834496e0+5.6924900763388610565e-4i)+(num-test (exp 5.0e-01-9.42443269378637893396e+00i) -1.6487211724286834496e0-5.6924900763388610565e-4i)+(num-test (exp -5.0e-01+9.42443269378637893396e+00i) -6.0653062356058926528e-1+2.0941500681575212464e-4i)+(num-test (exp -5.0e-01-9.42443269378637893396e+00i) -6.0653062356058926528e-1-2.0941500681575212464e-4i)+(num-test (exp 5.0e-01+9.42512322775237976202e+00i) -1.6487211724286834501e0-5.6924900763267464498e-4i)+(num-test (exp 5.0e-01-9.42512322775237976202e+00i) -1.6487211724286834501e0+5.6924900763267464498e-4i)+(num-test (exp -5.0e-01+9.42512322775237976202e+00i) -6.0653062356058926544e-1-2.0941500681530645317e-4i)+(num-test (exp -5.0e-01-9.42512322775237976202e+00i) -6.0653062356058926544e-1+2.0941500681530645317e-4i)+(num-test (exp 1.0e+00-3.45266983001243932001e-04i) 2.7182816664368240602e0-9.3853294721218487636e-4i)+(num-test (exp 1.0e+00+3.45266983001243932001e-04i) 2.7182816664368240602e0+9.3853294721218487636e-4i)+(num-test (exp -1.0e+00-3.45266983001243932001e-04i) 3.6787941924411912823e-1-1.2701662223785390836e-4i)+(num-test (exp -1.0e+00+3.45266983001243932001e-04i) 3.6787941924411912823e-1+1.2701662223785390836e-4i)+(num-test (exp 1.0e+00+1.57045105981189525579e+00i) 9.3853294721250973333e-4+2.7182816664368240601e0i)+(num-test (exp 1.0e+00-1.57045105981189525579e+00i) 9.3853294721250973333e-4-2.7182816664368240601e0i)+(num-test (exp -1.0e+00+1.57045105981189525579e+00i) 1.2701662223789787297e-4+3.6787941924411912822e-1i)+(num-test (exp -1.0e+00-1.57045105981189525579e+00i) 1.2701662223789787297e-4-3.6787941924411912822e-1i)+(num-test (exp 1.0e+00+1.57114159377789786021e+00i) -9.3853294721217683983e-4+2.7182816664368240602e0i)+(num-test (exp 1.0e+00-1.57114159377789786021e+00i) -9.3853294721217683983e-4-2.7182816664368240602e0i)+(num-test (exp -1.0e+00+1.57114159377789786021e+00i) -1.2701662223785282074e-4+3.6787941924411912823e-1i)+(num-test (exp -1.0e+00-1.57114159377789786021e+00i) -1.2701662223785282074e-4-3.6787941924411912823e-1i)+(num-test (exp 1.0e+00+3.14124738660679181379e+00i) -2.718281666436824060e0+9.3853294721267618008e-4i)+(num-test (exp 1.0e+00-3.14124738660679181379e+00i) -2.718281666436824060e0-9.3853294721267618008e-4i)+(num-test (exp -1.0e+00+3.14124738660679181379e+00i) -3.6787941924411912821e-1+1.2701662223792039909e-4i)+(num-test (exp -1.0e+00-3.14124738660679181379e+00i) -3.6787941924411912821e-1-1.2701662223792039909e-4i)+(num-test (exp 1.0e+00+3.14193792057279441821e+00i) -2.7182816664368240603e0-9.3853294721201039309e-4i)+(num-test (exp 1.0e+00-3.14193792057279441821e+00i) -2.7182816664368240603e0+9.3853294721201039309e-4i)+(num-test (exp -1.0e+00+3.14193792057279441821e+00i) -3.6787941924411912824e-1-1.2701662223783029462e-4i)+(num-test (exp -1.0e+00-3.14193792057279441821e+00i) -3.6787941924411912824e-1+1.2701662223783029462e-4i)+(num-test (exp 1.0e+00+4.71204371340168837179e+00i) -9.3853294721284262682e-4-2.718281666436824060e0i)+(num-test (exp 1.0e+00-4.71204371340168837179e+00i) -9.3853294721284262682e-4+2.718281666436824060e0i)+(num-test (exp -1.0e+00+4.71204371340168837179e+00i) -1.2701662223794292521e-4-3.6787941924411912820e-1i)+(num-test (exp -1.0e+00-4.71204371340168837179e+00i) -1.2701662223794292521e-4+3.6787941924411912820e-1i)+(num-test (exp 1.0e+00+4.71273424736769097620e+00i) 9.3853294721184394634e-4-2.7182816664368240603e0i)+(num-test (exp 1.0e+00-4.71273424736769097620e+00i) 9.3853294721184394634e-4+2.7182816664368240603e0i)+(num-test (exp -1.0e+00+4.71273424736769097620e+00i) 1.2701662223780776850e-4-3.6787941924411912825e-1i)+(num-test (exp -1.0e+00-4.71273424736769097620e+00i) 1.2701662223780776850e-4+3.6787941924411912825e-1i)+(num-test (exp 1.0e+00+6.28284004019658492979e+00i) 2.7182816664368240599e0-9.3853294721300907357e-4i)+(num-test (exp 1.0e+00-6.28284004019658492979e+00i) 2.7182816664368240599e0+9.3853294721300907357e-4i)+(num-test (exp -1.0e+00+6.28284004019658492979e+00i) 3.6787941924411912819e-1-1.2701662223796545132e-4i)+(num-test (exp -1.0e+00-6.28284004019658492979e+00i) 3.6787941924411912819e-1+1.2701662223796545132e-4i)+(num-test (exp 1.0e+00+6.28353057416258753420e+00i) 2.7182816664368240604e0+9.3853294721167749959e-4i)+(num-test (exp 1.0e+00-6.28353057416258753420e+00i) 2.7182816664368240604e0-9.3853294721167749959e-4i)+(num-test (exp -1.0e+00+6.28353057416258753420e+00i) 3.6787941924411912825e-1+1.2701662223778524238e-4i)+(num-test (exp -1.0e+00-6.28353057416258753420e+00i) 3.6787941924411912825e-1-1.2701662223778524238e-4i)+(num-test (exp 1.0e+00+9.42443269378637893396e+00i) -2.7182816664368240606e0+9.3853294721092764795e-4i)+(num-test (exp 1.0e+00-9.42443269378637893396e+00i) -2.7182816664368240606e0-9.3853294721092764795e-4i)+(num-test (exp -1.0e+00+9.42443269378637893396e+00i) -3.6787941924411912829e-1+1.270166222376837610e-4i)+(num-test (exp -1.0e+00-9.42443269378637893396e+00i) -3.6787941924411912829e-1-1.270166222376837610e-4i)+(num-test (exp 1.0e+00+9.42512322775237976202e+00i) -2.7182816664368240613e0-9.3853294720893028698e-4i)+(num-test (exp 1.0e+00-9.42512322775237976202e+00i) -2.7182816664368240613e0+9.3853294720893028698e-4i)+(num-test (exp -1.0e+00+9.42512322775237976202e+00i) -3.6787941924411912838e-1-1.2701662223741344759e-4i)+(num-test (exp -1.0e+00-9.42512322775237976202e+00i) -3.6787941924411912838e-1+1.2701662223741344759e-4i)+(num-test (exp 2.0e+00-3.45266983001243932001e-04i) 7.3890556585085906002e0-2.5511970558169944872e-3i)+(num-test (exp 2.0e+00+3.45266983001243932001e-04i) 7.3890556585085906002e0+2.5511970558169944872e-3i)+(num-test (exp -2.0e+00-3.45266983001243932001e-04i) 1.3533527517000128913e-1-4.6726804008345889445e-5i)+(num-test (exp -2.0e+00+3.45266983001243932001e-04i) 1.3533527517000128913e-1+4.6726804008345889445e-5i)+(num-test (exp 2.0e+00+1.57045105981189525579e+00i) 2.551197055817877540e-3+7.3890556585085905999e0i)+(num-test (exp 2.0e+00-1.57045105981189525579e+00i) 2.551197055817877540e-3-7.3890556585085905999e0i)+(num-test (exp -2.0e+00+1.57045105981189525579e+00i) 4.6726804008362063122e-5+1.3533527517000128913e-1i)+(num-test (exp -2.0e+00-1.57045105981189525579e+00i) 4.6726804008362063122e-5-1.3533527517000128913e-1i)+(num-test (exp 2.0e+00+1.57114159377789786021e+00i) -2.5511970558169726417e-3+7.3890556585085906002e0i)+(num-test (exp 2.0e+00-1.57114159377789786021e+00i) -2.5511970558169726417e-3-7.3890556585085906002e0i)+(num-test (exp -2.0e+00+1.57114159377789786021e+00i) -4.6726804008345489330e-5+1.3533527517000128913e-1i)+(num-test (exp -2.0e+00-1.57114159377789786021e+00i) -4.6726804008345489330e-5-1.3533527517000128913e-1i)+(num-test (exp 2.0e+00+3.14124738660679181379e+00i) -7.3890556585085905998e0+2.5511970558183299892e-3i)+(num-test (exp 2.0e+00-3.14124738660679181379e+00i) -7.3890556585085905998e0-2.5511970558183299892e-3i)+(num-test (exp -2.0e+00+3.14124738660679181379e+00i) -1.3533527517000128912e-1+4.6726804008370350017e-5i)+(num-test (exp -2.0e+00-3.14124738660679181379e+00i) -1.3533527517000128912e-1-4.6726804008370350017e-5i)+(num-test (exp 2.0e+00+3.14193792057279441821e+00i) -7.3890556585085906004e0-2.5511970558165201925e-3i)+(num-test (exp 2.0e+00-3.14193792057279441821e+00i) -7.3890556585085906004e0+2.5511970558165201925e-3i)+(num-test (exp -2.0e+00+3.14193792057279441821e+00i) -1.3533527517000128914e-1-4.6726804008337202435e-5i)+(num-test (exp -2.0e+00-3.14193792057279441821e+00i) -1.3533527517000128914e-1+4.6726804008337202435e-5i)+(num-test (exp 2.0e+00+4.71204371340168837179e+00i) -2.5511970558187824384e-3-7.3890556585085905996e0i)+(num-test (exp 2.0e+00-4.71204371340168837179e+00i) -2.5511970558187824384e-3+7.3890556585085905996e0i)+(num-test (exp -2.0e+00+4.71204371340168837179e+00i) -4.6726804008378636913e-5-1.3533527517000128912e-1i)+(num-test (exp -2.0e+00-4.71204371340168837179e+00i) -4.6726804008378636913e-5+1.3533527517000128912e-1i)+(num-test (exp 2.0e+00+4.71273424736769097620e+00i) 2.5511970558160677434e-3-7.3890556585085906006e0i)+(num-test (exp 2.0e+00-4.71273424736769097620e+00i) 2.5511970558160677434e-3+7.3890556585085906006e0i)+(num-test (exp -2.0e+00+4.71273424736769097620e+00i) 4.6726804008328915539e-5-1.3533527517000128914e-1i)+(num-test (exp -2.0e+00-4.71273424736769097620e+00i) 4.6726804008328915539e-5+1.3533527517000128914e-1i)+(num-test (exp 2.0e+00+6.28284004019658492979e+00i) 7.3890556585085905995e0-2.5511970558192348875e-3i)+(num-test (exp 2.0e+00-6.28284004019658492979e+00i) 7.3890556585085905995e0+2.5511970558192348875e-3i)+(num-test (exp -2.0e+00+6.28284004019658492979e+00i) 1.3533527517000128912e-1-4.6726804008386923808e-5i)+(num-test (exp -2.0e+00-6.28284004019658492979e+00i) 1.3533527517000128912e-1+4.6726804008386923808e-5i)+(num-test (exp 2.0e+00+6.28353057416258753420e+00i) 7.3890556585085906007e0+2.5511970558156152942e-3i)+(num-test (exp 2.0e+00-6.28353057416258753420e+00i) 7.3890556585085906007e0-2.5511970558156152942e-3i)+(num-test (exp -2.0e+00+6.28353057416258753420e+00i) 1.3533527517000128914e-1+4.6726804008320628644e-5i)+(num-test (exp -2.0e+00-6.28353057416258753420e+00i) 1.3533527517000128914e-1-4.6726804008320628644e-5i)+(num-test (exp 2.0e+00+9.42443269378637893396e+00i) -7.3890556585085906014e0+2.5511970558135769861e-3i)+(num-test (exp 2.0e+00-9.42443269378637893396e+00i) -7.3890556585085906014e0-2.5511970558135769861e-3i)+(num-test (exp -2.0e+00+9.42443269378637893396e+00i) -1.3533527517000128916e-1+4.6726804008283295729e-5i)+(num-test (exp -2.0e+00-9.42443269378637893396e+00i) -1.3533527517000128916e-1-4.6726804008283295729e-5i)+(num-test (exp 2.0e+00+9.42512322775237976202e+00i) -7.3890556585085906033e0-2.5511970558081475961e-3i)+(num-test (exp 2.0e+00-9.42512322775237976202e+00i) -7.3890556585085906033e0+2.5511970558081475961e-3i)+(num-test (exp -2.0e+00+9.42512322775237976202e+00i) -1.3533527517000128919e-1-4.6726804008183852982e-5i)+(num-test (exp -2.0e+00-9.42512322775237976202e+00i) -1.3533527517000128919e-1+4.6726804008183852982e-5i)+(num-test (exp -1000) 0.0)+(num-test (exp -1000000) 0.0)+(num-test (exp (make-rectangular 0.0 (* 0.5 our-pi))) 0+i)+(num-test (exp (make-rectangular 0.0 our-pi)) -1)+(num-test (exp 100.0) 2.688117141816135e43)+(num-test (exp 500.0) 1.40359221785284E+217)+(num-test (exp -100.0) 3.720075976020836E-44)+(num-test (exp -500.0) 7.12457640674129E-218)+++;; -------- log+;(num-test (log (/ (+ 1 (sqrt 5)) 2)) (acosh (/ (sqrt 5) 2)))+(num-test (log 1) 0.0)+(num-test (log -1) 0.0+3.14159265358979i)+(num-test (log 2) 0.69314718055995)+(num-test (log -2) 0.69314718055995+3.14159265358979i)+(num-test (log 3) 1.09861228866811)+(num-test (log -3) 1.09861228866811+3.14159265358979i)+(num-test (log 10) 2.30258509299405)+(num-test (log -10) 2.30258509299405+3.14159265358979i)+(num-test (log 1234) 7.11801620446533)+(num-test (log -1234) 7.11801620446533+3.14159265358979i)+(num-test (log 1234000000) 20.93352676242961)+(num-test (log -1234000000) 20.93352676242961+3.14159265358979i)+(num-test (log 500029) 13.12242137572239)+(num-test (log -500029) 13.12242137572239+3.14159265358979i)+(num-test (log 362880) 12.80182748008147)+(num-test (log -362880) 12.80182748008147+3.14159265358979i)+(num-test (log 1/1) 0.0)+(num-test (log -1/1) 0.0+3.14159265358979i)+(num-test (log 1/2) -0.69314718055995)+(num-test (log -1/2) -0.69314718055995+3.14159265358979i)+(num-test (log 1/3) -1.09861228866811)+(num-test (log -1/3) -1.09861228866811+3.14159265358979i)+(num-test (log 1/10) -2.30258509299405)+(num-test (log -1/10) -2.30258509299405+3.14159265358979i)+(num-test (log 1/1234) -7.11801620446533)+(num-test (log -1/1234) -7.11801620446533+3.14159265358979i)+(num-test (log 1/1234000000) -20.93352676242961)+(num-test (log -1/1234000000) -20.93352676242961+3.14159265358979i)+(num-test (log 1/500029) -13.12242137572239)+(num-test (log -1/500029) -13.12242137572239+3.14159265358979i)+(num-test (log 1/362880) -12.80182748008147)+(num-test (log -1/362880) -12.80182748008147+3.14159265358979i)+(num-test (log 2/1) 0.69314718055995)+(num-test (log -2/1) 0.69314718055995+3.14159265358979i)+(num-test (log 2/2) 0.0)+(num-test (log -2/2) 0.0+3.14159265358979i)+(num-test (log 2/3) -0.40546510810816)+(num-test (log -2/3) -0.40546510810816+3.14159265358979i)+(num-test (log 2/10) -1.60943791243410)+(num-test (log -2/10) -1.60943791243410+3.14159265358979i)+(num-test (log 2/1234) -6.42486902390539)+(num-test (log -2/1234) -6.42486902390539+3.14159265358979i)+(num-test (log 2/1234000000) -20.24037958186966)+(num-test (log -2/1234000000) -20.24037958186966+3.14159265358979i)+(num-test (log 2/500029) -12.42927419516245)+(num-test (log -2/500029) -12.42927419516245+3.14159265358979i)+(num-test (log 2/362880) -12.10868029952152)+(num-test (log -2/362880) -12.10868029952152+3.14159265358979i)+(num-test (log 3/1) 1.09861228866811)+(num-test (log -3/1) 1.09861228866811+3.14159265358979i)+(num-test (log 3/2) 0.40546510810816)+(num-test (log -3/2) 0.40546510810816+3.14159265358979i)+(num-test (log 3/3) 0.0)+(num-test (log -3/3) 0.0+3.14159265358979i)+(num-test (log 3/10) -1.20397280432594)+(num-test (log -3/10) -1.20397280432594+3.14159265358979i)+(num-test (log 3/1234) -6.01940391579722)+(num-test (log -3/1234) -6.01940391579722+3.14159265358979i)+(num-test (log 3/1234000000) -19.83491447376150)+(num-test (log -3/1234000000) -19.83491447376150+3.14159265358979i)+(num-test (log 3/500029) -12.02380908705428)+(num-test (log -3/500029) -12.02380908705428+3.14159265358979i)+(num-test (log 3/362880) -11.70321519141336)+(num-test (log -3/362880) -11.70321519141336+3.14159265358979i)+(num-test (log 10/1) 2.30258509299405)+(num-test (log -10/1) 2.30258509299405+3.14159265358979i)+(num-test (log 10/2) 1.60943791243410)+(num-test (log -10/2) 1.60943791243410+3.14159265358979i)+(num-test (log 10/3) 1.20397280432594)+(num-test (log -10/3) 1.20397280432594+3.14159265358979i)+(num-test (log 10/10) 0.0)+(num-test (log -10/10) 0.0+3.14159265358979i)+(num-test (log 10/1234) -4.81543111147129)+(num-test (log -10/1234) -4.81543111147129+3.14159265358979i)+(num-test (log 10/1234000000) -18.63094166943556)+(num-test (log -10/1234000000) -18.63094166943556+3.14159265358979i)+(num-test (log 10/500029) -10.81983628272835)+(num-test (log -10/500029) -10.81983628272835+3.14159265358979i)+(num-test (log 10/362880) -10.49924238708742)+(num-test (log -10/362880) -10.49924238708742+3.14159265358979i)+(num-test (log 1234/1) 7.11801620446533)+(num-test (log -1234/1) 7.11801620446533+3.14159265358979i)+(num-test (log 1234/2) 6.42486902390539)+(num-test (log -1234/2) 6.42486902390539+3.14159265358979i)+(num-test (log 1234/3) 6.01940391579722)+(num-test (log -1234/3) 6.01940391579722+3.14159265358979i)+(num-test (log 1234/10) 4.81543111147129)+(num-test (log -1234/10) 4.81543111147129+3.14159265358979i)+(num-test (log 1234/1234) 0.0)+(num-test (log -1234/1234) 0.0+3.14159265358979i)+(num-test (log 1234/1234000000) -13.81551055796427)+(num-test (log -1234/1234000000) -13.81551055796427+3.14159265358979i)+(num-test (log 1234/500029) -6.00440517125706)+(num-test (log -1234/500029) -6.00440517125706+3.14159265358979i)+(num-test (log 1234/362880) -5.68381127561614)+(num-test (log -1234/362880) -5.68381127561614+3.14159265358979i)+(num-test (log 1234000000/1) 20.93352676242961)+(num-test (log -1234000000/1) 20.93352676242961+3.14159265358979i)+(num-test (log 1234000000/2) 20.24037958186966)+(num-test (log -1234000000/2) 20.24037958186966+3.14159265358979i)+(num-test (log 1234000000/3) 19.83491447376150)+(num-test (log -1234000000/3) 19.83491447376150+3.14159265358979i)+(num-test (log 1234000000/10) 18.63094166943556)+(num-test (log -1234000000/10) 18.63094166943556+3.14159265358979i)+(num-test (log 1234000000/1234) 13.81551055796427)+(num-test (log -1234000000/1234) 13.81551055796427+3.14159265358979i)+(num-test (log 1234000000/1234000000) 0.0)+(num-test (log -1234000000/1234000000) 0.0+3.14159265358979i)+(num-test (log 1234000000/500029) 7.81110538670721)+(num-test (log -1234000000/500029) 7.81110538670721+3.14159265358979i)+(num-test (log 1234000000/362880) 8.13169928234814)+(num-test (log -1234000000/362880) 8.13169928234814+3.14159265358979i)+(num-test (log 500029/1) 13.12242137572239)+(num-test (log -500029/1) 13.12242137572239+3.14159265358979i)+(num-test (log 500029/2) 12.42927419516245)+(num-test (log -500029/2) 12.42927419516245+3.14159265358979i)+(num-test (log 500029/3) 12.02380908705428)+(num-test (log -500029/3) 12.02380908705428+3.14159265358979i)+(num-test (log 500029/10) 10.81983628272835)+(num-test (log -500029/10) 10.81983628272835+3.14159265358979i)+(num-test (log 500029/1234) 6.00440517125706)+(num-test (log -500029/1234) 6.00440517125706+3.14159265358979i)+(num-test (log 500029/1234000000) -7.81110538670721)+(num-test (log -500029/1234000000) -7.81110538670721+3.14159265358979i)+(num-test (log 500029/500029) 0.0)+(num-test (log -500029/500029) 0.0+3.14159265358979i)+(num-test (log 500029/362880) 0.32059389564092)+(num-test (log -500029/362880) 0.32059389564092+3.14159265358979i)+(num-test (log 362880/1) 12.80182748008147)+(num-test (log -362880/1) 12.80182748008147+3.14159265358979i)+(num-test (log 362880/2) 12.10868029952152)+(num-test (log -362880/2) 12.10868029952152+3.14159265358979i)+(num-test (log 362880/3) 11.70321519141336)+(num-test (log -362880/3) 11.70321519141336+3.14159265358979i)+(num-test (log 362880/10) 10.49924238708742)+(num-test (log -362880/10) 10.49924238708742+3.14159265358979i)+(num-test (log 362880/1234) 5.68381127561614)+(num-test (log -362880/1234) 5.68381127561614+3.14159265358979i)+(num-test (log 362880/1234000000) -8.13169928234814)+(num-test (log -362880/1234000000) -8.13169928234814+3.14159265358979i)+(num-test (log 362880/500029) -0.32059389564092)+(num-test (log -362880/500029) -0.32059389564092+3.14159265358979i)+(num-test (log 362880/362880) 0.0)+(num-test (log -362880/362880) 0.0+3.14159265358979i)+(num-test (log 0.00000001) -18.42068074395237)+(num-test (log -0.00000001) -18.42068074395237+3.14159265358979i)+(num-test (log 1.0) 0.0)+(num-test (log -1.0) 0.0+3.14159265358979i)+(num-test (log our-pi) 1.14472988584940)+(num-test (log -3.14159265358979) 1.14472988584940+3.14159265358979i)+(num-test (log 2.71828182845905) 1.0)+(num-test (log -2.71828182845905) 1.0+3.14159265358979i)+(num-test (log 1234.0) 7.11801620446533)+(num-test (log -1234.0) 7.11801620446533+3.14159265358979i)+(num-test (log 1234000000.0) 20.93352676242961)+(num-test (log -1234000000.0) 20.93352676242961+3.14159265358979i)+(num-test (log 0.0+0.00000001i) -18.42068074395237+1.57079632679490i)+(num-test (log -0.0+0.00000001i) -18.42068074395237+1.57079632679490i)+(num-test (log 0.0-0.00000001i) -18.42068074395237-1.57079632679490i)+(num-test (log -0.0-0.00000001i) -18.42068074395237-1.57079632679490i)+(num-test (log 0.0+1.0i) 0.0+1.57079632679490i)+(num-test (log -0.0+1.0i) 0.0+1.57079632679490i)+(num-test (log 0.0-1.0i) 0.0-1.57079632679490i)+(num-test (log -0.0-1.0i) 0.0-1.57079632679490i)+(num-test (log 0.0+3.14159265358979i) 1.14472988584940+1.57079632679490i)+(num-test (log -0.0+3.14159265358979i) 1.14472988584940+1.57079632679490i)+(num-test (log 0.0-3.14159265358979i) 1.14472988584940-1.57079632679490i)+(num-test (log -0.0-3.14159265358979i) 1.14472988584940-1.57079632679490i)+(num-test (log 0.0+2.71828182845905i) 1.0+1.57079632679490i)+(num-test (log -0.0+2.71828182845905i) 1.0+1.57079632679490i)+(num-test (log 0.0-2.71828182845905i) 1.0-1.57079632679490i)+(num-test (log -0.0-2.71828182845905i) 1.0-1.57079632679490i)+(num-test (log 0.0+1234.0i) 7.11801620446533+1.57079632679490i)+(num-test (log -0.0+1234.0i) 7.11801620446533+1.57079632679490i)+(num-test (log 0.0-1234.0i) 7.11801620446533-1.57079632679490i)+(num-test (log -0.0-1234.0i) 7.11801620446533-1.57079632679490i)+(num-test (log 0.0+1234000000.0i) 20.93352676242961+1.57079632679490i)+(num-test (log -0.0+1234000000.0i) 20.93352676242961+1.57079632679490i)+(num-test (log 0.0-1234000000.0i) 20.93352676242961-1.57079632679490i)+(num-test (log -0.0-1234000000.0i) 20.93352676242961-1.57079632679490i)+(num-test (log 0.00000001+0.0i) -18.42068074395237)+(num-test (log -0.00000001+0.0i) -18.42068074395237+3.14159265358979i)+(num-test (log 0.00000001-0.0i) -18.42068074395237)+(num-test (log -0.00000001-0.0i) -18.42068074395237+3.14159265358979i)+(num-test (log 0.00000001+0.00000001i) -18.07410715367239+0.78539816339745i)+(num-test (log -0.00000001+0.00000001i) -18.07410715367239+2.35619449019234i)+(num-test (log 0.00000001-0.00000001i) -18.07410715367239-0.78539816339745i)+(num-test (log -0.00000001-0.00000001i) -18.07410715367239-2.35619449019234i)+(num-test (log 0.00000001+1.0i) 0.0+1.57079631679490i)+(num-test (log -0.00000001+1.0i) 0.0+1.57079633679490i)+(num-test (log 0.00000001-1.0i) 0.0-1.57079631679490i)+(num-test (log -0.00000001-1.0i) 0.0-1.57079633679490i)+(num-test (log 0.00000001+3.14159265358979i) 1.14472988584940+1.57079632361180i)+(num-test (log -0.00000001+3.14159265358979i) 1.14472988584940+1.57079632997800i)+(num-test (log 0.00000001-3.14159265358979i) 1.14472988584940-1.57079632361180i)+(num-test (log -0.00000001-3.14159265358979i) 1.14472988584940-1.57079632997800i)+(num-test (log 0.00000001+2.71828182845905i) 1.0+1.57079632311610i)+(num-test (log -0.00000001+2.71828182845905i) 1.0+1.57079633047369i)+(num-test (log 0.00000001-2.71828182845905i) 1.0-1.57079632311610i)+(num-test (log -0.00000001-2.71828182845905i) 1.0-1.57079633047369i)+(num-test (log 0.00000001+1234.0i) 7.11801620446533+1.57079632678679i)+(num-test (log -0.00000001+1234.0i) 7.11801620446533+1.57079632680300i)+(num-test (log 0.00000001-1234.0i) 7.11801620446533-1.57079632678679i)+(num-test (log -0.00000001-1234.0i) 7.11801620446533-1.57079632680300i)+(num-test (log 0.00000001+1234000000.0i) 20.93352676242961+1.57079632679490i)+(num-test (log -0.00000001+1234000000.0i) 20.93352676242961+1.57079632679490i)+(num-test (log 0.00000001-1234000000.0i) 20.93352676242961-1.57079632679490i)+(num-test (log -0.00000001-1234000000.0i) 20.93352676242961-1.57079632679490i)+(num-test (log 1.0+0.0i) 0.0)+(num-test (log -1.0+0.0i) 0.0+3.14159265358979i)+(num-test (log 1.0-0.0i) 0.0)+(num-test (log -1.0-0.0i) 0.0+3.14159265358979i)+(num-test (log 1.0+0.00000001i) 0.0+0.00000001i)+(num-test (log -1.0+0.00000001i) 0.0+3.14159264358979i)+(num-test (log 1.0-0.00000001i) 0.0-0.00000001i)+(num-test (log -1.0-0.00000001i) 0.0-3.14159264358979i)+(num-test (log 1.0+1.0i) 0.34657359027997+0.78539816339745i)+(num-test (log -1.0+1.0i) 0.34657359027997+2.35619449019234i)+(num-test (log 1.0-1.0i) 0.34657359027997-0.78539816339745i)+(num-test (log -1.0-1.0i) 0.34657359027997-2.35619449019234i)+(num-test (log 1.0+3.14159265358979i) 1.19298515341341+1.26262725567891i)+(num-test (log -1.0+3.14159265358979i) 1.19298515341341+1.87896539791088i)+(num-test (log 1.0-3.14159265358979i) 1.19298515341341-1.26262725567891i)+(num-test (log -1.0-3.14159265358979i) 1.19298515341341-1.87896539791088i)+(num-test (log 1.0+2.71828182845905i) 1.06346400552149+1.21828290501728i)+(num-test (log -1.0+2.71828182845905i) 1.06346400552149+1.92330974857252i)+(num-test (log 1.0-2.71828182845905i) 1.06346400552149-1.21828290501728i)+(num-test (log -1.0-2.71828182845905i) 1.06346400552149-1.92330974857252i)+(num-test (log 1.0+1234.0i) 7.11801653281724+1.56998595420081i)+(num-test (log -1.0+1234.0i) 7.11801653281724+1.57160669938898i)+(num-test (log 1.0-1234.0i) 7.11801653281724-1.56998595420081i)+(num-test (log -1.0-1234.0i) 7.11801653281724-1.57160669938898i)+(num-test (log 1.0+1234000000.0i) 20.93352676242961+1.57079632598452i)+(num-test (log -1.0+1234000000.0i) 20.93352676242961+1.57079632760527i)+(num-test (log 1.0-1234000000.0i) 20.93352676242961-1.57079632598452i)+(num-test (log -1.0-1234000000.0i) 20.93352676242961-1.57079632760527i)+(num-test (log 3.14159265358979+0.0i) 1.14472988584940)+(num-test (log -3.14159265358979+0.0i) 1.14472988584940+3.14159265358979i)+(num-test (log 3.14159265358979-0.0i) 1.14472988584940)+(num-test (log -3.14159265358979-0.0i) 1.14472988584940+3.14159265358979i)+(num-test (log 3.14159265358979+0.00000001i) 1.14472988584940+0.00000000318310i)+(num-test (log -3.14159265358979+0.00000001i) 1.14472988584940+3.14159265040669i)+(num-test (log 3.14159265358979-0.00000001i) 1.14472988584940-0.00000000318310i)+(num-test (log -3.14159265358979-0.00000001i) 1.14472988584940-3.14159265040669i)+(num-test (log 3.14159265358979+1.0i) 1.19298515341341+0.30816907111598i)+(num-test (log -3.14159265358979+1.0i) 1.19298515341341+2.83342358247381i)+(num-test (log 3.14159265358979-1.0i) 1.19298515341341-0.30816907111598i)+(num-test (log -3.14159265358979-1.0i) 1.19298515341341-2.83342358247381i)+(num-test (log 3.14159265358979+3.14159265358979i) 1.49130347612937+0.78539816339745i)+(num-test (log -3.14159265358979+3.14159265358979i) 1.49130347612937+2.35619449019234i)+(num-test (log 3.14159265358979-3.14159265358979i) 1.49130347612937-0.78539816339745i)+(num-test (log -3.14159265358979-3.14159265358979i) 1.49130347612937-2.35619449019234i)+(num-test (log 3.14159265358979+2.71828182845905i) 1.42415703773030+0.71328454043905i)+(num-test (log -3.14159265358979+2.71828182845905i) 1.42415703773030+2.42830811315074i)+(num-test (log 3.14159265358979-2.71828182845905i) 1.42415703773030-0.71328454043905i)+(num-test (log -3.14159265358979-2.71828182845905i) 1.42415703773030-2.42830811315074i)+(num-test (log 3.14159265358979+1234.0i) 7.11801944515932+1.56825047114960i)+(num-test (log -3.14159265358979+1234.0i) 7.11801944515932+1.57334218244020i)+(num-test (log 3.14159265358979-1234.0i) 7.11801944515932-1.56825047114960i)+(num-test (log -3.14159265358979-1234.0i) 7.11801944515932-1.57334218244020i)+(num-test (log 3.14159265358979+1234000000.0i) 20.93352676242961+1.57079632424904i)+(num-test (log -3.14159265358979+1234000000.0i) 20.93352676242961+1.57079632934076i)+(num-test (log 3.14159265358979-1234000000.0i) 20.93352676242961-1.57079632424904i)+(num-test (log -3.14159265358979-1234000000.0i) 20.93352676242961-1.57079632934076i)+(num-test (log 2.71828182845905+0.0i) 1.0)+(num-test (log -2.71828182845905+0.0i) 1.0+3.14159265358979i)+(num-test (log 2.71828182845905-0.0i) 1.0)+(num-test (log -2.71828182845905-0.0i) 1.0+3.14159265358979i)+(num-test (log 2.71828182845905+0.00000001i) 1.0+0.00000000367879i)+(num-test (log -2.71828182845905+0.00000001i) 1.0+3.14159264991100i)+(num-test (log 2.71828182845905-0.00000001i) 1.0-0.00000000367879i)+(num-test (log -2.71828182845905-0.00000001i) 1.0-3.14159264991100i)+(num-test (log 2.71828182845905+1.0i) 1.06346400552149+0.35251342177762i)+(num-test (log -2.71828182845905+1.0i) 1.06346400552149+2.78907923181217i)+(num-test (log 2.71828182845905-1.0i) 1.06346400552149-0.35251342177762i)+(num-test (log -2.71828182845905-1.0i) 1.06346400552149-2.78907923181217i)+(num-test (log 2.71828182845905+3.14159265358979i) 1.42415703773030+0.85751178635585i)+(num-test (log -2.71828182845905+3.14159265358979i) 1.42415703773030+2.28408086723395i)+(num-test (log 2.71828182845905-3.14159265358979i) 1.42415703773030-0.85751178635585i)+(num-test (log -2.71828182845905-3.14159265358979i) 1.42415703773030-2.28408086723395i)+(num-test (log 2.71828182845905+2.71828182845905i) 1.34657359027997+0.78539816339745i)+(num-test (log -2.71828182845905+2.71828182845905i) 1.34657359027997+2.35619449019234i)+(num-test (log 2.71828182845905-2.71828182845905i) 1.34657359027997-0.78539816339745i)+(num-test (log -2.71828182845905-2.71828182845905i) 1.34657359027997-2.35619449019234i)+(num-test (log 2.71828182845905+1234.0i) 7.11801863067090+1.56859350877892i)+(num-test (log -2.71828182845905+1234.0i) 7.11801863067090+1.57299914481088i)+(num-test (log 2.71828182845905-1234.0i) 7.11801863067090-1.56859350877892i)+(num-test (log -2.71828182845905-1234.0i) 7.11801863067090-1.57299914481088i)+(num-test (log 2.71828182845905+1234000000.0i) 20.93352676242961+1.57079632459208i)+(num-test (log -2.71828182845905+1234000000.0i) 20.93352676242961+1.57079632899772i)+(num-test (log 2.71828182845905-1234000000.0i) 20.93352676242961-1.57079632459208i)+(num-test (log -2.71828182845905-1234000000.0i) 20.93352676242961-1.57079632899772i)+(num-test (log 1234.0+0.0i) 7.11801620446533)+(num-test (log -1234.0+0.0i) 7.11801620446533+3.14159265358979i)+(num-test (log 1234.0-0.0i) 7.11801620446533)+(num-test (log -1234.0-0.0i) 7.11801620446533+3.14159265358979i)+(num-test (log 1234.0+0.00000001i) 7.11801620446533+0.00000000000810i)+(num-test (log -1234.0+0.00000001i) 7.11801620446533+3.14159265358169i)+(num-test (log 1234.0-0.00000001i) 7.11801620446533-0.00000000000810i)+(num-test (log -1234.0-0.00000001i) 7.11801620446533-3.14159265358169i)+(num-test (log 1234.0+1.0i) 7.11801653281724+0.00081037259408i)+(num-test (log -1234.0+1.0i) 7.11801653281724+3.14078228099571i)+(num-test (log 1234.0-1.0i) 7.11801653281724-0.00081037259408i)+(num-test (log -1234.0-1.0i) 7.11801653281724-3.14078228099571i)+(num-test (log 1234.0+3.14159265358979i) 7.11801944515932+0.00254585564530i)+(num-test (log -1234.0+3.14159265358979i) 7.11801944515932+3.13904679794449i)+(num-test (log 1234.0-3.14159265358979i) 7.11801944515932-0.00254585564530i)+(num-test (log -1234.0-3.14159265358979i) 7.11801944515932-3.13904679794449i)+(num-test (log 1234.0+2.71828182845905i) 7.11801863067090+0.00220281801598i)+(num-test (log -1234.0+2.71828182845905i) 7.11801863067090+3.13938983557381i)+(num-test (log 1234.0-2.71828182845905i) 7.11801863067090-0.00220281801598i)+(num-test (log -1234.0-2.71828182845905i) 7.11801863067090-3.13938983557381i)+(num-test (log 1234.0+1234.0i) 7.46458979474531+0.78539816339745i)+(num-test (log -1234.0+1234.0i) 7.46458979474531+2.35619449019234i)+(num-test (log 1234.0-1234.0i) 7.46458979474531-0.78539816339745i)+(num-test (log -1234.0-1234.0i) 7.46458979474531-2.35619449019234i)+(num-test (log 1234.0+1234000000.0i) 20.93352676243011+1.57079532679490i)+(num-test (log -1234.0+1234000000.0i) 20.93352676243011+1.57079732679490i)+(num-test (log 1234.0-1234000000.0i) 20.93352676243011-1.57079532679490i)+(num-test (log -1234.0-1234000000.0i) 20.93352676243011-1.57079732679490i)+(num-test (log 1234000000.0+0.0i) 20.93352676242961)+(num-test (log -1234000000.0+0.0i) 20.93352676242961+3.14159265358979i)+(num-test (log 1234000000.0-0.0i) 20.93352676242961)+(num-test (log -1234000000.0-0.0i) 20.93352676242961+3.14159265358979i)+(num-test (log 1234000000.0+0.00000001i) 20.93352676242961+0.0i)+(num-test (log -1234000000.0+0.00000001i) 20.93352676242961+3.14159265358979i)+(num-test (log 1234000000.0-0.00000001i) 20.93352676242961-0.0i)+(num-test (log -1234000000.0-0.00000001i) 20.93352676242961-3.14159265358979i)+(num-test (log 1234000000.0+1.0i) 20.93352676242961+0.00000000081037i)+(num-test (log -1234000000.0+1.0i) 20.93352676242961+3.14159265277942i)+(num-test (log 1234000000.0-1.0i) 20.93352676242961-0.00000000081037i)+(num-test (log -1234000000.0-1.0i) 20.93352676242961-3.14159265277942i)+(num-test (log 1234000000.0+3.14159265358979i) 20.93352676242961+0.00000000254586i)+(num-test (log -1234000000.0+3.14159265358979i) 20.93352676242961+3.14159265104393i)+(num-test (log 1234000000.0-3.14159265358979i) 20.93352676242961-0.00000000254586i)+(num-test (log -1234000000.0-3.14159265358979i) 20.93352676242961-3.14159265104393i)+(num-test (log 1234000000.0+2.71828182845905i) 20.93352676242961+0.00000000220282i)+(num-test (log -1234000000.0+2.71828182845905i) 20.93352676242961+3.14159265138697i)+(num-test (log 1234000000.0-2.71828182845905i) 20.93352676242961-0.00000000220282i)+(num-test (log -1234000000.0-2.71828182845905i) 20.93352676242961-3.14159265138697i)+(num-test (log 1234000000.0+1234.0i) 20.93352676243011+0.00000100000000i)+(num-test (log -1234000000.0+1234.0i) 20.93352676243011+3.14159165358979i)+(num-test (log 1234000000.0-1234.0i) 20.93352676243011-0.00000100000000i)+(num-test (log -1234000000.0-1234.0i) 20.93352676243011-3.14159165358979i)+(num-test (log 1234000000.0+1234000000.0i) 21.28010035270958+0.78539816339745i)+(num-test (log -1234000000.0+1234000000.0i) 21.28010035270958+2.35619449019234i)+(num-test (log 1234000000.0-1234000000.0i) 21.28010035270958-0.78539816339745i)+(num-test (log -1234000000.0-1234000000.0i) 21.28010035270958-2.35619449019234i)+(num-test (log .3678794411714423) -1.0)+(num-test (log 22026.46579480672) 10.0)+(num-test (log 2.688117141816135E+43) 100.0)+(num-test (log 4.5399929762484853E-5) -10.0)+(num-test (log 3.720075976020836E-44) -100.0)+(num-test (log 2.2250739e-308) -708.39641851362)+(num-test (log 1.7976931e+308) 709.78271287399)+(num-test (log 1.19209289550781250e-07+0.0e+00i) -1.5942385152878742117e1+0.0i)+(num-test (log -1.19209289550781250e-07+0.0e+00i) -1.5942385152878742117e1+3.1415926535897932385e0i)+(num-test (log 1.19209289550781250e-07+1.19209289550781250e-07i) -1.5595811562598769462e1+7.8539816339744830962e-1i)+(num-test (log 1.19209289550781250e-07-1.19209289550781250e-07i) -1.5595811562598769462e1-7.8539816339744830962e-1i)+(num-test (log -1.19209289550781250e-07+1.19209289550781250e-07i) -1.5595811562598769462e1+2.3561944901923449288e0i)+(num-test (log -1.19209289550781250e-07-1.19209289550781250e-07i) -1.5595811562598769462e1-2.3561944901923449288e0i)+(num-test (log 1.19209289550781250e-07+5.0e-01i) -6.9314718055991688771e-1+1.5707960883763175177e0i)+(num-test (log 1.19209289550781250e-07-5.0e-01i) -6.9314718055991688771e-1-1.5707960883763175177e0i)+(num-test (log -1.19209289550781250e-07+5.0e-01i) -6.9314718055991688771e-1+1.5707965652134757208e0i)+(num-test (log -1.19209289550781250e-07-5.0e-01i) -6.9314718055991688771e-1-1.5707965652134757208e0i)+(num-test (log 1.19209289550781250e-07+1.0e+00i) 7.1054273576009513716e-15+1.5707962075856070685e0i)+(num-test (log 1.19209289550781250e-07-1.0e+00i) 7.1054273576009513716e-15-1.5707962075856070685e0i)+(num-test (log -1.19209289550781250e-07+1.0e+00i) 7.1054273576009513716e-15+1.570796446004186170e0i)+(num-test (log -1.19209289550781250e-07-1.0e+00i) 7.1054273576009513716e-15-1.570796446004186170e0i)+(num-test (log 1.19209289550781250e-07+2.0e+00i) 6.9314718055994708577e-1+1.5707962671902518438e0i)+(num-test (log 1.19209289550781250e-07-2.0e+00i) 6.9314718055994708577e-1-1.5707962671902518438e0i)+(num-test (log -1.19209289550781250e-07+2.0e+00i) 6.9314718055994708577e-1+1.5707963863995413946e0i)+(num-test (log -1.19209289550781250e-07-2.0e+00i) 6.9314718055994708577e-1-1.5707963863995413946e0i)+(num-test (log 1.19209289550781250e-07+8.3886080e+06i) 1.5942385152878742117e1+1.5707963267948824084e0i)+(num-test (log 1.19209289550781250e-07-8.3886080e+06i) 1.5942385152878742117e1-1.5707963267948824084e0i)+(num-test (log -1.19209289550781250e-07+8.3886080e+06i) 1.5942385152878742117e1+1.5707963267949108301e0i)+(num-test (log -1.19209289550781250e-07-8.3886080e+06i) 1.5942385152878742117e1-1.5707963267949108301e0i)+(num-test (log 5.0e-01+0.0e+00i) -6.9314718055994530942e-1+0.0i)+(num-test (log -5.0e-01+0.0e+00i) -6.9314718055994530942e-1+3.1415926535897932385e0i)+(num-test (log 5.0e-01+1.19209289550781250e-07i) -6.9314718055991688771e-1+2.3841857910155798249e-7i)+(num-test (log 5.0e-01-1.19209289550781250e-07i) -6.9314718055991688771e-1-2.3841857910155798249e-7i)+(num-test (log -5.0e-01+1.19209289550781250e-07i) -6.9314718055991688771e-1+3.1415924151712141369e0i)+(num-test (log -5.0e-01-1.19209289550781250e-07i) -6.9314718055991688771e-1-3.1415924151712141369e0i)+(num-test (log 5.0e-01+5.0e-01i) -3.4657359027997265471e-1+7.8539816339744830962e-1i)+(num-test (log 5.0e-01-5.0e-01i) -3.4657359027997265471e-1-7.8539816339744830962e-1i)+(num-test (log -5.0e-01+5.0e-01i) -3.4657359027997265471e-1+2.3561944901923449288e0i)+(num-test (log -5.0e-01-5.0e-01i) -3.4657359027997265471e-1-2.3561944901923449288e0i)+(num-test (log 5.0e-01+1.0e+00i) 1.1157177565710487788e-1+1.1071487177940905030e0i)+(num-test (log 5.0e-01-1.0e+00i) 1.1157177565710487788e-1-1.1071487177940905030e0i)+(num-test (log -5.0e-01+1.0e+00i) 1.1157177565710487788e-1+2.0344439357957027354e0i)+(num-test (log -5.0e-01-1.0e+00i) 1.1157177565710487788e-1-2.0344439357957027354e0i)+(num-test (log 5.0e-01+2.0e+00i) 7.2345949146816273071e-1+1.3258176636680324651e0i)+(num-test (log 5.0e-01-2.0e+00i) 7.2345949146816273071e-1-1.3258176636680324651e0i)+(num-test (log -5.0e-01+2.0e+00i) 7.2345949146816273071e-1+1.8157749899217607734e0i)+(num-test (log -5.0e-01-2.0e+00i) 7.2345949146816273071e-1-1.8157749899217607734e0i)+(num-test (log 5.0e-01+8.3886080e+06i) 1.5942385152878743893e1+1.5707962671902518438e0i)+(num-test (log 5.0e-01-8.3886080e+06i) 1.5942385152878743893e1-1.5707962671902518438e0i)+(num-test (log -5.0e-01+8.3886080e+06i) 1.5942385152878743893e1+1.5707963863995413946e0i)+(num-test (log -5.0e-01-8.3886080e+06i) 1.5942385152878743893e1-1.5707963863995413946e0i)+(num-test (log 1.0e+00+0.0e+00i) 0e0+0.0i)+(num-test (log -1.0e+00+0.0e+00i) 0+3.1415926535897932385e0i)+(num-test (log 1.0e+00+1.19209289550781250e-07i) 7.1054273576009513716e-15+1.1920928955078068531e-7i)+(num-test (log 1.0e+00-1.19209289550781250e-07i) 7.1054273576009513716e-15-1.1920928955078068531e-7i)+(num-test (log -1.0e+00+1.19209289550781250e-07i) 7.1054273576009513716e-15+3.1415925343805036877e0i)+(num-test (log -1.0e+00-1.19209289550781250e-07i) 7.1054273576009513716e-15-3.1415925343805036877e0i)+(num-test (log 1.0e+00+5.0e-01i) 1.1157177565710487788e-1+4.6364760900080611621e-1i)+(num-test (log 1.0e+00-5.0e-01i) 1.1157177565710487788e-1-4.6364760900080611621e-1i)+(num-test (log -1.0e+00+5.0e-01i) 1.1157177565710487788e-1+2.6779450445889871222e0i)+(num-test (log -1.0e+00-5.0e-01i) 1.1157177565710487788e-1-2.6779450445889871222e0i)+(num-test (log 1.0e+00+1.0e+00i) 3.4657359027997265471e-1+7.8539816339744830962e-1i)+(num-test (log 1.0e+00-1.0e+00i) 3.4657359027997265471e-1-7.8539816339744830962e-1i)+(num-test (log -1.0e+00+1.0e+00i) 3.4657359027997265471e-1+2.3561944901923449288e0i)+(num-test (log -1.0e+00-1.0e+00i) 3.4657359027997265471e-1-2.3561944901923449288e0i)+(num-test (log 1.0e+00+2.0e+00i) 8.0471895621705018730e-1+1.1071487177940905030e0i)+(num-test (log 1.0e+00-2.0e+00i) 8.0471895621705018730e-1-1.1071487177940905030e0i)+(num-test (log -1.0e+00+2.0e+00i) 8.0471895621705018730e-1+2.0344439357957027354e0i)+(num-test (log -1.0e+00-2.0e+00i) 8.0471895621705018730e-1-2.0344439357957027354e0i)+(num-test (log 1.0e+00+8.3886080e+06i) 1.5942385152878749222e1+1.5707962075856070685e0i)+(num-test (log 1.0e+00-8.3886080e+06i) 1.5942385152878749222e1-1.5707962075856070685e0i)+(num-test (log -1.0e+00+8.3886080e+06i) 1.5942385152878749222e1+1.570796446004186170e0i)+(num-test (log -1.0e+00-8.3886080e+06i) 1.5942385152878749222e1-1.570796446004186170e0i)+(num-test (log 2.0e+00+0.0e+00i) 6.9314718055994530942e-1+0.0i)+(num-test (log -2.0e+00+0.0e+00i) 6.9314718055994530942e-1+3.1415926535897932385e0i)+(num-test (log 2.0e+00+1.19209289550781250e-07i) 6.9314718055994708577e-1+5.9604644775390554414e-8i)+(num-test (log 2.0e+00-1.19209289550781250e-07i) 6.9314718055994708577e-1-5.9604644775390554414e-8i)+(num-test (log -2.0e+00+1.19209289550781250e-07i) 6.9314718055994708577e-1+3.1415925939851484631e0i)+(num-test (log -2.0e+00-1.19209289550781250e-07i) 6.9314718055994708577e-1-3.1415925939851484631e0i)+(num-test (log 2.0e+00+5.0e-01i) 7.2345949146816273071e-1+2.4497866312686415417e-1i)+(num-test (log 2.0e+00-5.0e-01i) 7.2345949146816273071e-1-2.4497866312686415417e-1i)+(num-test (log -2.0e+00+5.0e-01i) 7.2345949146816273071e-1+2.8966139904629290843e0i)+(num-test (log -2.0e+00-5.0e-01i) 7.2345949146816273071e-1-2.8966139904629290843e0i)+(num-test (log 2.0e+00+1.0e+00i) 8.0471895621705018730e-1+4.6364760900080611621e-1i)+(num-test (log 2.0e+00-1.0e+00i) 8.0471895621705018730e-1-4.6364760900080611621e-1i)+(num-test (log -2.0e+00+1.0e+00i) 8.0471895621705018730e-1+2.6779450445889871222e0i)+(num-test (log -2.0e+00-1.0e+00i) 8.0471895621705018730e-1-2.6779450445889871222e0i)+(num-test (log 2.0e+00+2.0e+00i) 1.0397207708399179641e0+7.8539816339744830962e-1i)+(num-test (log 2.0e+00-2.0e+00i) 1.0397207708399179641e0-7.8539816339744830962e-1i)+(num-test (log -2.0e+00+2.0e+00i) 1.0397207708399179641e0+2.3561944901923449288e0i)+(num-test (log -2.0e+00-2.0e+00i) 1.0397207708399179641e0-2.3561944901923449288e0i)+(num-test (log 2.0e+00+8.3886080e+06i) 1.5942385152878770538e1+1.5707960883763175177e0i)+(num-test (log 2.0e+00-8.3886080e+06i) 1.5942385152878770538e1-1.5707960883763175177e0i)+(num-test (log -2.0e+00+8.3886080e+06i) 1.5942385152878770538e1+1.5707965652134757208e0i)+(num-test (log -2.0e+00-8.3886080e+06i) 1.5942385152878770538e1-1.5707965652134757208e0i)+(num-test (log 8.3886080e+06+0.0e+00i) 1.5942385152878742117e1+0.0i)+(num-test (log -8.3886080e+06+0.0e+00i) 1.5942385152878742117e1+3.1415926535897932385e0i)+(num-test (log 8.3886080e+06+1.19209289550781250e-07i) 1.5942385152878742117e1+1.4210854715202003717e-14i)+(num-test (log 8.3886080e+06-1.19209289550781250e-07i) 1.5942385152878742117e1-1.4210854715202003717e-14i)+(num-test (log -8.3886080e+06+1.19209289550781250e-07i) 1.5942385152878742117e1+3.1415926535897790276e0i)+(num-test (log -8.3886080e+06-1.19209289550781250e-07i) 1.5942385152878742117e1-3.1415926535897790276e0i)+(num-test (log 8.3886080e+06+5.0e-01i) 1.5942385152878743893e1+5.9604644775390554414e-8i)+(num-test (log 8.3886080e+06-5.0e-01i) 1.5942385152878743893e1-5.9604644775390554414e-8i)+(num-test (log -8.3886080e+06+5.0e-01i) 1.5942385152878743893e1+3.1415925939851484631e0i)+(num-test (log -8.3886080e+06-5.0e-01i) 1.5942385152878743893e1-3.1415925939851484631e0i)+(num-test (log 8.3886080e+06+1.0e+00i) 1.5942385152878749222e1+1.1920928955078068531e-7i)+(num-test (log 8.3886080e+06-1.0e+00i) 1.5942385152878749222e1-1.1920928955078068531e-7i)+(num-test (log -8.3886080e+06+1.0e+00i) 1.5942385152878749222e1+3.1415925343805036877e0i)+(num-test (log -8.3886080e+06-1.0e+00i) 1.5942385152878749222e1-3.1415925343805036877e0i)+(num-test (log 8.3886080e+06+2.0e+00i) 1.5942385152878770538e1+2.3841857910155798249e-7i)+(num-test (log 8.3886080e+06-2.0e+00i) 1.5942385152878770538e1-2.3841857910155798249e-7i)+(num-test (log -8.3886080e+06+2.0e+00i) 1.5942385152878770538e1+3.1415924151712141369e0i)+(num-test (log -8.3886080e+06-2.0e+00i) 1.5942385152878770538e1-3.1415924151712141369e0i)+(num-test (log 8.3886080e+06+8.3886080e+06i) 1.6288958743158714771e1+7.8539816339744830962e-1i)+(num-test (log 8.3886080e+06-8.3886080e+06i) 1.6288958743158714771e1-7.8539816339744830962e-1i)+(num-test (log -8.3886080e+06+8.3886080e+06i) 1.6288958743158714771e1+2.3561944901923449288e0i)+(num-test (log -8.3886080e+06-8.3886080e+06i) 1.6288958743158714771e1-2.3561944901923449288e0i)+(num-test (log 0.0e+00+1.19209289550781250e-07i) -1.5942385152878742117e1+1.5707963267948966192e0i)+(num-test (log 0.0e+00-1.19209289550781250e-07i) -1.5942385152878742117e1-1.5707963267948966192e0i)+(num-test (log 0.0e+00+5.0e-01i) -6.9314718055994530942e-1+1.5707963267948966192e0i)+(num-test (log 0.0e+00-5.0e-01i) -6.9314718055994530942e-1-1.5707963267948966192e0i)+(num-test (log 0.0e+00+1.0e+00i) 0+1.5707963267948966192e0i)+(num-test (log 0.0e+00-1.0e+00i) 0-1.5707963267948966192e0i)+(num-test (log 0.0e+00+2.0e+00i) 6.9314718055994530942e-1+1.5707963267948966192e0i)+(num-test (log 0.0e+00-2.0e+00i) 6.9314718055994530942e-1-1.5707963267948966192e0i)+(num-test (log 0.0e+00+8.3886080e+06i) 1.5942385152878742117e1+1.5707963267948966192e0i)+(num-test (log 0.0e+00-8.3886080e+06i) 1.5942385152878742117e1-1.5707963267948966192e0i)+(num-test (log 1.19209289550781250e-07+1.19209289550781250e-07i) -1.5595811562598769462e1+7.8539816339744830962e-1i)+(num-test (log 1.19209289550781250e-07-1.19209289550781250e-07i) -1.5595811562598769462e1-7.8539816339744830962e-1i)+(num-test (log -1.19209289550781250e-07+1.19209289550781250e-07i) -1.5595811562598769462e1+2.3561944901923449288e0i)+(num-test (log -1.19209289550781250e-07-1.19209289550781250e-07i) -1.5595811562598769462e1-2.3561944901923449288e0i)+(num-test (log 1.19209289550781250e-07+5.0e-01i) -6.9314718055991688771e-1+1.5707960883763175177e0i)+(num-test (log 1.19209289550781250e-07-5.0e-01i) -6.9314718055991688771e-1-1.5707960883763175177e0i)+(num-test (log -1.19209289550781250e-07+5.0e-01i) -6.9314718055991688771e-1+1.5707965652134757208e0i)+(num-test (log -1.19209289550781250e-07-5.0e-01i) -6.9314718055991688771e-1-1.5707965652134757208e0i)+(num-test (log 1.19209289550781250e-07+1.0e+00i) 7.1054273576009513716e-15+1.5707962075856070685e0i)+(num-test (log 1.19209289550781250e-07-1.0e+00i) 7.1054273576009513716e-15-1.5707962075856070685e0i)+(num-test (log -1.19209289550781250e-07+1.0e+00i) 7.1054273576009513716e-15+1.570796446004186170e0i)+(num-test (log -1.19209289550781250e-07-1.0e+00i) 7.1054273576009513716e-15-1.570796446004186170e0i)+(num-test (log 1.19209289550781250e-07+2.0e+00i) 6.9314718055994708577e-1+1.5707962671902518438e0i)+(num-test (log 1.19209289550781250e-07-2.0e+00i) 6.9314718055994708577e-1-1.5707962671902518438e0i)+(num-test (log -1.19209289550781250e-07+2.0e+00i) 6.9314718055994708577e-1+1.5707963863995413946e0i)+(num-test (log -1.19209289550781250e-07-2.0e+00i) 6.9314718055994708577e-1-1.5707963863995413946e0i)+(num-test (log 1.19209289550781250e-07+8.3886080e+06i) 1.5942385152878742117e1+1.5707963267948824084e0i)+(num-test (log 1.19209289550781250e-07-8.3886080e+06i) 1.5942385152878742117e1-1.5707963267948824084e0i)+(num-test (log -1.19209289550781250e-07+8.3886080e+06i) 1.5942385152878742117e1+1.5707963267949108301e0i)+(num-test (log -1.19209289550781250e-07-8.3886080e+06i) 1.5942385152878742117e1-1.5707963267949108301e0i)+(num-test (log 5.0e-01+1.19209289550781250e-07i) -6.9314718055991688771e-1+2.3841857910155798249e-7i)+(num-test (log 5.0e-01-1.19209289550781250e-07i) -6.9314718055991688771e-1-2.3841857910155798249e-7i)+(num-test (log -5.0e-01+1.19209289550781250e-07i) -6.9314718055991688771e-1+3.1415924151712141369e0i)+(num-test (log -5.0e-01-1.19209289550781250e-07i) -6.9314718055991688771e-1-3.1415924151712141369e0i)+(num-test (log 5.0e-01+5.0e-01i) -3.4657359027997265471e-1+7.8539816339744830962e-1i)+(num-test (log 5.0e-01-5.0e-01i) -3.4657359027997265471e-1-7.8539816339744830962e-1i)+(num-test (log -5.0e-01+5.0e-01i) -3.4657359027997265471e-1+2.3561944901923449288e0i)+(num-test (log -5.0e-01-5.0e-01i) -3.4657359027997265471e-1-2.3561944901923449288e0i)+(num-test (log 5.0e-01+1.0e+00i) 1.1157177565710487788e-1+1.1071487177940905030e0i)+(num-test (log 5.0e-01-1.0e+00i) 1.1157177565710487788e-1-1.1071487177940905030e0i)+(num-test (log -5.0e-01+1.0e+00i) 1.1157177565710487788e-1+2.0344439357957027354e0i)+(num-test (log -5.0e-01-1.0e+00i) 1.1157177565710487788e-1-2.0344439357957027354e0i)+(num-test (log 5.0e-01+2.0e+00i) 7.2345949146816273071e-1+1.3258176636680324651e0i)+(num-test (log 5.0e-01-2.0e+00i) 7.2345949146816273071e-1-1.3258176636680324651e0i)+(num-test (log -5.0e-01+2.0e+00i) 7.2345949146816273071e-1+1.8157749899217607734e0i)+(num-test (log -5.0e-01-2.0e+00i) 7.2345949146816273071e-1-1.8157749899217607734e0i)+(num-test (log 5.0e-01+8.3886080e+06i) 1.5942385152878743893e1+1.5707962671902518438e0i)+(num-test (log 5.0e-01-8.3886080e+06i) 1.5942385152878743893e1-1.5707962671902518438e0i)+(num-test (log -5.0e-01+8.3886080e+06i) 1.5942385152878743893e1+1.5707963863995413946e0i)+(num-test (log -5.0e-01-8.3886080e+06i) 1.5942385152878743893e1-1.5707963863995413946e0i)+(num-test (log 1.0e+00+1.19209289550781250e-07i) 7.1054273576009513716e-15+1.1920928955078068531e-7i)+(num-test (log 1.0e+00-1.19209289550781250e-07i) 7.1054273576009513716e-15-1.1920928955078068531e-7i)+(num-test (log -1.0e+00+1.19209289550781250e-07i) 7.1054273576009513716e-15+3.1415925343805036877e0i)+(num-test (log -1.0e+00-1.19209289550781250e-07i) 7.1054273576009513716e-15-3.1415925343805036877e0i)+(num-test (log 1.0e+00+5.0e-01i) 1.1157177565710487788e-1+4.6364760900080611621e-1i)+(num-test (log 1.0e+00-5.0e-01i) 1.1157177565710487788e-1-4.6364760900080611621e-1i)+(num-test (log -1.0e+00+5.0e-01i) 1.1157177565710487788e-1+2.6779450445889871222e0i)+(num-test (log -1.0e+00-5.0e-01i) 1.1157177565710487788e-1-2.6779450445889871222e0i)+(num-test (log 1.0e+00+1.0e+00i) 3.4657359027997265471e-1+7.8539816339744830962e-1i)+(num-test (log 1.0e+00-1.0e+00i) 3.4657359027997265471e-1-7.8539816339744830962e-1i)+(num-test (log -1.0e+00+1.0e+00i) 3.4657359027997265471e-1+2.3561944901923449288e0i)+(num-test (log -1.0e+00-1.0e+00i) 3.4657359027997265471e-1-2.3561944901923449288e0i)+(num-test (log 1.0e+00+2.0e+00i) 8.0471895621705018730e-1+1.1071487177940905030e0i)+(num-test (log 1.0e+00-2.0e+00i) 8.0471895621705018730e-1-1.1071487177940905030e0i)+(num-test (log -1.0e+00+2.0e+00i) 8.0471895621705018730e-1+2.0344439357957027354e0i)+(num-test (log -1.0e+00-2.0e+00i) 8.0471895621705018730e-1-2.0344439357957027354e0i)+(num-test (log 1.0e+00+8.3886080e+06i) 1.5942385152878749222e1+1.5707962075856070685e0i)+(num-test (log 1.0e+00-8.3886080e+06i) 1.5942385152878749222e1-1.5707962075856070685e0i)+(num-test (log -1.0e+00+8.3886080e+06i) 1.5942385152878749222e1+1.570796446004186170e0i)+(num-test (log -1.0e+00-8.3886080e+06i) 1.5942385152878749222e1-1.570796446004186170e0i)+(num-test (log 2.0e+00+1.19209289550781250e-07i) 6.9314718055994708577e-1+5.9604644775390554414e-8i)+(num-test (log 2.0e+00-1.19209289550781250e-07i) 6.9314718055994708577e-1-5.9604644775390554414e-8i)+(num-test (log -2.0e+00+1.19209289550781250e-07i) 6.9314718055994708577e-1+3.1415925939851484631e0i)+(num-test (log -2.0e+00-1.19209289550781250e-07i) 6.9314718055994708577e-1-3.1415925939851484631e0i)+(num-test (log 2.0e+00+5.0e-01i) 7.2345949146816273071e-1+2.4497866312686415417e-1i)+(num-test (log 2.0e+00-5.0e-01i) 7.2345949146816273071e-1-2.4497866312686415417e-1i)+(num-test (log -2.0e+00+5.0e-01i) 7.2345949146816273071e-1+2.8966139904629290843e0i)+(num-test (log -2.0e+00-5.0e-01i) 7.2345949146816273071e-1-2.8966139904629290843e0i)+(num-test (log 2.0e+00+1.0e+00i) 8.0471895621705018730e-1+4.6364760900080611621e-1i)+(num-test (log 2.0e+00-1.0e+00i) 8.0471895621705018730e-1-4.6364760900080611621e-1i)+(num-test (log -2.0e+00+1.0e+00i) 8.0471895621705018730e-1+2.6779450445889871222e0i)+(num-test (log -2.0e+00-1.0e+00i) 8.0471895621705018730e-1-2.6779450445889871222e0i)+(num-test (log 2.0e+00+2.0e+00i) 1.0397207708399179641e0+7.8539816339744830962e-1i)+(num-test (log 2.0e+00-2.0e+00i) 1.0397207708399179641e0-7.8539816339744830962e-1i)+(num-test (log -2.0e+00+2.0e+00i) 1.0397207708399179641e0+2.3561944901923449288e0i)+(num-test (log -2.0e+00-2.0e+00i) 1.0397207708399179641e0-2.3561944901923449288e0i)+(num-test (log 2.0e+00+8.3886080e+06i) 1.5942385152878770538e1+1.5707960883763175177e0i)+(num-test (log 2.0e+00-8.3886080e+06i) 1.5942385152878770538e1-1.5707960883763175177e0i)+(num-test (log -2.0e+00+8.3886080e+06i) 1.5942385152878770538e1+1.5707965652134757208e0i)+(num-test (log -2.0e+00-8.3886080e+06i) 1.5942385152878770538e1-1.5707965652134757208e0i)+(num-test (log 8.3886080e+06+1.19209289550781250e-07i) 1.5942385152878742117e1+1.4210854715202003717e-14i)+(num-test (log 8.3886080e+06-1.19209289550781250e-07i) 1.5942385152878742117e1-1.4210854715202003717e-14i)+(num-test (log -8.3886080e+06+1.19209289550781250e-07i) 1.5942385152878742117e1+3.1415926535897790276e0i)+(num-test (log -8.3886080e+06-1.19209289550781250e-07i) 1.5942385152878742117e1-3.1415926535897790276e0i)+(num-test (log 8.3886080e+06+5.0e-01i) 1.5942385152878743893e1+5.9604644775390554414e-8i)+(num-test (log 8.3886080e+06-5.0e-01i) 1.5942385152878743893e1-5.9604644775390554414e-8i)+(num-test (log -8.3886080e+06+5.0e-01i) 1.5942385152878743893e1+3.1415925939851484631e0i)+(num-test (log -8.3886080e+06-5.0e-01i) 1.5942385152878743893e1-3.1415925939851484631e0i)+(num-test (log 8.3886080e+06+1.0e+00i) 1.5942385152878749222e1+1.1920928955078068531e-7i)+(num-test (log 8.3886080e+06-1.0e+00i) 1.5942385152878749222e1-1.1920928955078068531e-7i)+(num-test (log -8.3886080e+06+1.0e+00i) 1.5942385152878749222e1+3.1415925343805036877e0i)+(num-test (log -8.3886080e+06-1.0e+00i) 1.5942385152878749222e1-3.1415925343805036877e0i)+(num-test (log 8.3886080e+06+2.0e+00i) 1.5942385152878770538e1+2.3841857910155798249e-7i)+(num-test (log 8.3886080e+06-2.0e+00i) 1.5942385152878770538e1-2.3841857910155798249e-7i)+(num-test (log -8.3886080e+06+2.0e+00i) 1.5942385152878770538e1+3.1415924151712141369e0i)+(num-test (log -8.3886080e+06-2.0e+00i) 1.5942385152878770538e1-3.1415924151712141369e0i)+(num-test (log 8.3886080e+06+8.3886080e+06i) 1.6288958743158714771e1+7.8539816339744830962e-1i)+(num-test (log 8.3886080e+06-8.3886080e+06i) 1.6288958743158714771e1-7.8539816339744830962e-1i)+(num-test (log -8.3886080e+06+8.3886080e+06i) 1.6288958743158714771e1+2.3561944901923449288e0i)+(num-test (log -8.3886080e+06-8.3886080e+06i) 1.6288958743158714771e1-2.3561944901923449288e0i)+(num-test (exp (log 8)) 8.0)+(num-test (exp (log 1000)) 1000.0)+(num-test (exp (log 1000000)) 1000000.0)+(num-test (exp (log 1000000000)) 1000000000.0)+(num-test (log (exp 0.1)) 0.1)+(num-test (log (exp 0.0001)) 0.0001)+(num-test (log (exp 0.0000001)) 0.0000001)+(num-test (log (exp 8)) 8.0)+(num-test (log 0+i) (make-rectangular 0.0 (* 0.5 our-pi)))+(num-test (log 0-i) (make-rectangular 0.0 (* -0.5 our-pi)))+(num-test (log 1.0e-8) -18.42068074395237)+(num-test (log 1.0e-12) -27.63102111592855)++(let ((err 0.0))+  (do ((i 0 (+ i 1))+       (x -10.0 (+ x .1)))+      ((= i 200))+    (if (not (zero? x))+	(let ((y (magnitude (- x (exp (log x))))))+	  (if (> y err) (set! err y)))))+  (if (> err 1e-14)+      (begin (display "(exp (log ...)) error: ") (display err) (newline))))++(let ((err 0.0))+  (do ((i 0 (+ i 1))+       (x -10.0+i (+ x 0.1-0.1i)))+      ((= i 200))+    (if (not (zero? x))+	(let ((y (magnitude (- x (exp (log x))))))+	  (if (> y err) (set! err y)))))+  (if (> err 1e-14)+      (begin (display "(exp (log [complex] ...)) error: ") (display err) (newline))))++;; -------- expt+(num-test (expt 0 0) 1)+(num-test (expt 0 1) 0)+(num-test (expt 0 2) 0)+(num-test (expt 0 3) 0)+(num-test (expt 0 10) 0)+(num-test (expt 0 1234) 0)+(num-test (expt 1 0) 1)+(num-test (expt -1 0) 1)+(num-test (expt 1 0) 1)+(num-test (expt 1 1) 1)+(num-test (expt -1 1) -1)+(num-test (expt 1 -1) 1)+(num-test (expt 1 2) 1)+(num-test (expt -1 2) 1)+(num-test (expt 1 -2) 1)+(num-test (expt 1 3) 1)+(num-test (expt -1 3) -1)+(num-test (expt 1 -3) 1)+(num-test (expt 1 10) 1)+(num-test (expt -1 10) 1)+(num-test (expt 1 -10) 1)+(num-test (expt 1 1234) 1)+(num-test (expt -1 1234) 1)+(num-test (expt 1 -1234) 1)++(if with-large-powers+    (begin+      (num-test (expt 0 1234000000) 0)+      (num-test (expt 0 500029) 0)+      (num-test (expt 0 362880) 0)+      (num-test (expt 1 1234000000) 1)+      (num-test (expt -1 1234000000) 1)+      (num-test (expt 1 -1234000000) 1)+      (num-test (expt 1 500029) 1)+      (num-test (expt -1 500029) -1)+      (num-test (expt 1 -500029) 1)+      (num-test (expt 1 362880) 1)+      (num-test (expt -1 362880) 1)+      (num-test (expt 1 -362880) 1)+      (num-test (expt 3 10) 59049)+      (num-test (expt -3 10) 59049)+      (num-test (expt 3 -10) 1/59049)+      (num-test (expt 1234 2) 1522756)+      (num-test (expt -1234 2) 1522756)+      (num-test (expt 1234 -2) 1/1522756)+      (num-test (expt 1234 -3) 1/1879080904)+      (num-test (expt 1234000000 -1) 1/1234000000)+      (num-test (expt 500029 0) 1)+      (num-test (expt -500029 0) 1)+      (num-test (expt 500029 0) 1)+      (num-test (expt 500029 1) 500029)+      (num-test (expt -500029 1) -500029)+      (num-test (expt 500029 -1) 1/500029)+      (if (or with-bignums with-64-bit-ints) (num-test (expt 500029 -2) 1/250029000841))+      (num-test (expt 362880 1) 362880)+      (num-test (expt -362880 1) -362880)+      (num-test (expt 362880 -1) 1/362880)+      (if (or with-bignums with-64-bit-ints) (num-test (expt 362880 -2) 1/131681894400))+      (num-test (expt 2/3 1234/362880) 0.99862213634996)+      (num-test (expt -2/3 1234/362880) 0.99856514997103+0.01066829281071i)+      (num-test (expt 2/10 1234000000/500029) 0.0)+      (num-test (expt -2/10 1234000000/500029) 0.0)+      (num-test (expt 2/1234 500029/1234000000) 0.99739996551176)+      (num-test (expt -2/1234 500029/1234000000) 0.99739915734849+0.00126969420446i)+      (num-test (expt 2/1234000000 362880/1234) 0.0) (num-test (expt -2/1234000000 362880/1234) 0.0)+      (num-test (expt 2/500029 0/10) 1)+      (num-test (expt -2/500029 0/10) 1)+      (num-test (expt 2/362880 1/3) 0.01766399721581)+      (test (or (< (magnitude (- (expt -2/362880 1/3) 0.00883199860790+0.01529747032127i)) 1e-6)+		(< (magnitude (- (expt -2/362880 1/3) 0.00883199860790-0.01529747032127i)) 1e-6)+		(< (magnitude (- (expt -2/362880 1/3) -0.017663997215805)) 1e-6)) #t)+      (num-test (expt 3/1 10/2) 243)+      (num-test (expt -3/1 10/2) -243)+      (num-test (expt 3/10 500029/362880) 0.19032743228093)+      (num-test (expt -3/10 500029/362880) -0.07120470796705-0.17650615015342i)+      (num-test (expt 3/1234 362880/500029) 0.01267163536282)+      (num-test (expt -3/1234 362880/500029) -0.00825127977478+0.00961700186370i)+      (num-test (expt 3/1234000000 0/1234000000) 1)+      (num-test (expt -3/1234000000 0/1234000000) 1)+      (num-test (expt 3/500029 1/1234) 0.99030354920325)+      (num-test (expt -3/500029 1/1234) 0.99030033992383+0.00252117260474i)+      (num-test (expt 3/362880 2/10) 0.09626571578282)+      (num-test (expt -3/362880 2/10) 0.07788060004397+0.05658356803852i)+      (num-test (expt 10/1234 0/362880) 1)+      (num-test (expt -10/1234 0/362880) 1)+      (num-test (expt 10/1234000000 1/500029) 0.99996274097186)+      (num-test (expt -10/1234000000 1/500029) 0.99996274095212+0.00000628258681i)+      (num-test (expt 10/500029 2/1234000000) 0.99999998246380)+      (num-test (expt -10/500029 2/1234000000) 0.99999998246380+0.00000000509172i)+      (num-test (expt 10/362880 3/1234) 0.97479810574733)+      (num-test (expt -10/362880 3/1234) 0.97476967459219+0.00744502948457i)+      (num-test (expt 1234/10 0/1) 1)+      (num-test (expt -1234/10 0/1) 1)+      (num-test (expt 1234/1234000000 2/362880) 0.99992385921192)+      (num-test (expt -1234/1234000000 2/362880) 0.99992385906203+0.00001731345596i)+      (num-test (expt 1234/500029 3/500029) 0.99996397630725)+      (num-test (expt -1234/500029 3/500029) 0.99996397612963+0.00001884778372i)+      (num-test (expt 1234/362880 10/1234000000) 0.99999995393994)+      (num-test (expt -1234/362880 10/1234000000) 0.99999995393994+0.00000002545861i)+      (num-test (expt 1234000000/3 0/3) 1)+      (num-test (expt -1234000000/3 0/3) 1)+      (num-test (expt 1234000000/10 1/2) 11108.55526159905094)+      (num-test (expt -1234000000/10 1/2) 0.00000000000068+11108.55526159905094i)+      (num-test (expt 1234000000/500029 10/362880) 1.00021527629325)+      (num-test (expt -1234000000/500029 10/362880) 1.00021527254493+0.00008659250882i)+      (num-test (expt 1234000000/362880 1234/500029) 1.02027058333165)+      (num-test (expt -1234000000/362880 1234/500029) 1.02023991975054+0.00791007960266i)+      (num-test (expt 500029/1 362880/1234000000) 1.00386634022855)+      (num-test (expt -500029/1 362880/1234000000) 1.00386591183654+0.00092741384842i)+      (num-test (expt 500029/2 0/1234) 1)+      (num-test (expt -500029/2 0/1234) 1)+      (num-test (expt 500029/3 1/10) 3.32803123591083)+      (num-test (expt -500029/3 1/10) 3.16514579334680+1.02841820970710i)+      (num-test (expt 500029/10 2/3) 1357.26128653075921)+      (num-test (expt -500029/10 2/3) -678.63064326537926+1175.42275370878747i)+      (num-test (expt 500029/1234 3/2) 8156.80442672750178)+      (num-test (expt -500029/1234 3/2) -0.00000000000150-8156.80442672750178i)+      (num-test (expt 500029/1234000000 10/1) 0.0)+      (num-test (expt -500029/1234000000 10/1) 0.0-0.0i)+      (num-test (expt 362880/1 0/500029) 1)+      (num-test (expt -362880/1 0/500029) 1)+      (num-test (expt 362880/2 1/1234000000) 1.00000000981254)+      (num-test (expt -362880/2 1/1234000000) 1.00000000981254+0.00000000254586i)+      (num-test (expt 362880/3 2/1234) 1.01914896791961)+      (num-test (expt -362880/3 2/1234) 1.01913575690562+0.00518920109559i)+      (num-test (expt 362880/10 3/10) 23.33076127248722)+      (num-test (expt -362880/10 3/10) 13.71347740072436+18.87498236114703i)+      (num-test (expt 362880/1234 10/3) 169106218.17807236313820)+      (num-test (expt -362880/1234 10/3) -84553109.08903615176678-146450280.88012450933456i)+      (num-test (expt 362880/1234000000 1234/2) 0.0)+      (num-test (expt -362880/1234000000 1234/2) -0.0)))++(num-test (expt 2 0) 1)+(num-test (expt -2 0) 1)+(num-test (expt 2 0) 1)+(num-test (expt 2 1) 2)+(num-test (expt -2 1) -2)+(num-test (expt 2 -1) 1/2)+(num-test (expt 2 2) 4)+(num-test (expt -2 2) 4)+(num-test (expt 2 -2) 1/4)+(num-test (expt 2 3) 8)+(num-test (expt -2 3) -8)+(num-test (expt 2 -3) 1/8)+(num-test (expt 2 10) 1024)+(num-test (expt -2 10) 1024)+(num-test (expt 2 -10) 1/1024)+(num-test (expt 3 0) 1)+(num-test (expt -3 0) 1)+(num-test (expt 3 0) 1)+(num-test (expt 3 1) 3)+(num-test (expt -3 1) -3)+(num-test (expt 3 -1) 1/3)+(num-test (expt 3 2) 9)+(num-test (expt -3 2) 9)+(num-test (expt 3 -2) 1/9)+(num-test (expt 3 3) 27)+(num-test (expt -3 3) -27)+(num-test (expt 3 -3) 1/27)+(num-test (expt 2.0 -1.0220000e+03) 2.225073858507201383090232717332404063624E-308)+(num-test (expt 2.0 1.0230000e+03) 8.98846567431157953864652595394512365232E307)+(num-test (expt 0+i 1/2) (make-rectangular (/ (sqrt 2)) (/ (sqrt 2))))+(num-test (expt (expt 0+i 1/3) 3) 0+i)+(num-test (expt (expt 0+i 1/4) 4) 0+i)+(num-test (expt (expt 1+i 1/2) 2) 1+i)+(num-test (expt (expt 1+i 1/3) 3) 1+i)+(num-test (expt (expt 1+i 1/4) 4) 1+i)+(num-test (expt (expt 1-i 1/2) 2) 1-i)+(num-test (expt (expt 1-i 1/3) 3) 1-i)+(num-test (expt (expt 1-i 1/4) 4) 1-i)+(num-test (expt (expt 0+i 1/10) 10) 0+i)+(num-test (expt (expt 0+i -1/2) -2) 0+i)+(num-test (expt (expt 0+i -1/3) -3) 0+i)+(num-test (expt (expt 0+i -1/4) -4) 0+i)+(num-test (expt 0+i 2) -1)+(num-test (expt 0-i 2) -1)+(num-test (expt (expt 2 0+i) (/ 0+i)) 2)+(num-test (expt -1 1/2) 0+i)+(num-test (expt -1.0 1/2) 0+i)+(num-test (expt (expt -1/2 1/2) 2) -1/2)+(num-test (expt (expt -1/2 -1/2) -2) -1/2)+(num-test (expt (expt 1/2 -1/2) -2) 1/2)+(num-test (expt (expt -1/3 1/3) 3) -1/3)+(num-test (expt (expt -1/3 1/2) 2) -1/3)+(num-test (expt (expt -1/3 -1/2) -2) -1/3)+(num-test (expt (expt -2 1/2) 2) -2)+(num-test (expt (expt -2 -1/2) -2) -2)+(num-test (expt (expt -1 -1/2) -2) -1)+(num-test (expt (expt 1 -1/2) -2) 1)+(num-test (expt (expt 1 1/123) 123) 1)+(num-test (expt (expt -1 1/123) 123) -1)+(num-test (expt -1/8 -3) -512)++(let ((xs (list 2 3 4 1/2 1/3 1/4 2.5 1+i 2.5+1.5i 2.5-.5i))+      (ys  (list 2 3 4 -2 -3 -4 1/2 1/3 1/4 -1/2 -1/3 -1/4 2.5 -3.5 1+i -1+2i 2.5+1.5i 2.5-.5i)))+  (for-each+   (lambda (x)+     (for-each+      (lambda (y)+	(num-test (expt (expt x y) (/ y)) x)+	;;	(if (> (magnitude (- (expt (expt x y) (/ y)) x)) 1e-6)+	;;	    (format #t "(expt (expt ~A ~A) (/ ~A)) -> ~A (~A)~%" x y y (expt (expt x y) (/ y)) (magnitude (- (expt (expt x y) (/ y)) x))))+	)+      ys))+   xs))++(if with-bignums+    (begin+      (num-test (expt 4722366482869645213696 1/2) 68719476736)+      (num-test (expt 324518553658426726783156020576256 1/3) 68719476736)+      (num-test (expt 4722366482869645213696/6561 1/2) 68719476736/81)+      (num-test (expt 324518553658426726783156020576256/19683 1/3) 68719476736/27)++      (num-test (expt 4722366482869645213696/6561 -1/2) (/ 68719476736/81))+      (num-test (expt (expt -4722366482869645213696/6561 1/2) 2) -4722366482869645213696/6561)++      (num-test (numerator 1195068768795265792518361315725116351898245581/48889032896862784894921) 24444516448431392447461)+      (num-test (denominator 1195068768795265792518361315725116351898245581/48889032896862784894921) 1)+      (num-test (numerator 24444516448431392447461/1195068768795265792518361315725116351898245581) 1)+      (num-test (denominator 24444516448431392447461/1195068768795265792518361315725116351898245581) 48889032896862784894921)++      (if with-bigfloats+	  (begin+	    (num-test (expt 4722366482869645213696.0 1/2) 68719476736.0)+	    (num-test (expt 324518553658426726783156020576256.0 1/3) 68719476736.0)+	    (num-test (+ 12345678901234567890+12345678901234567890i 12345678901234567890-12345678901234567890i) 2.469135780246913578E19)+	    (num-test (* 2 12345678901234567890+12345678901234567890i) 2.469135780246913578E19+2.469135780246913578E19i)+	    (num-test (- 2 12345678901234567890+12345678901234567890i) -12345678901234567890-12345678901234567890i)+	    ))+      ))++(num-test (expt 10 0) 1)+(num-test (expt -10 0) 1)+(num-test (expt 10 0) 1)+(num-test (expt 10 1) 10)+(num-test (expt -10 1) -10)+(num-test (expt 10 -1) 1/10)+(num-test (expt 10 2) 100)+(num-test (expt -10 2) 100)+(num-test (expt 10 -2) 1/100)+(num-test (expt 10 3) 1000)+(num-test (expt -10 3) -1000)+(num-test (expt 10 -3) 1/1000)+(if (or with-bignums with-64-bit-ints) (num-test (expt 10 -10) 1/10000000000))+(num-test (expt 1234 0) 1)+(num-test (expt -1234 0) 1)+(num-test (expt 1234 0) 1)+(num-test (expt 1234 1) 1234)+(num-test (expt -1234 1) -1234)+(num-test (expt 1234 -1) 1/1234)+(num-test (expt 1234000000 0) 1)+(num-test (expt -1234000000 0) 1)+(num-test (expt 1234000000 0) 1)+(num-test (expt 0/500029 500029/2) 0.0)+(num-test (expt 0/362880 362880/1) 0)+(num-test (expt 1/2 3/362880) 0.99999426963298)+(num-test (expt -1/2 3/362880) 0.99999426929571+0.00002597201266i)+(num-test (expt 1/3 10/500029) 0.99997802926990)+(num-test (expt -1/3 10/500029) 0.99997802729625+0.00006282682861i)+(num-test (expt 1/10 1234/1234000000) 0.99999769741756)+(num-test (expt -1/10 1234/1234000000) 0.99999769741262+0.00000314158542i)+(num-test (expt 1/1234000000 500029/10) 0.0)+(num-test (expt -1/1234000000 500029/10) -0.0)+(num-test (expt 1/500029 362880/3) 0.0)+(num-test (expt -1/500029 362880/3) 0.0)+(num-test (expt 362880 0) 1)+(num-test (expt -362880 0) 1)+(num-test (expt 362880 0) 1)+(num-test (expt 0/1 1/362880) 0.0)+(num-test (expt 0/2 2/500029) 0.0)+(num-test (expt 0/3 3/1234000000) 0.0)+(num-test (expt 0/10 10/1234) 0.0)+(num-test (expt 0/1234 1234/10) 0.0)+(num-test (expt 1/362880 0/2) 1)+(num-test (expt -1/362880 0/2) 1)+(num-test (expt 2/1 3/1) 8)+(num-test (expt 1/4 -2) 16)+(num-test (expt 16 1/4) 2)+(num-test (expt -2/1 3/1) -8)+(num-test (expt 0 0.00000001) 0.0)+(num-test (expt 0 1.0) 0.0)+(num-test (expt 0 our-pi) 0.0)+(num-test (expt 0 2.71828182845905) 0.0)+(num-test (expt 0 1234.0) 0.0)+(num-test (expt 0 1234000000.0) 0.0)+(num-test (expt 1 0.0) 1.0)+(num-test (expt -1 0.0) 1.0)+(num-test (expt 1 -0.0) 1.0)+(num-test (expt 1 0.00000001) 1.0)+(num-test (expt -1 0.00000001) 1.0+0.00000003141593i)+(num-test (expt 1 -0.00000001) 1.0)+(num-test (expt 1 1.0) 1.0)+(num-test (expt -1 1.0) -1.0+0.0i)+(num-test (expt 1 -1.0) 1.0)+(num-test (expt 1 our-pi) 1.0)+(num-test (expt -1 our-pi) -0.90268536193307-0.43030121700009i)+(num-test (expt 1 -3.14159265358979) 1.0)+(num-test (expt 1 2.71828182845905) 1.0)+(num-test (expt -1 2.71828182845905) -0.63325565131482+0.77394268526671i)+(num-test (expt 1 -2.71828182845905) 1.0)+(num-test (expt 1 1234.0) 1.0)+(num-test (expt -1 1234.0) 1.0)+(num-test (expt 1 -1234.0) 1.0)+(num-test (expt 1 1234000000.0) 1.0)+(num-test (expt -1 1234000000.0) 1.0)+(num-test (expt 1 -1234000000.0) 1.0)+(num-test (expt 2 0.0) 1.0)+(num-test (expt -2 0.0) 1.0)+(num-test (expt 2 -0.0) 1.0)+(num-test (expt 2 0.00000001) 1.00000000693147)+(num-test (expt -2 0.00000001) 1.00000000693147+0.00000003141593i)+(num-test (expt 2 -0.00000001) 0.99999999306853)+(num-test (expt 2 1.0) 2.0)+(num-test (expt -2 1.0) -2.0+0.0i)+(num-test (expt 2 -1.0) 0.50000000000000)+(num-test (expt 2 our-pi) 8.82497782707629)+(num-test (expt -2 our-pi) -7.96617830388569-3.79739869898975i)+(num-test (expt 2 -3.14159265358979) 0.11331473229676)+(num-test (expt 2 2.71828182845905) 6.58088599101792)+(num-test (expt -2 2.71828182845905) -4.16738324447062+5.09322857532248i)+(num-test (expt 2 -2.71828182845905) 0.15195522325791)+(num-test (expt 3 0.0) 1.0)+(num-test (expt -3 0.0) 1.0)+(num-test (expt 3 -0.0) 1.0)+(num-test (expt 3 0.00000001) 1.00000001098612)+(num-test (expt -3 0.00000001) 1.00000001098612+0.00000003141593i)+(num-test (expt 3 -0.00000001) 0.99999998901388)+(num-test (expt 3 1.0) 3.0)+(num-test (expt -3 1.0) -3.0+0.0i)+(num-test (expt 3 -1.0) 0.33333333333333)+(num-test (expt 3 our-pi) 31.54428070019755)+(num-test (expt -3 our-pi) -28.47456044077623-13.57354237468751i)+(num-test (expt 3 -3.14159265358979) 0.03170146783514)+(num-test (expt 3 2.71828182845905) 19.81299074527465)+(num-test (expt -3 2.71828182845905) -12.54668835889338+15.33411926056231i)+(num-test (expt 3 -2.71828182845905) 0.05047193595639)+(num-test (expt 10 0.0) 1.0)+(num-test (expt -10 0.0) 1.0)+(num-test (expt 10 -0.0) 1.0)+(num-test (expt 10 0.00000001) 1.00000002302585)+(num-test (expt -10 0.00000001) 1.00000002302585+0.00000003141593i)+(num-test (expt 10 -0.00000001) 0.99999997697415)+(num-test (expt 10 1.0) 10.0)+(num-test (expt -10 1.0) -10.0+0.0i)+(num-test (expt 10 -1.0) 0.1)+(num-test (expt 10 our-pi) 1385.45573136701182)+(num-test (expt -10 our-pi) -1250.63060831127905-596.16328730697728i)+(num-test (expt 10 -3.14159265358979) 0.00072178415907)+(num-test (expt 10 2.71828182845905) 522.73529967043669)+(num-test (expt -10 2.71828182845905) -331.02508265804954+404.56716151063557i)+(num-test (expt 10 -2.71828182845905) 0.00191301410222)+(num-test (expt 1234 0.0) 1.0)+(num-test (expt -1234 0.0) 1.0)+(num-test (expt 1234 -0.0) 1.0)+(num-test (expt 1234 0.00000001) 1.00000007118016)+(num-test (expt -1234 0.00000001) 1.00000007118016+0.00000003141593i)+(num-test (expt 1234 -0.00000001) 0.99999992881984)+(num-test (expt 1234 1.0) 1234.00000000000045)+(num-test (expt -1234 1.0) -1234.00000000000045+0.00000000000015i)+(num-test (expt 1234 -1.0) 0.00081037277147)+(num-test (expt 1234 -3.14159265358979) 0.00000000019424)+(num-test (expt 1234 2.71828182845905) 252968138.32201290130615)+(num-test (expt -1234 2.71828182845905) -160193503.19500353932381+195782840.25985893607140i)+(num-test (expt 1234 -2.71828182845905) 0.00000000395307)+(num-test (expt 1234000000 0.0) 1.0)+(num-test (expt -1234000000 0.0) 1.0)+(num-test (expt 1234000000 -0.0) 1.0)+(num-test (expt 1234000000 0.00000001) 1.00000020933529)+(num-test (expt -1234000000 0.00000001) 1.00000020933529+0.00000003141593i)+(num-test (expt 1234000000 -0.00000001) 0.99999979066475)+(num-test (expt 1234000000 -1.0) 0.00000000081037)+(num-test (expt 500029 0.0) 1.0)+(num-test (expt -500029 0.0) 1.0)+(num-test (expt 500029 -0.0) 1.0)+(num-test (expt 500029 0.00000001) 1.00000013122422)+(num-test (expt -500029 0.00000001) 1.00000013122422+0.00000003141593i)+(num-test (expt 500029 -0.00000001) 0.99999986877579)+(num-test (expt 500029 1.0) 500029.00000000040745)+(num-test (expt -500029 1.0) -500029.00000000040745+0.00000000006123i)+(num-test (expt 500029 -1.0) 0.00000199988401)+(num-test (expt 362880 0.0) 1.0)+(num-test (expt -362880 0.0) 1.0)+(num-test (expt 362880 -0.0) 1.0)+(num-test (expt 362880 0.00000001) 1.00000012801828)+(num-test (expt -362880 0.00000001) 1.00000012801828+0.00000003141593i)+(num-test (expt 362880 -0.00000001) 0.99999987198173)+(num-test (expt 362880 1.0) 362879.99999999982538)+(num-test (expt -362880 1.0) -362879.99999999982538+0.00000000004444i)+(num-test (expt 362880 -1.0) 0.00000275573192)+(num-test (expt 0.0 0.00000001) 0.0)+(num-test (expt -0.0 0.00000001) 0.0)+(num-test (expt 0.0 1.0) 0.0)+(num-test (expt -0.0 1.0) 0.0)+(num-test (expt 0.0 our-pi) 0.0)+(num-test (expt -0.0 our-pi) 0.0)+(num-test (expt 0.0 2.71828182845905) 0.0)+(num-test (expt -0.0 2.71828182845905) 0.0)+(num-test (expt 0.0 1234.0) 0.0)+(num-test (expt -0.0 1234.0) 0.0)+(num-test (expt 0.0 1234000000.0) 0.0)+(num-test (expt -0.0 1234000000.0) 0.0)+(num-test (expt 0.00000001 0.0) 1.0)+(num-test (expt -0.00000001 0.0) 1.0)+(num-test (expt 0.00000001 -0.0) 1.0)+(num-test (expt -0.00000001 -0.0) 1.0)+(num-test (expt 0.00000001 0.00000001) 0.99999981579321)+(num-test (expt -0.00000001 0.00000001) 0.99999981579321+0.00000003141592i)+(num-test (expt 0.00000001 -0.00000001) 1.00000018420682)+(num-test (expt -0.00000001 -0.00000001) 1.00000018420682-0.00000003141593i)+(num-test (expt 0.00000001 1.0) 0.00000001)+(num-test (expt -0.00000001 1.0) -0.00000001+0.0i)+(num-test (expt 0.00000001 -1.0) 100000000.00000017881393)+(num-test (expt -0.00000001 -1.0) -100000000.00000017881393-0.00000001224606i)+(num-test (expt 0.00000001 our-pi) 0.0)+(num-test (expt -0.00000001 our-pi) -0.0-0.0i)+(num-test (expt 0.00000001 2.71828182845905) 0.0)+(num-test (expt -0.00000001 2.71828182845905) -0.0+0.0i)+(num-test (expt 0.00000001 1234.0) 0.0)+(num-test (expt -0.00000001 1234.0) 0.0)+(num-test (expt 0.00000001 1234000000.0) 0.0)+(num-test (expt -0.00000001 1234000000.0) 0.0)+(num-test (expt 1.0 0.0) 1.0)+(num-test (expt -1.0 0.0) 1.0)+(num-test (expt 1.0 -0.0) 1.0)+(num-test (expt -1.0 -0.0) 1.0)+(num-test (expt 1.0 0.00000001) 1.0)+(num-test (expt -1.0 0.00000001) 1.0+0.00000003141593i)+(num-test (expt 1.0 -0.00000001) 1.0)+(num-test (expt -1.0 -0.00000001) 1.0-0.00000003141593i)+(num-test (expt 1.0 1.0) 1.0)+(num-test (expt -1.0 1.0) -1.0+0.0i)+(num-test (expt 1.0 -1.0) 1.0)+(num-test (expt -1.0 -1.0) -1.0-0.0i)+(num-test (expt 1.0 our-pi) 1.0)+(num-test (expt -1.0 our-pi) -0.90268536193307-0.43030121700009i)+(num-test (expt 1.0 -3.14159265358979) 1.0)+(num-test (expt -1.0 -3.14159265358979) -0.90268536193307+0.43030121700009i)+(num-test (expt 1.0 2.71828182845905) 1.0)+(num-test (expt -1.0 2.71828182845905) -0.63325565131482+0.77394268526671i)+(num-test (expt 1.0 -2.71828182845905) 1.0)+(num-test (expt -1.0 -2.71828182845905) -0.63325565131482-0.77394268526671i)+(num-test (expt 1.0 1234.0) 1.0)+(num-test (expt -1.0 1234.0) 1.0)+(num-test (expt 1.0 -1234.0) 1.0)+(num-test (expt -1.0 -1234.0) 1.0)+(num-test (expt 1.0 1234000000.0) 1.0)+(num-test (expt -1.0 1234000000.0) 1.0)+(num-test (expt 1.0 -1234000000.0) 1.0)+(num-test (expt -1.0 -1234000000.0) 1.0)+(num-test (expt 3.14159265358979 0.0) 1.0)+(num-test (expt -3.14159265358979 0.0) 1.0)+(num-test (expt 3.14159265358979 -0.0) 1.0)+(num-test (expt -3.14159265358979 -0.0) 1.0)+(num-test (expt 3.14159265358979 0.00000001) 1.00000001144730)+(num-test (expt -3.14159265358979 0.00000001) 1.00000001144730+0.00000003141593i)+(num-test (expt 3.14159265358979 -0.00000001) 0.99999998855270)+(num-test (expt -3.14159265358979 -0.00000001) 0.99999998855270-0.00000003141593i)+(num-test (expt 3.14159265358979 1.0) our-pi)+(num-test (expt -3.14159265358979 1.0) -3.14159265358979+0.0i)+(num-test (expt 3.14159265358979 -1.0) 0.31830988618379)+(num-test (expt -3.14159265358979 -1.0) -0.31830988618379-0.0i)+(num-test (expt 3.14159265358979 our-pi) 36.46215960720790)+(num-test (expt -3.14159265358979 our-pi) -32.91385774189388-15.68971165343314i)+(num-test (expt 3.14159265358979 -3.14159265358979) 0.02742569312330)+(num-test (expt -3.14159265358979 -3.14159265358979) -0.02475677172327+0.01180130912803i)+(num-test (expt 3.14159265358979 2.71828182845905) 22.45915771836104)+(num-test (expt -3.14159265358979 2.71828182845905) -14.22238854892297+17.38210083337688i)+(num-test (expt 3.14159265358979 -2.71828182845905) 0.04452526726692)+(num-test (expt -3.14159265358979 -2.71828182845905) -0.02819587712308-0.03446000491078i)+(num-test (expt 2.71828182845905 0.0) 1.0)+(num-test (expt -2.71828182845905 0.0) 1.0)+(num-test (expt 2.71828182845905 -0.0) 1.0)+(num-test (expt -2.71828182845905 -0.0) 1.0)+(num-test (expt 2.71828182845905 0.00000001) 1.00000001)+(num-test (expt -2.71828182845905 0.00000001) 1.00000001+0.00000003141593i)+(num-test (expt 2.71828182845905 -0.00000001) 0.99999999000000)+(num-test (expt -2.71828182845905 -0.00000001) 0.99999999000000-0.00000003141593i)+(num-test (expt 2.71828182845905 1.0) 2.71828182845905)+(num-test (expt -2.71828182845905 1.0) -2.71828182845905+0.0i)+(num-test (expt 2.71828182845905 -1.0) 0.36787944117144)+(num-test (expt -2.71828182845905 -1.0) -0.36787944117144-0.0i)+(num-test (expt 2.71828182845905 our-pi) 23.14069263277927)+(num-test (expt -2.71828182845905 our-pi) -20.88876450460231-9.95746820210997i)+(num-test (expt 2.71828182845905 -3.14159265358979) 0.04321391826377)+(num-test (expt -2.71828182845905 -3.14159265358979) -0.03900857144848+0.01859500162024i)+(num-test (expt 2.71828182845905 2.71828182845905) 15.15426224147926)+(num-test (expt -2.71828182845905 2.71828182845905) -9.59652220592352+11.72853041240636i)+(num-test (expt 2.71828182845905 -2.71828182845905) 0.06598803584531)+(num-test (expt -2.71828182845905 -2.71828182845905) -0.04178729661821-0.05107095765760i)+(num-test (expt 1234.0 0.0) 1.0)+(num-test (expt -1234.0 0.0) 1.0)+(num-test (expt 1234.0 -0.0) 1.0)+(num-test (expt -1234.0 -0.0) 1.0)+(num-test (expt 1234.0 0.00000001) 1.00000007118016)+(num-test (expt -1234.0 0.00000001) 1.00000007118016+0.00000003141593i)+(num-test (expt 1234.0 -0.00000001) 0.99999992881984)+(num-test (expt -1234.0 -0.00000001) 0.99999992881984-0.00000003141592i)+(num-test (expt 1234.0 1.0) 1234.00000000000045)+(num-test (expt -1234.0 1.0) -1234.00000000000045+0.00000000000015i)+(num-test (expt 1234.0 -1.0) 0.00081037277147)+(num-test (expt -1234.0 -1.0) -0.00081037277147-0.0i)+(num-test (expt 1234.0 -3.14159265358979) 0.00000000019424)+(num-test (expt -1234.0 -3.14159265358979) -0.00000000017534+0.00000000008358i)+(num-test (expt 1234.0 2.71828182845905) 252968138.32201290130615)+(num-test (expt -1234.0 2.71828182845905) -160193503.19500353932381+195782840.25985893607140i)+(num-test (expt 1234.0 -2.71828182845905) 0.00000000395307)+(num-test (expt -1234.0 -2.71828182845905) -0.00000000250330-0.00000000305945i)+(num-test (expt 1234000000.0 0.0) 1.0)+(num-test (expt -1234000000.0 0.0) 1.0)+(num-test (expt 1234000000.0 -0.0) 1.0)+(num-test (expt -1234000000.0 -0.0) 1.0)+(num-test (expt 1234000000.0 0.00000001) 1.00000020933529)+(num-test (expt -1234000000.0 0.00000001) 1.00000020933529+0.00000003141593i)+(num-test (expt 1234000000.0 -0.00000001) 0.99999979066475)+(num-test (expt -1234000000.0 -0.00000001) 0.99999979066475-0.00000003141592i)+(num-test (expt 1234000000.0 -1.0) 0.00000000081037)+(num-test (expt -1234000000.0 -1.0) -0.00000000081037-0.0i)+(num-test (expt 0.00000001 0) 1.0)+(num-test (expt -0.00000001 0) 1.0)+(num-test (expt 0.00000001 0) 1.0)+(num-test (expt -0.00000001 0) 1.0)+(num-test (expt 0.00000001 1) 0.00000001)+(num-test (expt -0.00000001 1) -0.00000001+0.0i)+(num-test (expt 0.00000001 -1) 100000000.00000017881393)+(num-test (expt -0.00000001 -1) -100000000.00000017881393-0.00000001224606i)+(num-test (expt 0.00000001 2) 0.0)+(num-test (expt -0.00000001 2) 0.0-0.0i)+(num-test (expt 0.00000001 3) 0.0)+(num-test (expt -0.00000001 3) -0.0+0.0i)+(num-test (expt 0.00000001 10) 0.0)+(num-test (expt -0.00000001 10) 0.0-0.0i)+(num-test (expt 0.00000001 1234) 0.0)+(num-test (expt -0.00000001 1234) 0.0)+(num-test (expt 0.00000001 1234000000) 0.0)+(num-test (expt -0.00000001 1234000000) 0.0)+(num-test (expt 0.00000001 500029) 0.0)+(num-test (expt -0.00000001 500029) -0.0)+(num-test (expt 0.00000001 362880) 0.0)+(num-test (expt -0.00000001 362880) 0.0)+(num-test (expt 1.0 0) 1.0)+(num-test (expt -1.0 0) 1.0)+(num-test (expt 1.0 0) 1.0)+(num-test (expt -1.0 0) 1.0)+(num-test (expt 1.0 1) 1.0)+(num-test (expt -1.0 1) -1.0+0.0i)+(num-test (expt 1.0 -1) 1.0)+(num-test (expt -1.0 -1) -1.0-0.0i)+(num-test (expt 1.0 2) 1.0)+(num-test (expt -1.0 2) 1.0-0.0i)+(num-test (expt 1.0 -2) 1.0)+(num-test (expt -1.0 -2) 1.0+0.0i)+(num-test (expt 1.0 3) 1.0)+(num-test (expt -1.0 3) -1.0+0.0i)+(num-test (expt 1.0 -3) 1.0)+(num-test (expt -1.0 -3) -1.0-0.0i)+(num-test (expt 1.0 10) 1.0)+(num-test (expt -1.0 10) 1.0-0.0i)+(num-test (expt 1.0 -10) 1.0)+(num-test (expt -1.0 -10) 1.0+0.0i)+(num-test (expt 1.0 1234) 1.0)+(num-test (expt -1.0 1234) 1.0)+(num-test (expt 1.0 -1234) 1.0)+(num-test (expt -1.0 -1234) 1.0)+(num-test (expt 1.0 1234000000) 1.0)+(num-test (expt -1.0 1234000000) 1.0)+(num-test (expt 1.0 -1234000000) 1.0)+(num-test (expt -1.0 -1234000000) 1.0)+(num-test (expt 1.0 500029) 1.0)+(num-test (expt -1.0 500029) -1.0)+(num-test (expt 1.0 -500029) 1.0)+(num-test (expt -1.0 -500029) -1.0)+(num-test (expt 1.0 362880) 1.0)+(num-test (expt -1.0 362880) 1.0)+(num-test (expt 1.0 -362880) 1.0)+(num-test (expt -1.0 -362880) 1.0)+(num-test (expt 3.14159265358979 0) 1.0)+(num-test (expt -3.14159265358979 0) 1.0)+(num-test (expt 3.14159265358979 0) 1.0)+(num-test (expt -3.14159265358979 0) 1.0)+(num-test (expt 3.14159265358979 1) our-pi)+(num-test (expt -3.14159265358979 1) -3.14159265358979+0.0i)+(num-test (expt 3.14159265358979 -1) 0.31830988618379)+(num-test (expt -3.14159265358979 -1) -0.31830988618379-0.0i)+(num-test (expt 3.14159265358979 2) 9.86960440108936)+(num-test (expt -3.14159265358979 2) 9.86960440108936-0.0i)+(num-test (expt 3.14159265358979 -2) 0.10132118364234)+(num-test (expt -3.14159265358979 -2) 0.10132118364234+0.0i)+(num-test (expt 3.14159265358979 3) 31.00627668029983)+(num-test (expt -3.14159265358979 3) -31.00627668029983)+(num-test (expt 3.14159265358979 -3) 0.03225153443320)+(num-test (expt -3.14159265358979 -3) -0.03225153443320-0.0i)+(num-test (expt 3.14159265358979 10) 93648.04747608296748)+(num-test (expt -3.14159265358979 10) 93648.04747608296748)+(num-test (expt 3.14159265358979 -10) 0.00001067827923)+(num-test (expt -3.14159265358979 -10) 0.00001067827923+0.0i)+(num-test (expt 2.71828182845905 0) 1.0)+(num-test (expt -2.71828182845905 0) 1.0)+(num-test (expt 2.71828182845905 0) 1.0)+(num-test (expt -2.71828182845905 0) 1.0)+(num-test (expt 2.71828182845905 1) 2.71828182845905)+(num-test (expt -2.71828182845905 1) -2.71828182845905+0.0i)+(num-test (expt 2.71828182845905 -1) 0.36787944117144)+(num-test (expt -2.71828182845905 -1) -0.36787944117144-0.0i)+(num-test (expt 2.71828182845905 2) 7.38905609893065)+(num-test (expt -2.71828182845905 2) 7.38905609893065-0.0i)+(num-test (expt 2.71828182845905 -2) 0.13533528323661)+(num-test (expt -2.71828182845905 -2) 0.13533528323661+0.0i)+(num-test (expt 2.71828182845905 3) 20.08553692318767)+(num-test (expt -2.71828182845905 3) -20.08553692318767+0.00000000000001i)+(num-test (expt 2.71828182845905 -3) 0.04978706836786)+(num-test (expt -2.71828182845905 -3) -0.04978706836786-0.0i)+(num-test (expt 2.71828182845905 10) 22026.46579480671789)+(num-test (expt -2.71828182845905 10) 22026.46579480671789-0.00000000002697i)+(num-test (expt 2.71828182845905 -10) 0.00004539992976)+(num-test (expt -2.71828182845905 -10) 0.00004539992976+0.0i)+(num-test (expt 1234.0 0) 1.0)+(num-test (expt -1234.0 0) 1.0)+(num-test (expt 1234.0 0) 1.0)+(num-test (expt -1234.0 0) 1.0)+(num-test (expt 1234.0 1) 1234.00000000000045)+(num-test (expt -1234.0 1) -1234.00000000000045+0.00000000000015i)+(num-test (expt 1234.0 -1) 0.00081037277147)+(num-test (expt -1234.0 -1) -0.00081037277147-0.0i)+(num-test (expt 1234.0 2) 1522756.00000000093132)+(num-test (expt -1234.0 2) 1522756.00000000093132-0.00000000037296i)+(num-test (expt 1234.0 -2) 0.00000065670403)+(num-test (expt -1234.0 -2) 0.00000065670403+0.0i)+(num-test (expt 1234.0 -3) 0.00000000053218)+(num-test (expt -1234.0 -3) -0.00000000053218-0.0i)+(num-test (expt 1234000000.0 0) 1.0)+(num-test (expt -1234000000.0 0) 1.0)+(num-test (expt 1234000000.0 0) 1.0)+(num-test (expt -1234000000.0 0) 1.0)+(num-test (expt 1234000000.0 -1) 0.00000000081037)+(num-test (expt -1234000000.0 -1) -0.00000000081037-0.0i)+(num-test (expt 0.0-1234000000.0i -1234000000.0+0.00000001i) 0.0)+(num-test (expt -0.0-1234000000.0i -1234000000.0-0.00000001i) 0.0)+(num-test (expt 0.00000001+0.0i 0.00000001+0.00000001i) 0.99999981579319-0.00000018420677i)+(num-test (expt -0.00000001+0.0i 0.00000001-0.00000001i) 0.99999984720911+0.00000021562270i)+(num-test (expt 0.00000001-0.0i -0.00000001+0.00000001i) 1.00000018420681-0.00000018420684i)+(num-test (expt -0.00000001-0.0i -0.00000001-0.00000001i) 1.00000021562275+0.00000015279091i)+(num-test (expt 0.00000001+0.00000001i 1.0+0.0i) 0.00000001+0.00000001i)+(num-test (expt -0.00000001+0.00000001i 1.0-0.0i) -0.00000001+0.00000001i)+(num-test (expt 0.00000001-0.00000001i -1.0+0.0i) 50000000.00000004470348+50000000.00000003725290i)+(num-test (expt -0.00000001-0.00000001i -1.0-0.0i) -50000000.00000003725290+50000000.00000004470348i)+(num-test (expt 1.0+0.00000001i 3.14159265358979+0.00000001i) 1.0+0.00000003141593i)+(num-test (expt -1.0+0.00000001i 3.14159265358979-0.00000001i) -0.90268540381008-0.43030120215971i)+(num-test (expt 1.0-0.00000001i -3.14159265358979+0.00000001i) 1.0+0.00000003141593i)+(num-test (expt -1.0-0.00000001i -3.14159265358979-0.00000001i) -0.90268534709269-0.43030117512308i)+(num-test (expt 1.0+1.0i 2.71828182845905+0.0i) -1.37164508585166+2.16782742612896i)+(num-test (expt -1.0+1.0i 2.71828182845905-0.0i) 2.54637618158683+0.31121428769451i)+(num-test (expt 1.0-1.0i -2.71828182845905+0.0i) -0.20842863525121+0.32941270052205i)+(num-test (expt -1.0-1.0i -2.71828182845905-0.0i) 0.38693516117166+0.04729063656767i)+(num-test (expt 3.14159265358979-1.0i -1234.0+0.00000001i) -0.0)+(num-test (expt -3.14159265358979-1.0i -1234.0-0.00000001i) -0.0)+(num-test (expt 3.14159265358979-3.14159265358979i -1234000000.0+0.0i) 0.0)+(num-test (expt -3.14159265358979-3.14159265358979i -1234000000.0-0.0i) 0.0)+(num-test (expt 2.71828182845905+3.14159265358979i 0.0+0.00000001i) 0.99999999142488+0.00000001424157i)+(num-test (expt -2.71828182845905+3.14159265358979i 0.0-0.00000001i) 1.00000002284081-0.00000001424157i)+(num-test (expt 2.71828182845905-3.14159265358979i -0.0+0.00000001i) 1.00000000857512+0.00000001424157i)+(num-test (expt -2.71828182845905-3.14159265358979i -0.0-0.00000001i) 0.99999997715919-0.00000001424157i)+(num-test (expt 2.71828182845905+2.71828182845905i 0.00000001+0.0i) 1.00000001346574+0.00000000785398i)+(num-test (expt -2.71828182845905+2.71828182845905i 0.00000001-0.0i) 1.00000001346574+0.00000002356195i)+(num-test (expt 2.71828182845905-2.71828182845905i -0.00000001+0.0i) 0.99999998653426+0.00000000785398i)+(num-test (expt -2.71828182845905-2.71828182845905i -0.00000001-0.0i) 0.99999998653426+0.00000002356194i)+(num-test (expt 1234.0+2.71828182845905i 1.0+0.00000001i) 1233.99999977932634+2.71836966474906i)+(num-test (expt -1234.0+2.71828182845905i 1.0-0.00000001i) -1234.00003854658053+2.71836975014915i)+(num-test (expt 1234.0-2.71828182845905i -1.0+0.00000001i) 0.00081036883911+0.00000178515565i)+(num-test (expt -1234.0-2.71828182845905i -1.0-0.00000001i) -0.00081036881365+0.00000178515559i)+(num-test (expt 1234.0+1234.0i 3.14159265358979+0.0i) -11947544392.17545890808105+9547275530.50568199157715i)+(num-test (expt -1234.0+1234.0i 3.14159265358979-0.0i) 6676669154.05054950714111+13759228759.84499740600586i)+(num-test (expt 1234.0-1234.0i -3.14159265358979+0.0i) -5.108095859217296E-11+4.081876325659167E-11i)+(num-test (expt -1234.0-1234.0i -3.14159265358979-0.0i) 2.854567008891443E-11+5.882669873167984E-11i)+(num-test (expt 1234000000.0-1234.0i -2.71828182845905+0.00000001i) 0.0+0.0i)+(num-test (expt -1234000000.0-1234.0i -2.71828182845905-0.00000001i) -0.0+0.0i)+(num-test (expt 1234000000.0-1234000000.0i -1234.0+0.0i) 0.0)+(num-test (expt -1234000000.0-1234000000.0i -1234.0-0.0i) 0.0)+(num-test (expt 1.0e+00+0.0e+00i 0.0e+00+0.0e+00i) 1e0+0.0i)+(num-test (expt 1.0e+00+0.0e+00i 1.0e+00+0.0e+00i) 1e0+0.0i)+(num-test (expt 1.0e+00+0.0e+00i 0.0e+00+1.0e+00i) 1e0+0.0i)+(num-test (expt 1.0e+00+0.0e+00i -1.0e+00+0.0e+00i) 1e0+0.0i)+(num-test (expt 1.0e+00+0.0e+00i 0.0e+00-1.0e+00i) 1e0+0.0i)+(num-test (expt 1.0e+00+0.0e+00i 5.0e-01+1.00000000000000005551e-01i) 1e0+0.0i)+(num-test (expt 1.0e+00+0.0e+00i 5.0e-01-1.00000000000000005551e-01i) 1e0+0.0i)+(num-test (expt 0.0e+00+1.0e+00i 0.0e+00+0.0e+00i) 1e0+0.0i)+(num-test (expt 0.0e+00+1.0e+00i 1.0e+00+0.0e+00i) 0+1i)+(num-test (expt 0.0e+00+1.0e+00i 0.0e+00+1.0e+00i) 2.0787957635076190855e-1+0.0i)+(num-test (expt 0.0e+00+1.0e+00i -1.0e+00+0.0e+00i) 0-1i)+(num-test (expt 0.0e+00+1.0e+00i 0.0e+00-1.0e+00i) 4.8104773809653516555e0+0.0i)+(num-test (expt 0.0e+00+1.0e+00i 5.0e-01+1.00000000000000005551e-01i) 6.0431891044739184057e-1+6.0431891044739184057e-1i)+(num-test (expt 0.0e+00+1.0e+00i 5.0e-01-1.00000000000000005551e-01i) 8.2737771622906514822e-1+8.2737771622906514822e-1i)+(num-test (expt -1.0e+00+0.0e+00i 0.0e+00+0.0e+00i) 1e0+0.0i)+(num-test (expt -1.0e+00+0.0e+00i 1.0e+00+0.0e+00i) -1e0+0.0i)+(num-test (expt -1.0e+00+0.0e+00i 0.0e+00+1.0e+00i) 4.3213918263772249774e-2+0.0i)+(num-test (expt -1.0e+00+0.0e+00i -1.0e+00+0.0e+00i) -1e0+0.0i)+(num-test (expt -1.0e+00+0.0e+00i 0.0e+00-1.0e+00i) 2.3140692632779269006e1+0.0i)+(num-test (expt -1.0e+00+0.0e+00i 5.0e-01+1.00000000000000005551e-01i) 0+7.3040269104864559813e-1i)+(num-test (expt -1.0e+00+0.0e+00i 5.0e-01-1.00000000000000005551e-01i) 0+1.3691077706248469087e0i)+(num-test (expt 0.0e+00-1.0e+00i 0.0e+00+0.0e+00i) 1e0+0.0i)+(num-test (expt 0.0e+00-1.0e+00i 1.0e+00+0.0e+00i) 0-1i)+(num-test (expt 0.0e+00-1.0e+00i 0.0e+00+1.0e+00i) 4.8104773809653516555e0+0.0i)+(num-test (expt 0.0e+00-1.0e+00i -1.0e+00+0.0e+00i) 0+1i)+(num-test (expt 0.0e+00-1.0e+00i 0.0e+00-1.0e+00i) 2.0787957635076190855e-1+0.0i)+(num-test (expt 0.0e+00-1.0e+00i 5.0e-01+1.00000000000000005551e-01i) 8.2737771622906514822e-1-8.2737771622906514822e-1i)+(num-test (expt 0.0e+00-1.0e+00i 5.0e-01-1.00000000000000005551e-01i) 6.0431891044739184057e-1-6.0431891044739184057e-1i)+(num-test (expt 5.0e-01+1.00000000000000005551e-01i 0.0e+00+0.0e+00i) 1e0+0.0i)+(num-test (expt 5.0e-01+1.00000000000000005551e-01i 1.0e+00+0.0e+00i) 5e-1+1.0000000000000000555e-1i)+(num-test (expt 5.0e-01+1.00000000000000005551e-01i 0.0e+00+1.0e+00i) 6.4160554864378080418e-1-5.1201864456768275590e-1i)+(num-test (expt 5.0e-01+1.00000000000000005551e-01i -1.0e+00+0.0e+00i) 1.9230769230769230687e0-3.8461538461538463509e-1i)+(num-test (expt 5.0e-01+1.00000000000000005551e-01i 0.0e+00-1.0e+00i) 9.5219021866126714108e-1+7.5987364224031834571e-1i)+(num-test (expt 5.0e-01+1.00000000000000005551e-01i 5.0e-01+1.00000000000000005551e-01i) 6.9977300530987816719e-1+2.1940939105372143160e-2i)+(num-test (expt 5.0e-01+1.00000000000000005551e-01i 5.0e-01-1.00000000000000005551e-01i) 7.1829191470060938876e-1+1.2038189555821612762e-1i)+(num-test (expt 5.0e-01-1.00000000000000005551e-01i 0.0e+00+0.0e+00i) 1e0+0.0i)+(num-test (expt 5.0e-01-1.00000000000000005551e-01i 1.0e+00+0.0e+00i) 5e-1-1.0000000000000000555e-1i)+(num-test (expt 5.0e-01-1.00000000000000005551e-01i 0.0e+00+1.0e+00i) 9.5219021866126714108e-1-7.5987364224031834571e-1i)+(num-test (expt 5.0e-01-1.00000000000000005551e-01i -1.0e+00+0.0e+00i) 1.9230769230769230687e0+3.8461538461538463509e-1i)+(num-test (expt 5.0e-01-1.00000000000000005551e-01i 0.0e+00-1.0e+00i) 6.4160554864378080418e-1+5.1201864456768275590e-1i)+(num-test (expt 5.0e-01-1.00000000000000005551e-01i 5.0e-01+1.00000000000000005551e-01i) 7.1829191470060938876e-1-1.2038189555821612762e-1i)+(num-test (expt 5.0e-01-1.00000000000000005551e-01i 5.0e-01-1.00000000000000005551e-01i) 6.9977300530987816719e-1-2.1940939105372143160e-2i)++(num-test (expt 0 10) 0)+(num-test (expt 1 10) 1)+(num-test (expt 2 10) 1024)+(num-test (expt 3 10) 59049)+(num-test (expt 4 10) 1048576)+(num-test (expt 5 10) 9765625)+(num-test (expt 6 10) 60466176)+(num-test (expt 7 10) 282475249)+(num-test (expt 8 10) 1073741824)+(if (or with-bignums with-64-bit-ints) (num-test (expt 9 10) 3486784401))+(if (or with-bignums with-64-bit-ints) (num-test (expt 10 10) 10000000000))+(if (or with-bignums with-64-bit-ints) (num-test (expt 11 10) 25937424601))+(num-test (expt 0 1/10) 0)+(num-test (expt 1 1/10) 1)+(num-test (expt 1024 1/10) 2)+(num-test (expt 59049 1/10) 3)+(num-test (expt 1048576 1/10) 4)+(num-test (expt 9765625 1/10) 5)+(num-test (expt 60466176 1/10) 6)+(num-test (expt 282475249 1/10) 7)+(num-test (expt 1073741824 1/10) 8)+(if (or with-bignums with-64-bit-ints) (num-test (expt 3486784401 1/10) 9))+(if (or with-bignums with-64-bit-ints) (num-test (expt 10000000000 1/10) 10))+(if (or with-bignums with-64-bit-ints) (num-test (expt 25937424601 1/10) 11))+(num-test (expt 2 9) 512)+(num-test (expt 8 1/3) 2)+(num-test (expt 1024 1/10) 2)+(num-test (expt 512 1/9) 2)+(num-test (expt (expt 20 10) 1/10) 20)+(num-test (expt (expt 40 10) 1/10) 40)+(num-test (expt (expt 2 30) 1/30) 2)+(num-test (expt (expt 2 50) 1/50) 2)+(num-test (expt (expt 2 1/10) 10) 2)+(num-test (expt (expt 2 1/30) 30) 2)+(num-test (expt 64 1/6) 2)+(num-test (expt 64 1/3) 4)+(num-test (expt 64 2/3) 16)+(num-test (expt 64 1/2) 8)+(num-test (expt 64 3/2) 512)+(num-test (expt 1/2 3) 1/8)+(num-test (expt 1/64 1/2) 1/8)+(num-test (expt 1/64 1/3) 1/4)+(num-test (expt 1/64 3/2) 1/512)+(num-test (expt 1/64 2/3) 1/16)+(num-test (expt 1/2 10) 1/1024)+(num-test (expt 2/3 5) (* 2/3 2/3 2/3 2/3 2/3))+(num-test (expt 2 -10) 1/1024)+(num-test (expt 2 -9) 1/512)+(num-test (expt 64 -1/6) 1/2)+(num-test (expt 64 -1/3) 1/4)+(num-test (expt 64 -2/3) 1/16)+(num-test (expt 64 -1/2) 1/8)+(num-test (expt 64 -3/2) 1/512)+(num-test (expt 1/2 -3) 8)+(num-test (expt 1/64 -1/2) 8)+(num-test (expt 1/64 -1/3) 4)+(num-test (expt 1/64 -3/2) 512)+(num-test (expt 1/64 -2/3) 16)+(num-test (expt 1/2 -10) 1024)+(num-test (expt 2718/1000 617/5) 3.858179469787681136058424024656091858698003418770850904916305853631035158956514884526199288e53) ; not an int!+(num-test (expt 2/3 -5) (/ 1 (* 2/3 2/3 2/3 2/3 2/3)))+;(num-test (expt 0 0.0) 0.0) ; ?? -- guile returns 1.0+(num-test (expt 0 1.0+i) 0.0) ; ??+;(num-test (expt 0 -1.0+i) 0.0) ; ?? guile says +inf.0+nan.0i+(num-test (expt 0 1.0) 0.0)+;(num-test (expt 0 -1.0) 0.0) ; ?? guile says inf+(test (expt 0 0) 1 )+(test (expt 0 1) 0 )+(test (expt 0 256) 0 )+;(test (expt 0 -255) 0 )+(test (expt -1 256) 1 )+(test (expt -1 255) -1 )+(test (expt -1 -256) 1 )+(test (expt -1 -255) -1 )+(test (expt 256 0) 1 )+(test (expt -256 0) 1 )+(test (expt 256 1) 256 )+(test (expt -256 1) -256 )+(test (expt 2 3) 8 )+(test (expt -2 3) -8 )+(test (expt 3 2) 9 )+(test (expt -3 2) 9 )++(let ((x-10 (lambda (n) (- (expt n 10) (* n n n n n n n n n n)))))+  (let ((happy #t)+	(lim (if with-bignums 100+		 (if with-64-bit-ints 74+		     8))))+    (do ((i 1 (+ i 2)))+	((or (not happy) (> i lim))) ; stop around 63 bits+      (let ((val (x-10 (/ i 2))))+	(if (not (= val 0))+	    (begin+	      (set! happy #f)+	      (display "(expt ") (display i) (display "/2 10) = ") (display (expt (/ i 2) 10))+	      (display " but (* ") (display i) (display "/2 ... 10x) = ")+	      (display (/ (* i i i i i i i i i i) 1024)) (newline)))))))++(let ((x-10 (lambda (n) (- (expt n -10) (/ 1 (* n n n n n n n n n n))))))+  (let ((happy #t)+	(lim (if with-bignums 100+		 (if with-64-bit-ints 74+		     8))))+    (do ((i 1 (+ i 2)))+	((or (not happy) (> i lim))) ; stop around 63 bits+      (let ((val (x-10 (/ i 2))))+	(if (not (= val 0))+	    (begin+	      (set! happy #f)+	      (display "(expt ") (display i) (display "/2 -10) = ") (display (expt (/ i 2) -10))+	      (display " but (* 1/(") (display i) (display "/2) ... 10x) = ")+	      (display (/ 1024 (* i i i i i i i i i i)))+	      (display " [diff=") (display val) (display "]")+	      (newline)))))))++(let ((happy #t)+      (lim (if with-bignums 50+	       (if with-64-bit-ints 19+		   4))))+  (do ((i 1 (+ i 1)))+      ((or (not happy) (> i lim)))+    (let* ((val1 (expt 3 i))+	   (val2 (sqrt (* val1 val1))))+      (if (not (= val1 val2))+	  (begin+	    (set! happy #f)+	    (display "[3^i] (sqrt ") (display (* val1 val1)) (display " = ") (display val2)+	      (display " but should be ") (display val1) (newline))))))++++;;; -------- rationalize (both versions)++(if with-rationalize+    (begin+      (num-test (rationalize 0.0 1.0001) 0)+      (num-test (rationalize -0.0 1.0001) 0)+      (num-test (rationalize 0.0 0.50000000000000) 0)+      (num-test (rationalize -0.0 0.50000000000000) 0)+      (num-test (rationalize 0.0 0.1) 0)+      (num-test (rationalize -0.0 0.1) 0)+      (num-test (rationalize 0.0 0.001) 0)+      (num-test (rationalize -0.0 0.001) 0)+      (num-test (rationalize 0.0 0.00300000000000) 0)+      (num-test (rationalize -0.0 0.00300000000000) 0)+      (num-test (rationalize 0.0 0.00002000000000) 0)+      (num-test (rationalize -0.0 0.00002000000000) 0)+      (num-test (rationalize 0.0 0.00000001) 0)+      (num-test (rationalize -0.0 0.00000001) 0)+      (num-test (rationalize 0.00000001 1.0) 0)+      (num-test (rationalize -0.00000001 1.0) 0)+      (num-test (rationalize 0.00000001 0.50000000000000) 0)+      (num-test (rationalize -0.00000001 0.50000000000000) 0)+      (num-test (rationalize 0.00000001 0.1) 0)+      (num-test (rationalize -0.00000001 0.1) 0)+      (num-test (rationalize 0.00000001 0.001) 0)+      (num-test (rationalize -0.00000001 0.001) 0)+      (num-test (rationalize 0.00000001 0.00300000000000) 0)+      (num-test (rationalize -0.00000001 0.00300000000000) 0)+      (num-test (rationalize 0.00000001 0.00002000000000) 0)+      (num-test (rationalize -0.00000001 0.00002000000000) 0)+      (num-test (rationalize 0.00000001 0.000000011) 0)+      (num-test (rationalize -0.00000001 0.000000011) 0)+      (num-test (rationalize 1.0 1.0001) 0)+      (num-test (rationalize -1.0 1.0001) 0)+      (num-test (rationalize 1.0 0.999) 1)+      (num-test (rationalize -1.0 0.999) -1)+      (num-test (rationalize 1.0 0.50000000000000) 1)+      (num-test (rationalize -1.0 0.50000000000000) -1)+      (num-test (rationalize 1.0 0.1) 1)+      (num-test (rationalize -1.0 0.1) -1)+      (num-test (rationalize 1.0 0.001) 1)+      (num-test (rationalize -1.0 0.001) -1)+      (num-test (rationalize 1.0 0.00300000000000) 1)+      (num-test (rationalize -1.0 0.00300000000000) -1)+      (num-test (rationalize 1.0 0.00002000000000) 1)+      (num-test (rationalize -1.0 0.00002000000000) -1)+      (num-test (rationalize 1.0 0.00000001) 1)+      (num-test (rationalize -1.0 0.00000001) -1)+      (num-test (rationalize 3.14159265358979 1.0) 3)+      (num-test (rationalize -3.14159265358979 1.0) -3)+      (num-test (rationalize 3.14159265358979 0.50000000000000) 3)+      (num-test (rationalize -3.14159265358979 0.50000000000000) -3)+      (num-test (rationalize 3.14159265358979 0.1) 16/5)+      (num-test (rationalize -3.14159265358979 0.1) -16/5)+      (num-test (rationalize 3.14159265358979 0.001) 201/64)+      (num-test (rationalize -3.14159265358979 0.001) -201/64)+      (num-test (rationalize 3.14159265358979 0.00300000000000) 22/7)+      (num-test (rationalize -3.14159265358979 0.00300000000000) -22/7)+      (num-test (rationalize 3.14159265358979 0.00002000000000) 355/113)+      (num-test (rationalize -3.14159265358979 0.00002000000000) -355/113)+      (num-test (rationalize 3.14159265358979 0.00000001) 100798/32085)+      (num-test (rationalize -3.14159265358979 0.00000001) -100798/32085)+      (num-test (rationalize 2.71828182845905 1.0) 2)+      (num-test (rationalize -2.71828182845905 1.0) -2)+      (num-test (rationalize 2.71828182845905 0.50000000000000) 3)+      (num-test (rationalize -2.71828182845905 0.50000000000000) -3)+      (num-test (rationalize 2.71828182845905 0.1) 8/3)+      (num-test (rationalize -2.71828182845905 0.1) -8/3)+      (num-test (rationalize 2.71828182845905 0.001) 87/32)+      (num-test (rationalize -2.71828182845905 0.001) -87/32)+      (num-test (rationalize 2.71828182845905 0.00300000000000) 68/25)+      (num-test (rationalize -2.71828182845905 0.00300000000000) -68/25)+      (num-test (rationalize 2.71828182845905 0.00002000000000) 878/323)+      (num-test (rationalize -2.71828182845905 0.00002000000000) -878/323)+      (num-test (rationalize 2.71828182845905 0.00000001) 23225/8544)+      (num-test (rationalize -2.71828182845905 0.00000001) -23225/8544)+      (num-test (rationalize 1234.12339999999995 1.0) 1234)+      (num-test (rationalize -1234.12339999999995 1.0) -1234)+      (num-test (rationalize 1234.12339999999995 0.50000000000000) 1234)+      (num-test (rationalize -1234.12339999999995 0.50000000000000) -1234)+      (num-test (rationalize 1234.12339999999995 0.1) 6171/5)+      (num-test (rationalize -1234.12339999999995 0.1) -6171/5)+      (num-test (rationalize 1234.12339999999995 0.001) 60472/49)+      (num-test (rationalize -1234.12339999999995 0.001) -60472/49)+      (num-test (rationalize 1234.12339999999995 0.00300000000000) 9873/8)+      (num-test (rationalize -1234.12339999999995 0.00300000000000) -9873/8)+      (num-test (rationalize 1234.12339999999995 0.00002000000000) 290019/235)+      (num-test (rationalize -1234.12339999999995 0.00002000000000) -290019/235)+      (num-test (rationalize 1234.12339999999995 0.00000001) 6170617/5000)+      (num-test (rationalize -1234.12339999999995 0.00000001) -6170617/5000)+      (num-test (rationalize 1234000000.01234006881714 1.0) 1234000000/1)+      (num-test (rationalize -1234000000.01234006881714 1.0) -1234000000/1)+      (num-test (rationalize 1234000000.01234006881714 0.50000000000000) 1234000000/1)+      (num-test (rationalize -1234000000.01234006881714 0.50000000000000) -1234000000/1)+      (num-test (rationalize 1234000000.01234006881714 0.1) 1234000000/1)+      (num-test (rationalize -1234000000.01234006881714 0.1) -1234000000/1)+      (num-test (rationalize 1234000000.01234006881714 0.001) 92550000001/75)+      (num-test (rationalize -1234000000.01234006881714 0.001) -92550000001/75)+      (num-test (rationalize 1234000000.01234006881714 0.00300000000000) 81444000001/66)+      (num-test (rationalize -1234000000.01234006881714 0.00300000000000) -81444000001/66)+      (num-test (rationalize 1234000000.01234006881714 0.00002000000000) 99954000001/81)+      (num-test (rationalize -1234000000.01234006881714 0.00002000000000) -99954000001/81)+      (num-test (rationalize 1234000000.01234006881714 0.000001) 2400130000024/1945)+      (num-test (rationalize -1234000000.01234006881714 0.000001) -2400130000024/1945)+      (num-test (rationalize 0.33 1.0) 0)+      (num-test (rationalize -0.33 1.0) 0)+      (num-test (rationalize 0.33 0.50000000000000) 0)+      (num-test (rationalize -0.33 0.50000000000000) 0)+      (num-test (rationalize 0.33 0.1) 1/3)+      (num-test (rationalize -0.33 0.1) -1/3)+      (num-test (rationalize 0.33 0.001) 26/79)+      (num-test (rationalize -0.33 0.001) -26/79)+      (num-test (rationalize 0.33 0.00300000000000) 18/55)+      (num-test (rationalize -0.33 0.00300000000000) -18/55)+      (num-test (rationalize 0.33 0.00002000000000) 33/100)+      (num-test (rationalize -0.33 0.00002000000000) -33/100)+      (num-test (rationalize 0.33 0.00000001) 33/100)+      (num-test (rationalize -0.33 0.00000001) -33/100)+      (num-test (rationalize 0.99990 1.0) 0)+      (num-test (rationalize -0.99990 1.0) 0)+      (num-test (rationalize 0.99990 0.50000000000000) 1)+      (num-test (rationalize -0.99990 0.50000000000000) -1)+      (num-test (rationalize 0.99990 0.1) 1)+      (num-test (rationalize -0.99990 0.1) -1)+      (num-test (rationalize 0.99990 0.001) 1)+      (num-test (rationalize -0.99990 0.001) -1)+      (num-test (rationalize 0.99990 0.00300000000000) 1)+      (num-test (rationalize -0.99990 0.00300000000000) -1)+      (num-test (rationalize 0.99990 0.00002000000000) 8333/8334)+      (num-test (rationalize -0.99990 0.00002000000000) -8333/8334)+      (num-test (rationalize 0.99990 0.00000001) 9999/10000)+      (num-test (rationalize -0.99990 0.00000001) -9999/10000)+      (num-test (rationalize 0.5010 1.0) 0)+      (num-test (rationalize -0.5010 1.0) 0)+      (num-test (rationalize 0.5010 0.50000000000000) 1)+      (num-test (rationalize -0.5010 0.50000000000000) -1)+      (num-test (rationalize 0.5010 0.1) 1/2)+      (num-test (rationalize -0.5010 0.1) -1/2)+      (num-test (rationalize 0.5010 0.00099) 127/253)+      (num-test (rationalize -0.5010 0.00099) -127/253)+      (num-test (rationalize 0.5010 0.00300000000000) 1/2)+      (num-test (rationalize -0.5010 0.00300000000000) -1/2)+      (num-test (rationalize 0.5010 0.00002000000000) 246/491)+      (num-test (rationalize -0.5010 0.00002000000000) -246/491)+      (num-test (rationalize 0.5010 0.00000001) 501/1000)+      (num-test (rationalize -0.5010 0.00000001) -501/1000)+      (num-test (rationalize 0.499 1.0) 0)+      (num-test (rationalize -0.499 1.0) 0)+      (num-test (rationalize 0.499 0.50000000000000) 0)+      (num-test (rationalize -0.499 0.50000000000000) 0)+      (num-test (rationalize 0.499 0.1) 1/2)+      (num-test (rationalize -0.499 0.1) -1/2)+      (num-test (rationalize 0.499 0.00099) 126/253)+      (num-test (rationalize -0.499 0.00099) -126/253)+      (num-test (rationalize 0.499 0.00300000000000) 1/2)+      (num-test (rationalize -0.499 0.00300000000000) -1/2)+      (num-test (rationalize 0.499 0.00002000000000) 245/491)+      (num-test (rationalize -0.499 0.00002000000000) -245/491)+      (num-test (rationalize 0.499 0.00000001) 499/1000)+      (num-test (rationalize -0.499 0.00000001) -499/1000)+      (num-test (rationalize 1.501 1.0) 1)+      (num-test (rationalize -1.501 1.0) -1)+      (num-test (rationalize 1.501 0.50000000000000) 2)+      (num-test (rationalize -1.501 0.50000000000000) -2)+      (num-test (rationalize 1.501 0.1) 3/2)+      (num-test (rationalize -1.501 0.1) -3/2)+      (num-test (rationalize 1.501 0.001) 3/2)+      (num-test (rationalize -1.501 0.001) -3/2)+      (num-test (rationalize 1.501 0.00300000000000) 3/2)+      (num-test (rationalize -1.501 0.00300000000000) -3/2)+      (num-test (rationalize 1.501 0.00002000000000) 737/491)+      (num-test (rationalize -1.501 0.00002000000000) -737/491)+      (num-test (rationalize 1.501 0.00000001) 1501/1000)+      (num-test (rationalize -1.501 0.00000001) -1501/1000)+      (num-test (rationalize 1.499 1.0) 1)+      (num-test (rationalize -1.499 1.0) -1)+      (num-test (rationalize 1.499 0.50000000000000) 1)+      (num-test (rationalize -1.499 0.50000000000000) -1)+      (num-test (rationalize 1.499 0.1) 3/2)+      (num-test (rationalize -1.499 0.1) -3/2)+      (num-test (rationalize 1.499 0.001) 3/2)+      (num-test (rationalize -1.499 0.001) -3/2)+      (num-test (rationalize 1.499 0.00300000000000) 3/2)+      (num-test (rationalize -1.499 0.00300000000000) -3/2)+      (num-test (rationalize 1.499 0.00002000000000) 736/491)+      (num-test (rationalize -1.499 0.00002000000000) -736/491)+      (num-test (rationalize 1.499 0.00000001) 1499/1000)+      (num-test (rationalize -1.499 0.00000001) -1499/1000)++      (num-test (rationalize 1.16 .2) 1)+      (num-test (rationalize 1.16 .1) 5/4)+      (num-test (rationalize 1.16 .041) 6/5)+      (num-test (rationalize 1.16 .039) 7/6)+      (num-test (rationalize 1.16 .007) 7/6)+      (num-test (rationalize 1.16 .006) 22/19)+      (num-test (rationalize 1.16 .0022) 22/19)+      (num-test (rationalize 1.16 .002) 29/25)+      (num-test (rationalize 1.16 .0000001) 29/25)++      (num-test (rationalize 23.1 22.0) 2)+      (num-test (rationalize 23.1 22) 2)+      (num-test (rationalize 23.1 .5) 23)+      (num-test (rationalize 23.1 1/2) 23)++      (num-test (rationalize 1/2 3/4) 0)+      (num-test (rationalize 1/2 1/4) 1/2)+      (num-test (rationalize 1 3) 0)+      (num-test (rationalize 11/10 1/5) 1)+      (num-test (rationalize 3/4 1/2) 1)+      (num-test (rationalize 1/4 1/3) 0)+      (num-test (rationalize 1/4 1/6) 1/3)+      (num-test (rationalize 2/3 1/4) 1/2)+      (num-test (rationalize 1/3 1/3) 0)+      (num-test (rationalize 1/3 1/4) 1/2)+      (num-test (rationalize 3/10 1/10) 1/3)++      (num-test (rationalize (exact->inexact 1/2) 3/4) 0)+      (num-test (rationalize (exact->inexact 1/2) 1/4) 1/2)+      (num-test (rationalize (exact->inexact 1) 3) 0)+      (num-test (rationalize (exact->inexact 11/10) 1/5) 1)+      (num-test (rationalize (exact->inexact 3/4) 1/2) 1)+      (num-test (rationalize (exact->inexact 1/4) 1/3) 0)+      (num-test (rationalize (exact->inexact 1/4) 1/6) 1/3)+      (num-test (rationalize (exact->inexact 2/3) 1/4) 1/2)+      (num-test (rationalize (exact->inexact 1/3) 1/4) 1/2)+      (num-test (rationalize (exact->inexact 3/10) 1/10) 1/3)++      (num-test (rationalize 1/2 (exact->inexact 3/4)) 0)+      (num-test (rationalize 1/2 (exact->inexact 1/4)) 1/2)+      (num-test (rationalize 1 (exact->inexact 3)) 0)+      (num-test (rationalize 11/10 (exact->inexact 1/5)) 1)+      (num-test (rationalize 3/4 (exact->inexact 1/2)) 1)+      (num-test (rationalize 1/4 (exact->inexact 1/3)) 0)+      (num-test (rationalize 1/4 (exact->inexact 1/6)) 1/3)+      (num-test (rationalize 2/3 (exact->inexact 1/4)) 1/2)+      (num-test (rationalize 1/3 (exact->inexact 1/4)) 1/2)+      (num-test (rationalize 3/10 (exact->inexact 1/10)) 1/3)++      (num-test (rationalize (exact->inexact 1/2) (exact->inexact 3/4)) 0)+      (num-test (rationalize (exact->inexact 1/2) (exact->inexact 1/4)) 1/2)+      (num-test (rationalize (exact->inexact 1) (exact->inexact 3)) 0)+      (num-test (rationalize (exact->inexact 11/10) (exact->inexact 1/5)) 1)+      (num-test (rationalize (exact->inexact 3/4) (exact->inexact 1/2)) 1)+      (num-test (rationalize (exact->inexact 1/4) (exact->inexact 1/3)) 0)+      (num-test (rationalize (exact->inexact 1/4) (exact->inexact 1/6)) 1/3)+      (num-test (rationalize (exact->inexact 2/3) (exact->inexact 1/4)) 1/2)+      (num-test (rationalize (exact->inexact 1/3) (exact->inexact 1/4)) 1/2)+      (num-test (rationalize (exact->inexact 3/10) (exact->inexact 1/10)) 1/3)++      (num-test (rationalize -1/2 3/4) 0)+      (num-test (rationalize -1/2 1/4) -1/2)+      (num-test (rationalize -1 3) 0)+      (num-test (rationalize -11/10 1/5) -1)+      (num-test (rationalize -3/4 1/2) -1)+      (num-test (rationalize -1/4 1/3) 0)+      (num-test (rationalize -1/4 1/6) -1/3)+      (num-test (rationalize -2/3 1/4) -1/2)+      (num-test (rationalize -1/3 1/4) -1/2)+      (num-test (rationalize -1/3 1/3) 0)+      (num-test (rationalize -3/10 1/10) -1/3)++      (num-test (rationalize .239 .0005) 11/46) ;baseball of course... the average .001 is the hardest to get: 1/667+      (num-test (rationalize .001 .0005) 1/667)+      (num-test (rationalize .334 .0005) 96/287)++      (num-test (rationalize 1.0000001 0.00000001) 9090911/9090910)+      (num-test (rationalize 0.000000015 0.000000001) 1/62500001)++      (num-test (rationalize -1 -1) 0) ;; spec says "differs by no more than", but that seems to imply a comparison+                                       ;; on either side, so a negative error doesn't change the result??+      (num-test (rationalize 1/4 -1/6) 1/3)+      (num-test (rationalize -3/10 -1/10) -1/3)+      (num-test (rationalize (exact->inexact 1/3) (exact->inexact -1/4)) 1/2)++      (if with-bigfloats+	  (begin+	    ;; can this sort of thing be handled with locally set precisions?+	    (num-test (rationalize 385817946978768113605842402465609185854927496022065152.5) 771635893957536227211684804931218371709854992044130305/2)+	    ))++      (num-test (rationalize 0.5 0.02) 1/2)+      ))+++;; -------- gcd and lcm++(num-test (gcd) 0)+(num-test (lcm) 1)+(num-test (gcd 1 0) 1)+(num-test (lcm 1 0) 0)+(num-test (gcd 0) 0)+(num-test (lcm 0) 0)+(num-test (gcd 0) 0)+(num-test (lcm 0) 0)+(num-test (gcd 1) 1)+(num-test (lcm 1) 1)+(num-test (gcd -1) 1)+(num-test (lcm -1) 1)+(num-test (gcd 2) 2)+(num-test (lcm 2) 2)+(num-test (gcd -2) 2)+(num-test (lcm -2) 2)+(num-test (gcd 3) 3)+(num-test (lcm 3) 3)+(num-test (gcd -3) 3)+(num-test (lcm -3) 3)+(num-test (gcd 10) 10)+(num-test (lcm 10) 10)+(num-test (gcd -10) 10)+(num-test (lcm -10) 10)+(num-test (gcd 1234) 1234)+(num-test (lcm 1234) 1234)+(num-test (gcd -1234) 1234)+(num-test (lcm -1234) 1234)+(num-test (gcd 1234000000) 1234000000)+(num-test (lcm 1234000000) 1234000000)+(num-test (gcd -1234000000) 1234000000)+(num-test (lcm -1234000000) 1234000000)+(num-test (gcd 500029) 500029)+(num-test (lcm 500029) 500029)+(num-test (gcd -500029) 500029)+(num-test (lcm -500029) 500029)+(num-test (gcd 362880) 362880)+(num-test (lcm 362880) 362880)+(num-test (gcd -362880) 362880)+(num-test (lcm -362880) 362880)+(num-test (gcd 0 0) 0)+(num-test (lcm 0 0) 0)+(num-test (gcd 0 0) 0)+(num-test (lcm 0 0) 0)+(num-test (gcd 0 0) 0)+(num-test (lcm 0 0) 0)+(num-test (gcd 0 0) 0)+(num-test (lcm 0 0) 0)+(num-test (gcd 0 1) 1)+(num-test (lcm 0 1) 0)+(num-test (gcd 0 1) 1)+(num-test (lcm 0 1) 0)+(num-test (gcd 0 -1) 1)+(num-test (lcm 0 -1) 0)+(num-test (gcd 0 -1) 1)+(num-test (lcm 0 -1) 0)+(num-test (gcd 0 2) 2)+(num-test (lcm 0 2) 0)+(num-test (gcd 0 2) 2)+(num-test (lcm 0 2) 0)+(num-test (gcd 0 -2) 2)+(num-test (lcm 0 -2) 0)+(num-test (gcd 0 -2) 2)+(num-test (lcm 0 -2) 0)+(num-test (gcd 0 3) 3)+(num-test (lcm 0 3) 0)+(num-test (gcd 0 3) 3)+(num-test (lcm 0 3) 0)+(num-test (gcd 0 -3) 3)+(num-test (lcm 0 -3) 0)+(num-test (gcd 0 -3) 3)+(num-test (lcm 0 -3) 0)+(num-test (gcd 0 10) 10)+(num-test (lcm 0 10) 0)+(num-test (gcd 0 10) 10)+(num-test (lcm 0 10) 0)+(num-test (gcd 0 -10) 10)+(num-test (lcm 0 -10) 0)+(num-test (gcd 0 -10) 10)+(num-test (lcm 0 -10) 0)+(num-test (gcd 0 1234) 1234)+(num-test (lcm 0 1234) 0)+(num-test (gcd 0 1234) 1234)+(num-test (lcm 0 1234) 0)+(num-test (gcd 0 -1234) 1234)+(num-test (lcm 0 -1234) 0)+(num-test (gcd 0 -1234) 1234)+(num-test (lcm 0 -1234) 0)+(num-test (gcd 0 1234000000) 1234000000)+(num-test (lcm 0 1234000000) 0)+(num-test (gcd 0 1234000000) 1234000000)+(num-test (lcm 0 1234000000) 0)+(num-test (gcd 0 -1234000000) 1234000000)+(num-test (lcm 0 -1234000000) 0)+(num-test (gcd 0 -1234000000) 1234000000)+(num-test (lcm 0 -1234000000) 0)+(num-test (gcd 0 500029) 500029)+(num-test (lcm 0 500029) 0)+(num-test (gcd 0 500029) 500029)+(num-test (lcm 0 500029) 0)+(num-test (gcd 0 -500029) 500029)+(num-test (lcm 0 -500029) 0)+(num-test (gcd 0 -500029) 500029)+(num-test (lcm 0 -500029) 0)+(num-test (gcd 0 362880) 362880)+(num-test (lcm 0 362880) 0)+(num-test (gcd 0 362880) 362880)+(num-test (lcm 0 362880) 0)+(num-test (gcd 0 -362880) 362880)+(num-test (lcm 0 -362880) 0)+(num-test (gcd 0 -362880) 362880)+(num-test (lcm 0 -362880) 0)+(num-test (gcd 1 0) 1)+(num-test (lcm 1 0) 0)+(num-test (gcd -1 0) 1)+(num-test (lcm -1 0) 0)+(num-test (gcd 1 0) 1)+(num-test (lcm 1 0) 0)+(num-test (gcd -1 0) 1)+(num-test (lcm -1 0) 0)+(num-test (gcd 1 1) 1)+(num-test (lcm 1 1) 1)+(num-test (gcd -1 1) 1)+(num-test (lcm -1 1) 1)+(num-test (gcd 1 -1) 1)+(num-test (lcm 1 -1) 1)+(num-test (gcd -1 -1) 1)+(num-test (lcm -1 -1) 1)+(num-test (gcd 1 2) 1)+(num-test (lcm 1 2) 2)+(num-test (gcd -1 2) 1)+(num-test (lcm -1 2) 2)+(num-test (gcd 1 -2) 1)+(num-test (lcm 1 -2) 2)+(num-test (gcd -1 -2) 1)+(num-test (lcm -1 -2) 2)+(num-test (gcd 1 3) 1)+(num-test (lcm 1 3) 3)+(num-test (gcd -1 3) 1)+(num-test (lcm -1 3) 3)+(num-test (gcd 1 -3) 1)+(num-test (lcm 1 -3) 3)+(num-test (gcd -1 -3) 1)+(num-test (lcm -1 -3) 3)+(num-test (gcd 1 10) 1)+(num-test (lcm 1 10) 10)+(num-test (gcd -1 10) 1)+(num-test (lcm -1 10) 10)+(num-test (gcd 1 -10) 1)+(num-test (lcm 1 -10) 10)+(num-test (gcd -1 -10) 1)+(num-test (lcm -1 -10) 10)+(num-test (gcd 1 1234) 1)+(num-test (lcm 1 1234) 1234)+(num-test (gcd -1 1234) 1)+(num-test (lcm -1 1234) 1234)+(num-test (gcd 1 -1234) 1)+(num-test (lcm 1 -1234) 1234)+(num-test (gcd -1 -1234) 1)+(num-test (lcm -1 -1234) 1234)+(num-test (gcd 1 1234000000) 1)+(num-test (lcm 1 1234000000) 1234000000)+(num-test (gcd -1 1234000000) 1)+(num-test (lcm -1 1234000000) 1234000000)+(num-test (gcd 1 -1234000000) 1)+(num-test (lcm 1 -1234000000) 1234000000)+(num-test (gcd -1 -1234000000) 1)+(num-test (lcm -1 -1234000000) 1234000000)+(num-test (gcd 1 500029) 1)+(num-test (lcm 1 500029) 500029)+(num-test (gcd -1 500029) 1)+(num-test (lcm -1 500029) 500029)+(num-test (gcd 1 -500029) 1)+(num-test (lcm 1 -500029) 500029)+(num-test (gcd -1 -500029) 1)+(num-test (lcm -1 -500029) 500029)+(num-test (gcd 1 362880) 1)+(num-test (lcm 1 362880) 362880)+(num-test (gcd -1 362880) 1)+(num-test (lcm -1 362880) 362880)+(num-test (gcd 1 -362880) 1)+(num-test (lcm 1 -362880) 362880)+(num-test (gcd -1 -362880) 1)+(num-test (lcm -1 -362880) 362880)+(num-test (gcd 2 0) 2)+(num-test (lcm 2 0) 0)+(num-test (gcd -2 0) 2)+(num-test (lcm -2 0) 0)+(num-test (gcd 2 0) 2)+(num-test (lcm 2 0) 0)+(num-test (gcd -2 0) 2)+(num-test (lcm -2 0) 0)+(num-test (gcd 2 1) 1)+(num-test (lcm 2 1) 2)+(num-test (gcd -2 1) 1)+(num-test (lcm -2 1) 2)+(num-test (gcd 2 -1) 1)+(num-test (lcm 2 -1) 2)+(num-test (gcd -2 -1) 1)+(num-test (lcm -2 -1) 2)+(num-test (gcd 2 2) 2)+(num-test (lcm 2 2) 2)+(num-test (gcd -2 2) 2)+(num-test (lcm -2 2) 2)+(num-test (gcd 2 -2) 2)+(num-test (lcm 2 -2) 2)+(num-test (gcd -2 -2) 2)+(num-test (lcm -2 -2) 2)+(num-test (gcd 2 3) 1)+(num-test (lcm 2 3) 6)+(num-test (gcd -2 3) 1)+(num-test (lcm -2 3) 6)+(num-test (gcd 2 -3) 1)+(num-test (lcm 2 -3) 6)+(num-test (gcd -2 -3) 1)+(num-test (lcm -2 -3) 6)+(num-test (gcd 2 10) 2)+(num-test (lcm 2 10) 10)+(num-test (gcd -2 10) 2)+(num-test (lcm -2 10) 10)+(num-test (gcd 2 -10) 2)+(num-test (lcm 2 -10) 10)+(num-test (gcd -2 -10) 2)+(num-test (lcm -2 -10) 10)+(num-test (gcd 2 1234) 2)+(num-test (lcm 2 1234) 1234)+(num-test (gcd -2 1234) 2)+(num-test (lcm -2 1234) 1234)+(num-test (gcd 2 -1234) 2)+(num-test (lcm 2 -1234) 1234)+(num-test (gcd -2 -1234) 2)+(num-test (lcm -2 -1234) 1234)+(num-test (gcd 2 1234000000) 2)+(num-test (lcm 2 1234000000) 1234000000)+(num-test (gcd -2 1234000000) 2)+(num-test (lcm -2 1234000000) 1234000000)+(num-test (gcd 2 -1234000000) 2)+(num-test (lcm 2 -1234000000) 1234000000)+(num-test (gcd -2 -1234000000) 2)+(num-test (lcm -2 -1234000000) 1234000000)+(num-test (gcd 2 500029) 1)+(num-test (lcm 2 500029) 1000058)+(num-test (gcd -2 500029) 1)+(num-test (lcm -2 500029) 1000058)+(num-test (gcd 2 -500029) 1)+(num-test (lcm 2 -500029) 1000058)+(num-test (gcd -2 -500029) 1)+(num-test (lcm -2 -500029) 1000058)+(num-test (gcd 2 362880) 2)+(num-test (lcm 2 362880) 362880)+(num-test (gcd -2 362880) 2)+(num-test (lcm -2 362880) 362880)+(num-test (gcd 2 -362880) 2)+(num-test (lcm 2 -362880) 362880)+(num-test (gcd -2 -362880) 2)+(num-test (lcm -2 -362880) 362880)+(num-test (gcd 3 0) 3)+(num-test (lcm 3 0) 0)+(num-test (gcd -3 0) 3)+(num-test (lcm -3 0) 0)+(num-test (gcd 3 0) 3)+(num-test (lcm 3 0) 0)+(num-test (gcd -3 0) 3)+(num-test (lcm -3 0) 0)+(num-test (gcd 3 1) 1)+(num-test (lcm 3 1) 3)+(num-test (gcd -3 1) 1)+(num-test (lcm -3 1) 3)+(num-test (gcd 3 -1) 1)+(num-test (lcm 3 -1) 3)+(num-test (gcd -3 -1) 1)+(num-test (lcm -3 -1) 3)+(num-test (gcd 3 2) 1)+(num-test (lcm 3 2) 6)+(num-test (gcd -3 2) 1)+(num-test (lcm -3 2) 6)+(num-test (gcd 3 -2) 1)+(num-test (lcm 3 -2) 6)+(num-test (gcd -3 -2) 1)+(num-test (lcm -3 -2) 6)+(num-test (gcd 3 3) 3)+(num-test (lcm 3 3) 3)+(num-test (gcd -3 3) 3)+(num-test (lcm -3 3) 3)+(num-test (gcd 3 -3) 3)+(num-test (lcm 3 -3) 3)+(num-test (gcd -3 -3) 3)+(num-test (lcm -3 -3) 3)+(num-test (gcd 3 10) 1)+(num-test (lcm 3 10) 30)+(num-test (gcd -3 10) 1)+(num-test (lcm -3 10) 30)+(num-test (gcd 3 -10) 1)+(num-test (lcm 3 -10) 30)+(num-test (gcd -3 -10) 1)+(num-test (lcm -3 -10) 30)+(num-test (gcd 3 1234) 1)+(num-test (lcm 3 1234) 3702)+(num-test (gcd -3 1234) 1)+(num-test (lcm -3 1234) 3702)+(num-test (gcd 3 -1234) 1)+(num-test (lcm 3 -1234) 3702)+(num-test (gcd -3 -1234) 1)+(num-test (lcm -3 -1234) 3702)+(num-test (gcd 3 1234000000) 1)+(num-test (lcm 3 1234000000) 3702000000)+(num-test (gcd -3 1234000000) 1)+(num-test (lcm -3 1234000000) 3702000000)+(num-test (gcd 3 -1234000000) 1)+(num-test (lcm 3 -1234000000) 3702000000)+(num-test (gcd -3 -1234000000) 1)+(num-test (lcm -3 -1234000000) 3702000000)+(num-test (gcd 3 500029) 1)+(num-test (lcm 3 500029) 1500087)+(num-test (gcd -3 500029) 1)+(num-test (lcm -3 500029) 1500087)+(num-test (gcd 3 -500029) 1)+(num-test (lcm 3 -500029) 1500087)+(num-test (gcd -3 -500029) 1)+(num-test (lcm -3 -500029) 1500087)+(num-test (gcd 3 362880) 3)+(num-test (lcm 3 362880) 362880)+(num-test (gcd -3 362880) 3)+(num-test (lcm -3 362880) 362880)+(num-test (gcd 3 -362880) 3)+(num-test (lcm 3 -362880) 362880)+(num-test (gcd -3 -362880) 3)+(num-test (lcm -3 -362880) 362880)+(num-test (gcd 10 0) 10)+(num-test (lcm 10 0) 0)+(num-test (gcd -10 0) 10)+(num-test (lcm -10 0) 0)+(num-test (gcd 10 0) 10)+(num-test (lcm 10 0) 0)+(num-test (gcd -10 0) 10)+(num-test (lcm -10 0) 0)+(num-test (gcd 10 1) 1)+(num-test (lcm 10 1) 10)+(num-test (gcd -10 1) 1)+(num-test (lcm -10 1) 10)+(num-test (gcd 10 -1) 1)+(num-test (lcm 10 -1) 10)+(num-test (gcd -10 -1) 1)+(num-test (lcm -10 -1) 10)+(num-test (gcd 10 2) 2)+(num-test (lcm 10 2) 10)+(num-test (gcd -10 2) 2)+(num-test (lcm -10 2) 10)+(num-test (gcd 10 -2) 2)+(num-test (lcm 10 -2) 10)+(num-test (gcd -10 -2) 2)+(num-test (lcm -10 -2) 10)+(num-test (gcd 10 3) 1)+(num-test (lcm 10 3) 30)+(num-test (gcd -10 3) 1)+(num-test (lcm -10 3) 30)+(num-test (gcd 10 -3) 1)+(num-test (lcm 10 -3) 30)+(num-test (gcd -10 -3) 1)+(num-test (lcm -10 -3) 30)+(num-test (gcd 10 10) 10)+(num-test (lcm 10 10) 10)+(num-test (gcd -10 10) 10)+(num-test (lcm -10 10) 10)+(num-test (gcd 10 -10) 10)+(num-test (lcm 10 -10) 10)+(num-test (gcd -10 -10) 10)+(num-test (lcm -10 -10) 10)+(num-test (gcd 10 1234) 2)+(num-test (lcm 10 1234) 6170)+(num-test (gcd -10 1234) 2)+(num-test (lcm -10 1234) 6170)+(num-test (gcd 10 -1234) 2)+(num-test (lcm 10 -1234) 6170)+(num-test (gcd -10 -1234) 2)+(num-test (lcm -10 -1234) 6170)+(num-test (gcd 10 1234000000) 10)+(num-test (lcm 10 1234000000) 1234000000)+(num-test (gcd -10 1234000000) 10)+(num-test (lcm -10 1234000000) 1234000000)+(num-test (gcd 10 -1234000000) 10)+(num-test (lcm 10 -1234000000) 1234000000)+(num-test (gcd -10 -1234000000) 10)+(num-test (lcm -10 -1234000000) 1234000000)+(num-test (gcd 10 500029) 1)+(num-test (lcm 10 500029) 5000290)+(num-test (gcd -10 500029) 1)+(num-test (lcm -10 500029) 5000290)+(num-test (gcd 10 -500029) 1)+(num-test (lcm 10 -500029) 5000290)+(num-test (gcd -10 -500029) 1)+(num-test (lcm -10 -500029) 5000290)+(num-test (gcd 10 362880) 10)+(num-test (lcm 10 362880) 362880)+(num-test (gcd -10 362880) 10)+(num-test (lcm -10 362880) 362880)+(num-test (gcd 10 -362880) 10)+(num-test (lcm 10 -362880) 362880)+(num-test (gcd -10 -362880) 10)+(num-test (lcm -10 -362880) 362880)+(num-test (gcd 1234 0) 1234)+(num-test (lcm 1234 0) 0)+(num-test (gcd -1234 0) 1234)+(num-test (lcm -1234 0) 0)+(num-test (gcd 1234 0) 1234)+(num-test (lcm 1234 0) 0)+(num-test (gcd -1234 0) 1234)+(num-test (lcm -1234 0) 0)+(num-test (gcd 1234 1) 1)+(num-test (lcm 1234 1) 1234)+(num-test (gcd -1234 1) 1)+(num-test (lcm -1234 1) 1234)+(num-test (gcd 1234 -1) 1)+(num-test (lcm 1234 -1) 1234)+(num-test (gcd -1234 -1) 1)+(num-test (lcm -1234 -1) 1234)+(num-test (gcd 1234 2) 2)+(num-test (lcm 1234 2) 1234)+(num-test (gcd -1234 2) 2)+(num-test (lcm -1234 2) 1234)+(num-test (gcd 1234 -2) 2)+(num-test (lcm 1234 -2) 1234)+(num-test (gcd -1234 -2) 2)+(num-test (lcm -1234 -2) 1234)+(num-test (gcd 1234 3) 1)+(num-test (lcm 1234 3) 3702)+(num-test (gcd -1234 3) 1)+(num-test (lcm -1234 3) 3702)+(num-test (gcd 1234 -3) 1)+(num-test (lcm 1234 -3) 3702)+(num-test (gcd -1234 -3) 1)+(num-test (lcm -1234 -3) 3702)+(num-test (gcd 1234 10) 2)+(num-test (lcm 1234 10) 6170)+(num-test (gcd -1234 10) 2)+(num-test (lcm -1234 10) 6170)+(num-test (gcd 1234 -10) 2)+(num-test (lcm 1234 -10) 6170)+(num-test (gcd -1234 -10) 2)+(num-test (lcm -1234 -10) 6170)+(num-test (gcd 1234 1234) 1234)+(num-test (lcm 1234 1234) 1234)+(num-test (gcd -1234 1234) 1234)+(num-test (lcm -1234 1234) 1234)+(num-test (gcd 1234 -1234) 1234)+(num-test (lcm 1234 -1234) 1234)+(num-test (gcd -1234 -1234) 1234)+(num-test (lcm -1234 -1234) 1234)+(num-test (gcd 1234 1234000000) 1234)+(num-test (lcm 1234 1234000000) 1234000000)+(num-test (gcd -1234 1234000000) 1234)+(num-test (lcm -1234 1234000000) 1234000000)+(num-test (gcd 1234 -1234000000) 1234)+(num-test (lcm 1234 -1234000000) 1234000000)+(num-test (gcd -1234 -1234000000) 1234)+(num-test (lcm -1234 -1234000000) 1234000000)+(num-test (gcd 1234 500029) 1)+(num-test (lcm 1234 500029) 617035786)+(num-test (gcd -1234 500029) 1)+(num-test (lcm -1234 500029) 617035786)+(num-test (gcd 1234 -500029) 1)+(num-test (lcm 1234 -500029) 617035786)+(num-test (gcd -1234 -500029) 1)+(num-test (lcm -1234 -500029) 617035786)+(num-test (gcd 1234 362880) 2)+(num-test (lcm 1234 362880) 223896960)+(num-test (gcd -1234 362880) 2)+(num-test (lcm -1234 362880) 223896960)+(num-test (gcd 1234 -362880) 2)+(num-test (lcm 1234 -362880) 223896960)+(num-test (gcd -1234 -362880) 2)+(num-test (lcm -1234 -362880) 223896960)+(num-test (gcd 1234000000 0) 1234000000)+(num-test (lcm 1234000000 0) 0)+(num-test (gcd -1234000000 0) 1234000000)+(num-test (lcm -1234000000 0) 0)+(num-test (gcd 1234000000 0) 1234000000)+(num-test (lcm 1234000000 0) 0)+(num-test (gcd -1234000000 0) 1234000000)+(num-test (lcm -1234000000 0) 0)+(num-test (gcd 1234000000 1) 1)+(num-test (lcm 1234000000 1) 1234000000)+(num-test (gcd -1234000000 1) 1)+(num-test (lcm -1234000000 1) 1234000000)+(num-test (gcd 1234000000 -1) 1)+(num-test (lcm 1234000000 -1) 1234000000)+(num-test (gcd -1234000000 -1) 1)+(num-test (lcm -1234000000 -1) 1234000000)+(num-test (gcd 1234000000 2) 2)+(num-test (lcm 1234000000 2) 1234000000)+(num-test (gcd -1234000000 2) 2)+(num-test (lcm -1234000000 2) 1234000000)+(num-test (gcd 1234000000 -2) 2)+(num-test (lcm 1234000000 -2) 1234000000)+(num-test (gcd -1234000000 -2) 2)+(num-test (lcm -1234000000 -2) 1234000000)+(num-test (gcd 1234000000 3) 1)+(num-test (lcm 1234000000 3) 3702000000)+(num-test (gcd -1234000000 3) 1)+(num-test (lcm -1234000000 3) 3702000000)+(num-test (gcd 1234000000 -3) 1)+(num-test (lcm 1234000000 -3) 3702000000)+(num-test (gcd -1234000000 -3) 1)+(num-test (lcm -1234000000 -3) 3702000000)+(num-test (gcd 1234000000 10) 10)+(num-test (lcm 1234000000 10) 1234000000)+(num-test (gcd -1234000000 10) 10)+(num-test (lcm -1234000000 10) 1234000000)+(num-test (gcd 1234000000 -10) 10)+(num-test (lcm 1234000000 -10) 1234000000)+(num-test (gcd -1234000000 -10) 10)+(num-test (lcm -1234000000 -10) 1234000000)+(num-test (gcd 1234000000 1234) 1234)+(num-test (lcm 1234000000 1234) 1234000000)+(num-test (gcd -1234000000 1234) 1234)+(num-test (lcm -1234000000 1234) 1234000000)+(num-test (gcd 1234000000 -1234) 1234)+(num-test (lcm 1234000000 -1234) 1234000000)+(num-test (gcd -1234000000 -1234) 1234)+(num-test (lcm -1234000000 -1234) 1234000000)+(num-test (gcd 1234000000 1234000000) 1234000000)+(num-test (lcm 1234000000 1234000000) 1234000000)+(num-test (gcd -1234000000 1234000000) 1234000000)+(num-test (lcm -1234000000 1234000000) 1234000000)+(num-test (gcd 1234000000 -1234000000) 1234000000)+(num-test (lcm 1234000000 -1234000000) 1234000000)+(num-test (gcd -1234000000 -1234000000) 1234000000)+(num-test (lcm -1234000000 -1234000000) 1234000000)+(num-test (gcd 1234000000 500029) 1)+(num-test (lcm 1234000000 500029) 617035786000000)+(num-test (gcd -1234000000 500029) 1)+(num-test (lcm -1234000000 500029) 617035786000000)+(num-test (gcd 1234000000 -500029) 1)+(num-test (lcm 1234000000 -500029) 617035786000000)+(num-test (gcd -1234000000 -500029) 1)+(num-test (lcm -1234000000 -500029) 617035786000000)+(num-test (gcd 1234000000 362880) 640)+(num-test (lcm 1234000000 362880) 699678000000)+(num-test (gcd -1234000000 362880) 640)+(num-test (lcm -1234000000 362880) 699678000000)+(num-test (gcd 1234000000 -362880) 640)+(num-test (lcm 1234000000 -362880) 699678000000)+(num-test (gcd -1234000000 -362880) 640)+(num-test (lcm -1234000000 -362880) 699678000000)+(num-test (gcd 500029 0) 500029)+(num-test (lcm 500029 0) 0)+(num-test (gcd -500029 0) 500029)+(num-test (lcm -500029 0) 0)+(num-test (gcd 500029 0) 500029)+(num-test (lcm 500029 0) 0)+(num-test (gcd -500029 0) 500029)+(num-test (lcm -500029 0) 0)+(num-test (gcd 500029 1) 1)+(num-test (lcm 500029 1) 500029)+(num-test (gcd -500029 1) 1)+(num-test (lcm -500029 1) 500029)+(num-test (gcd 500029 -1) 1)+(num-test (lcm 500029 -1) 500029)+(num-test (gcd -500029 -1) 1)+(num-test (lcm -500029 -1) 500029)+(num-test (gcd 500029 2) 1)+(num-test (lcm 500029 2) 1000058)+(num-test (gcd -500029 2) 1)+(num-test (lcm -500029 2) 1000058)+(num-test (gcd 500029 -2) 1)+(num-test (lcm 500029 -2) 1000058)+(num-test (gcd -500029 -2) 1)+(num-test (lcm -500029 -2) 1000058)+(num-test (gcd 500029 3) 1)+(num-test (lcm 500029 3) 1500087)+(num-test (gcd -500029 3) 1)+(num-test (lcm -500029 3) 1500087)+(num-test (gcd 500029 -3) 1)+(num-test (lcm 500029 -3) 1500087)+(num-test (gcd -500029 -3) 1)+(num-test (lcm -500029 -3) 1500087)+(num-test (gcd 500029 10) 1)+(num-test (lcm 500029 10) 5000290)+(num-test (gcd -500029 10) 1)+(num-test (lcm -500029 10) 5000290)+(num-test (gcd 500029 -10) 1)+(num-test (lcm 500029 -10) 5000290)+(num-test (gcd -500029 -10) 1)+(num-test (lcm -500029 -10) 5000290)+(num-test (gcd 500029 1234) 1)+(num-test (lcm 500029 1234) 617035786)+(num-test (gcd -500029 1234) 1)+(num-test (lcm -500029 1234) 617035786)+(num-test (gcd 500029 -1234) 1)+(num-test (lcm 500029 -1234) 617035786)+(num-test (gcd -500029 -1234) 1)+(num-test (lcm -500029 -1234) 617035786)+(num-test (gcd 500029 1234000000) 1)+(num-test (lcm 500029 1234000000) 617035786000000)+(num-test (gcd -500029 1234000000) 1)+(num-test (lcm -500029 1234000000) 617035786000000)+(num-test (gcd 500029 -1234000000) 1)+(num-test (lcm 500029 -1234000000) 617035786000000)+(num-test (gcd -500029 -1234000000) 1)+(num-test (lcm -500029 -1234000000) 617035786000000)+(num-test (gcd 500029 500029) 500029)+(num-test (lcm 500029 500029) 500029)+(num-test (gcd -500029 500029) 500029)+(num-test (lcm -500029 500029) 500029)+(num-test (gcd 500029 -500029) 500029)+(num-test (lcm 500029 -500029) 500029)+(num-test (gcd -500029 -500029) 500029)+(num-test (lcm -500029 -500029) 500029)+(num-test (gcd 500029 362880) 1)+(num-test (lcm 500029 362880) 181450523520)+(num-test (gcd -500029 362880) 1)+(num-test (lcm -500029 362880) 181450523520)+(num-test (gcd 500029 -362880) 1)+(num-test (lcm 500029 -362880) 181450523520)+(num-test (gcd -500029 -362880) 1)+(num-test (lcm -500029 -362880) 181450523520)+(num-test (gcd 362880 0) 362880)+(num-test (lcm 362880 0) 0)+(num-test (gcd -362880 0) 362880)+(num-test (lcm -362880 0) 0)+(num-test (gcd 362880 0) 362880)+(num-test (lcm 362880 0) 0)+(num-test (gcd -362880 0) 362880)+(num-test (lcm -362880 0) 0)+(num-test (gcd 362880 1) 1)+(num-test (lcm 362880 1) 362880)+(num-test (gcd -362880 1) 1)+(num-test (lcm -362880 1) 362880)+(num-test (gcd 362880 -1) 1)+(num-test (lcm 362880 -1) 362880)+(num-test (gcd -362880 -1) 1)+(num-test (lcm -362880 -1) 362880)+(num-test (gcd 362880 2) 2)+(num-test (lcm 362880 2) 362880)+(num-test (gcd -362880 2) 2)+(num-test (lcm -362880 2) 362880)+(num-test (gcd 362880 -2) 2)+(num-test (lcm 362880 -2) 362880)+(num-test (gcd -362880 -2) 2)+(num-test (lcm -362880 -2) 362880)+(num-test (gcd 362880 3) 3)+(num-test (lcm 362880 3) 362880)+(num-test (gcd -362880 3) 3)+(num-test (lcm -362880 3) 362880)+(num-test (gcd 362880 -3) 3)+(num-test (lcm 362880 -3) 362880)+(num-test (gcd -362880 -3) 3)+(num-test (lcm -362880 -3) 362880)+(num-test (gcd 362880 10) 10)+(num-test (lcm 362880 10) 362880)+(num-test (gcd -362880 10) 10)+(num-test (lcm -362880 10) 362880)+(num-test (gcd 362880 -10) 10)+(num-test (lcm 362880 -10) 362880)+(num-test (gcd -362880 -10) 10)+(num-test (lcm -362880 -10) 362880)+(num-test (gcd 362880 1234) 2)+(num-test (lcm 362880 1234) 223896960)+(num-test (gcd -362880 1234) 2)+(num-test (lcm -362880 1234) 223896960)+(num-test (gcd 362880 -1234) 2)+(num-test (lcm 362880 -1234) 223896960)+(num-test (gcd -362880 -1234) 2)+(num-test (lcm -362880 -1234) 223896960)+(num-test (gcd 362880 1234000000) 640)+(num-test (lcm 362880 1234000000) 699678000000)+(num-test (gcd -362880 1234000000) 640)+(num-test (lcm -362880 1234000000) 699678000000)+(num-test (gcd 362880 -1234000000) 640)+(num-test (lcm 362880 -1234000000) 699678000000)+(num-test (gcd -362880 -1234000000) 640)+(num-test (lcm -362880 -1234000000) 699678000000)+(num-test (gcd 362880 500029) 1)+(num-test (lcm 362880 500029) 181450523520)+(num-test (gcd -362880 500029) 1)+(num-test (lcm -362880 500029) 181450523520)+(num-test (gcd 362880 -500029) 1)+(num-test (lcm 362880 -500029) 181450523520)+(num-test (gcd -362880 -500029) 1)+(num-test (lcm -362880 -500029) 181450523520)+(num-test (gcd 362880 362880) 362880)+(num-test (lcm 362880 362880) 362880)+(num-test (gcd -362880 362880) 362880)+(num-test (lcm -362880 362880) 362880)+(num-test (gcd 362880 -362880) 362880)+(num-test (lcm 362880 -362880) 362880)+(num-test (gcd -362880 -362880) 362880)+(num-test (lcm -362880 -362880) 362880)+(num-test (gcd 60 42) 6)+(num-test (gcd 3333 -33 101) 1)+(num-test (gcd 3333 -33 1002001) 11)+(num-test (gcd 91 -49) 7)+(num-test (gcd 63 -42 35) 7)+(num-test (gcd 0 0 0 10) 10)+(num-test (lcm 0 0 0 10) 0)+(num-test (gcd 0 1 -1 362880) 1)+(num-test (gcd 0 2 2 -500029) 1)+(num-test (gcd 0 3 -3 -1234000000) 1)+(num-test (gcd 0 10 10 1234) 2)+(num-test (lcm 0 10 10 1234) 0)+(num-test (gcd 0 1234 -1234 10) 2)+(num-test (lcm 0 1234 -1234 10) 0)+(num-test (gcd 0 1234000000 1234000000 -3) 1)+(num-test (gcd 0 500029 -500029 -2) 1)+(num-test (gcd 0 362880 362880 1) 1)+(num-test (gcd 1 0 -1 1) 1)+(num-test (lcm 1 0 -1 1) 0)+(num-test (gcd 1 1 2 -10) 1)+(num-test (lcm 1 1 2 -10) 10)+(num-test (gcd 1 2 -3 -362880) 1)+(num-test (gcd 1 3 10 500029) 1)+(num-test (gcd 1 10 -1234 1234000000) 1)+(num-test (gcd 1 1234 1234000000 -1234) 1)+(num-test (gcd 1 1234000000 -500029 -10) 1)+(num-test (gcd 1 500029 362880 3) 1)+(num-test (gcd 1 362880 0 2) 1)+(num-test (gcd 2 0 2 -2) 2)+(num-test (lcm 2 0 2 -2) 0)+(num-test (gcd 2 1 -3 -1) 1)+(num-test (lcm 2 1 -3 -1) 6)+(num-test (gcd 2 2 10 10) 2)+(num-test (lcm 2 2 10 10) 10)+(num-test (gcd 2 3 -1234 362880) 1)+(num-test (gcd 2 10 1234000000 -500029) 1)+(num-test (gcd 2 1234 -500029 -1234000000) 1)+(num-test (gcd 2 1234000000 362880 1234) 2)+(num-test (gcd 2 500029 0 10) 1)+(num-test (gcd 2 362880 1 -3) 1)+(num-test (gcd 3 0 -3 -3) 3)+(num-test (lcm 3 0 -3 -3) 0)+(num-test (gcd 3 1 10 2) 1)+(num-test (lcm 3 1 10 2) 30)+(num-test (gcd 3 2 -1234 1) 1)+(num-test (lcm 3 2 -1234 1) 3702)+(num-test (gcd 3 3 1234000000 -10) 1)+(num-test (gcd 3 10 -500029 -362880) 1)+(num-test (gcd 3 1234 362880 500029) 1)+(num-test (gcd 3 1234000000 0 1234000000) 1)+(num-test (gcd 3 500029 1 -1234) 1)+(num-test (gcd 3 362880 -2 -10) 1)+(num-test (gcd 10 0 10 10) 10)+(num-test (lcm 10 0 10 10) 0)+(num-test (gcd 10 1 -1234 3) 1)+(num-test (lcm 10 1 -1234 3) 18510)+(num-test (gcd 10 2 1234000000 -2) 2)+(num-test (gcd 10 3 -500029 -1) 1)+(num-test (gcd 10 10 362880 10) 10)+(num-test (gcd 10 1234 0 362880) 2)+(num-test (gcd 10 1234000000 1 -500029) 1)+(num-test (gcd 10 500029 -2 -1234000000) 1)+(num-test (gcd 10 362880 3 1234) 1)+(num-test (gcd 1234 0 -1234 1234) 1234)+(num-test (lcm 1234 0 -1234 1234) 0)+(num-test (gcd 1234 1 1234000000 -10) 1)+(num-test (gcd 1234 2 -500029 -3) 1)+(num-test (gcd 1234 3 362880 2) 1)+(num-test (gcd 1234 10 0 1) 1)+(num-test (lcm 1234 10 0 1) 0)+(num-test (gcd 1234 1234 1 -10) 1)+(num-test (lcm 1234 1234 1 -10) 6170)+(num-test (gcd 1234 1234000000 -2 -362880) 2)+(num-test (gcd 1234 500029 3 500029) 1)+(num-test (gcd 1234 362880 -10 1234000000) 2)+(num-test (gcd 1234000000 0 1234000000 -1234000000) 1234000000)+(num-test (gcd 1234000000 1 -500029 -1234) 1)+(num-test (gcd 1234000000 2 362880 10) 2)+(num-test (gcd 1234000000 3 0 3) 1)+(num-test (gcd 1234000000 10 1 -2) 1)+(num-test (gcd 1234000000 1234 -2 -1) 1)+(num-test (gcd 1234000000 1234000000 3 10) 1)+(num-test (gcd 1234000000 500029 -10 362880) 1)+(num-test (gcd 1234000000 362880 1234 -500029) 1)+(num-test (gcd 500029 0 -500029 -500029) 500029)+(num-test (gcd 500029 1 362880 1234000000) 1)+(num-test (gcd 500029 2 0 1234) 1)+(num-test (gcd 500029 3 1 -10) 1)+(num-test (gcd 500029 10 -2 -3) 1)+(num-test (gcd 500029 1234 3 2) 1)+(num-test (gcd 500029 1234000000 -10 1) 1)+(num-test (gcd 500029 500029 1234 -10) 1)+(num-test (gcd 500029 362880 -1234000000 -362880) 1)+(num-test (gcd 362880 0 362880 362880) 362880)+(num-test (gcd 362880 1 0 500029) 1)+(num-test (gcd 362880 2 1 -1234000000) 1)+(num-test (gcd 362880 3 -2 -1234) 1)+(num-test (gcd 362880 10 3 10) 1)+(num-test (gcd 362880 1234 -10 3) 1)+(num-test (gcd 362880 1234000000 1234 -2) 2)+(num-test (gcd 362880 500029 -1234000000 -1) 1)+(num-test (gcd 362880 362880 500029 10) 1)+(num-test (gcd 323 28747 27113) 19)+(num-test (lcm 323 28747 27113) 41021969)+(num-test (lcm (* 512 500057) (* 128 500057) (* 2048 500057)) 1024116736)+(num-test (gcd (* 512 500057) (* 128 500057) (* 2048 500057)) 64007296)+(num-test (gcd 91 -49) 7)+(num-test (lcm 14 35) 70)+(num-test (gcd (- (expt 2 11) 1) (- (expt 2 19) 1)) (- (expt 2 (gcd 11 19)) 1))+(num-test (gcd (- (expt 2 11) 1) (- (expt 2 22) 1)) (- (expt 2 (gcd 11 22)) 1))+(num-test (gcd (- (expt 2 12) 1) (- (expt 2 18) 1)) (- (expt 2 (gcd 12 18)) 1))+(if (or with-bignums with-64-bit-ints)+    (num-test (gcd (- (expt 2 52) 1) (- (expt 2 39) 1)) (- (expt 2 (gcd 52 39)) 1)))+(num-test (gcd (numerator 7/9) (denominator 7/9)) 1)+(num-test (gcd 0 4) 4 )+(num-test (gcd -4 0) 4 )+(num-test (gcd 32 -36) 4 )+(num-test (gcd) 0 )+(num-test (lcm 32 -36) 288 )+(num-test (lcm) 1 )+(num-test (gcd 2 0) 2)+(num-test (lcm 2 0) 0)+++;; -------- real-part and imag-part+(num-test (real-part 1) 1)+(num-test (imag-part 1) 0.0)+(num-test (real-part 2.0) 2.0)+(num-test (imag-part -2.0) 0.0)+(num-test (real-part 2/3) 2/3)+(num-test (imag-part 1+i) 1.0)+(num-test (imag-part 0+i) 1.0)+(num-test (imag-part 1-i) -1.0)+(num-test (imag-part 2/3) 0.0)+(num-test (real-part 0.0+0.0i) 0.0)+(num-test (imag-part 0.0+0.0i) 0.0)+(num-test (real-part -0.0+0.00000001i) -0.0)+(num-test (imag-part -0.0+0.00000001i) 0.00000001)+(num-test (real-part 0.0-1.0i) 0.0)+(num-test (imag-part 0.0-1.0i) -1.0)+(num-test (real-part -0.0-3.14159265358979i) -0.0)+(num-test (imag-part -0.0-3.14159265358979i) -3.14159265358979)+(num-test (real-part 0.0+2.71828182845905i) 0.0)+(num-test (imag-part 0.0+2.71828182845905i) 2.71828182845905)+(num-test (real-part -0.0+1234.0i) -0.0)+(num-test (imag-part -0.0+1234.0i) 1234.0)+(num-test (real-part 0.0-1234000000.0i) 0.0)+(num-test (imag-part 0.0-1234000000.0i) -1234000000.0)+(num-test (real-part -0.00000001-0.0i) -0.00000001)+(num-test (imag-part -0.00000001-0.0i) -0.0)+(num-test (real-part 0.00000001+0.00000001i) 0.00000001)+(num-test (imag-part 0.00000001+0.00000001i) 0.00000001)+(num-test (real-part -0.00000001+1.0i) -0.00000001)+(num-test (imag-part -0.00000001+1.0i) 1.0)+(num-test (real-part 0.00000001-3.14159265358979i) 0.00000001)+(num-test (imag-part 0.00000001-3.14159265358979i) -3.14159265358979)+(num-test (real-part -0.00000001-2.71828182845905i) -0.00000001)+(num-test (imag-part -0.00000001-2.71828182845905i) -2.71828182845905)+(num-test (real-part 0.00000001+1234.0i) 0.00000001)+(num-test (imag-part 0.00000001+1234.0i) 1234.0)+(num-test (real-part -0.00000001+1234000000.0i) -0.00000001)+(num-test (imag-part -0.00000001+1234000000.0i) 1234000000.0)+(num-test (real-part 1.0-0.0i) 1.0)+(num-test (imag-part 1.0-0.0i) -0.0)+(num-test (real-part -1.0-0.00000001i) -1.0)+(num-test (imag-part -1.0-0.00000001i) -0.00000001)+(num-test (real-part 1.0+1.0i) 1.0)+(num-test (imag-part 1.0+1.0i) 1.0)+(num-test (real-part -1.0+3.14159265358979i) -1.0)+(num-test (imag-part -1.0+3.14159265358979i) 3.14159265358979)+(num-test (real-part 1.0-2.71828182845905i) 1.0)+(num-test (imag-part 1.0-2.71828182845905i) -2.71828182845905)+(num-test (real-part -1.0-1234.0i) -1.0)+(num-test (imag-part -1.0-1234.0i) -1234.0)+(num-test (real-part 1.0+1234000000.0i) 1.0)+(num-test (imag-part 1.0+1234000000.0i) 1234000000.0)+(num-test (real-part -3.14159265358979+0.0i) -3.14159265358979)+(num-test (imag-part -3.14159265358979+0.0i) 0.0)+(num-test (real-part 3.14159265358979-0.00000001i) 3.14159265358979)+(num-test (imag-part 3.14159265358979-0.00000001i) -0.00000001)+(num-test (real-part -3.14159265358979-1.0i) -3.14159265358979)+(num-test (imag-part -3.14159265358979-1.0i) -1.0)+(num-test (real-part 3.14159265358979+3.14159265358979i) 3.14159265358979)+(num-test (imag-part 3.14159265358979+3.14159265358979i) 3.14159265358979)+(num-test (real-part -3.14159265358979+2.71828182845905i) -3.14159265358979)+(num-test (imag-part -3.14159265358979+2.71828182845905i) 2.71828182845905)+(num-test (real-part 3.14159265358979-1234.0i) 3.14159265358979)+(num-test (imag-part 3.14159265358979-1234.0i) -1234.0)+(num-test (real-part -3.14159265358979-1234000000.0i) -3.14159265358979)+(num-test (imag-part -3.14159265358979-1234000000.0i) -1234000000.0)+(num-test (real-part 2.71828182845905+0.0i) 2.71828182845905)+(num-test (imag-part 2.71828182845905+0.0i) 0.0)+(num-test (real-part -2.71828182845905+0.00000001i) -2.71828182845905)+(num-test (imag-part -2.71828182845905+0.00000001i) 0.00000001)+(num-test (real-part 2.71828182845905-1.0i) 2.71828182845905)+(num-test (imag-part 2.71828182845905-1.0i) -1.0)+(num-test (real-part -2.71828182845905-3.14159265358979i) -2.71828182845905)+(num-test (imag-part -2.71828182845905-3.14159265358979i) -3.14159265358979)+(num-test (real-part 2.71828182845905+2.71828182845905i) 2.71828182845905)+(num-test (imag-part 2.71828182845905+2.71828182845905i) 2.71828182845905)+(num-test (real-part -2.71828182845905+1234.0i) -2.71828182845905)+(num-test (imag-part -2.71828182845905+1234.0i) 1234.0)+(num-test (real-part 2.71828182845905-1234000000.0i) 2.71828182845905)+(num-test (imag-part 2.71828182845905-1234000000.0i) -1234000000.0)+(num-test (real-part -1234.0-0.0i) -1234.0)+(num-test (imag-part -1234.0-0.0i) -0.0)+(num-test (real-part 1234.0+0.00000001i) 1234.0)+(num-test (imag-part 1234.0+0.00000001i) 0.00000001)+(num-test (real-part -1234.0+1.0i) -1234.0)+(num-test (imag-part -1234.0+1.0i) 1.0)+(num-test (real-part 1234.0-3.14159265358979i) 1234.0)+(num-test (imag-part 1234.0-3.14159265358979i) -3.14159265358979)+(num-test (real-part -1234.0-2.71828182845905i) -1234.0)+(num-test (imag-part -1234.0-2.71828182845905i) -2.71828182845905)+(num-test (real-part 1234.0+1234.0i) 1234.0)+(num-test (imag-part 1234.0+1234.0i) 1234.0)+(num-test (real-part -1234.0+1234000000.0i) -1234.0)+(num-test (imag-part -1234.0+1234000000.0i) 1234000000.0)+(num-test (real-part 1234000000.0-0.0i) 1234000000.0)+(num-test (imag-part 1234000000.0-0.0i) -0.0)+(num-test (real-part -1234000000.0-0.00000001i) -1234000000.0)+(num-test (imag-part -1234000000.0-0.00000001i) -0.00000001)+(num-test (real-part 1234000000.0+1.0i) 1234000000.0)+(num-test (imag-part 1234000000.0+1.0i) 1.0)+(num-test (real-part -1234000000.0+3.14159265358979i) -1234000000.0)+(num-test (imag-part -1234000000.0+3.14159265358979i) 3.14159265358979)+(num-test (real-part 1234000000.0-2.71828182845905i) 1234000000.0)+(num-test (imag-part 1234000000.0-2.71828182845905i) -2.71828182845905)+(num-test (real-part -1234000000.0-1234.0i) -1234000000.0)+(num-test (imag-part -1234000000.0-1234.0i) -1234.0)+(num-test (real-part 1234000000.0+1234000000.0i) 1234000000.0)+(num-test (imag-part 1234000000.0+1234000000.0i) 1234000000.0)+(num-test (real-part 5) 5)+(num-test (real-part 1.4+0.0i) 1.4)+(num-test (imag-part 5) 0.0)+(num-test (imag-part 1.4+0.0i) 0.0)+++;; -------- numerator and denominator+(num-test (numerator 12/6000996) 1)+(num-test (denominator 12/6000996) 500083)+(num-test (numerator 1) 1)+(num-test (numerator 2/3) 2)+(num-test (numerator 2/4) 1)+(num-test (denominator 2/4) 2)+(num-test (numerator -2/6) -1)+(num-test (denominator -2/6) 3)+(num-test (numerator -2/3) -2)+(num-test (denominator -2/3) 3)+(num-test (denominator 1) 1)+(num-test (denominator 2/3) 3)+(num-test (numerator 0/1) 0)+(num-test (denominator 0/1) 1)+(num-test (numerator 0/2) 0)+(num-test (denominator 0/2) 1)+(num-test (numerator 0/3) 0)+(num-test (denominator 0/3) 1)+(num-test (numerator 0/10) 0)+(num-test (denominator 0/10) 1)+(num-test (numerator 0/1234) 0)+(num-test (denominator 0/1234) 1)+(num-test (numerator 0/1234000000) 0)+(num-test (denominator 0/1234000000) 1)+(num-test (numerator 0/500029) 0)+(num-test (denominator 0/500029) 1)+(num-test (numerator 0/362880) 0)+(num-test (denominator 0/362880) 1)+(num-test (numerator 1/1) 1)+(num-test (denominator 1/1) 1)+(num-test (numerator -1/2) -1)+(num-test (denominator -1/2) 2)+(num-test (numerator 1/3) 1)+(num-test (denominator 1/3) 3)+(num-test (numerator -1/10) -1)+(num-test (denominator -1/10) 10)+(num-test (numerator 1/1234) 1)+(num-test (denominator 1/1234) 1234)+(num-test (numerator -1/1234000000) -1)+(num-test (denominator -1/1234000000) 1234000000)+(num-test (numerator 1/500029) 1)+(num-test (denominator 1/500029) 500029)+(num-test (numerator -1/362880) -1)+(num-test (denominator -1/362880) 362880)+(num-test (numerator -2/1) -2)+(num-test (denominator -2/1) 1)+(num-test (numerator 2/2) 1)+(num-test (denominator 2/2) 1)+(num-test (numerator -2/3) -2)+(num-test (denominator -2/3) 3)+(num-test (numerator 2/10) 1)+(num-test (denominator 2/10) 5)+(num-test (numerator -2/1234) -1)+(num-test (denominator -2/1234) 617)+(num-test (numerator 2/1234000000) 1)+(num-test (denominator 2/1234000000) 617000000)+(num-test (numerator -2/500029) -2)+(num-test (denominator -2/500029) 500029)+(num-test (numerator 2/362880) 1)+(num-test (denominator 2/362880) 181440)+(num-test (numerator 3/1) 3)+(num-test (denominator 3/1) 1)+(num-test (numerator -3/2) -3)+(num-test (denominator -3/2) 2)+(num-test (numerator 3/3) 1)+(num-test (denominator 3/3) 1)+(num-test (numerator -3/10) -3)+(num-test (denominator -3/10) 10)+(num-test (numerator 3/1234) 3)+(num-test (denominator 3/1234) 1234)+(num-test (numerator -3/1234000000) -3)+(num-test (denominator -3/1234000000) 1234000000)+(num-test (numerator 3/500029) 3)+(num-test (denominator 3/500029) 500029)+(num-test (numerator -3/362880) -1)+(num-test (denominator -3/362880) 120960)+(num-test (numerator -10/1) -10)+(num-test (denominator -10/1) 1)+(num-test (numerator 10/2) 5)+(num-test (denominator 10/2) 1)+(num-test (numerator -10/3) -10)+(num-test (denominator -10/3) 3)+(num-test (numerator 10/10) 1)+(num-test (denominator 10/10) 1)+(num-test (numerator -10/1234) -5)+(num-test (denominator -10/1234) 617)+(num-test (numerator 10/1234000000) 1)+(num-test (denominator 10/1234000000) 123400000)+(num-test (numerator -10/500029) -10)+(num-test (denominator -10/500029) 500029)+(num-test (numerator 10/362880) 1)+(num-test (denominator 10/362880) 36288)+(num-test (numerator 1234/1) 1234)+(num-test (denominator 1234/1) 1)+(num-test (numerator -1234/2) -617)+(num-test (denominator -1234/2) 1)+(num-test (numerator 1234/3) 1234)+(num-test (denominator 1234/3) 3)+(num-test (numerator -1234/10) -617)+(num-test (denominator -1234/10) 5)+(num-test (numerator 1234/1234) 1)+(num-test (denominator 1234/1234) 1)+(num-test (numerator -1234/1234000000) -1)+(num-test (denominator -1234/1234000000) 1000000)+(num-test (numerator 1234/500029) 1234)+(num-test (denominator 1234/500029) 500029)+(num-test (numerator -1234/362880) -617)+(num-test (denominator -1234/362880) 181440)+(num-test (numerator -1234000000/1) -1234000000)+(num-test (denominator -1234000000/1) 1)+(num-test (numerator 1234000000/2) 617000000)+(num-test (denominator 1234000000/2) 1)+(num-test (numerator -1234000000/3) -1234000000)+(num-test (denominator -1234000000/3) 3)+(num-test (numerator 1234000000/10) 123400000)+(num-test (denominator 1234000000/10) 1)+(num-test (numerator -1234000000/1234) -1000000)+(num-test (denominator -1234000000/1234) 1)+(num-test (numerator 1234000000/1234000000) 1)+(num-test (denominator 1234000000/1234000000) 1)+(num-test (numerator -1234000000/500029) -1234000000)+(num-test (denominator -1234000000/500029) 500029)+(num-test (numerator 1234000000/362880) 1928125)+(num-test (denominator 1234000000/362880) 567)+(num-test (numerator 500029/1) 500029)+(num-test (denominator 500029/1) 1)+(num-test (numerator -500029/2) -500029)+(num-test (denominator -500029/2) 2)+(num-test (numerator 500029/3) 500029)+(num-test (denominator 500029/3) 3)+(num-test (numerator -500029/10) -500029)+(num-test (denominator -500029/10) 10)+(num-test (numerator 500029/1234) 500029)+(num-test (denominator 500029/1234) 1234)+(num-test (numerator -500029/1234000000) -500029)+(num-test (denominator -500029/1234000000) 1234000000)+(num-test (numerator 500029/500029) 1)+(num-test (denominator 500029/500029) 1)+(num-test (numerator -500029/362880) -500029)+(num-test (denominator -500029/362880) 362880)+(num-test (numerator -362880/1) -362880)+(num-test (denominator -362880/1) 1)+(num-test (numerator 362880/2) 181440)+(num-test (denominator 362880/2) 1)+(num-test (numerator -362880/3) -120960)+(num-test (denominator -362880/3) 1)+(num-test (numerator 362880/10) 36288)+(num-test (denominator 362880/10) 1)+(num-test (numerator -362880/1234) -181440)+(num-test (denominator -362880/1234) 617)+(num-test (numerator 362880/1234000000) 567)+(num-test (denominator 362880/1234000000) 1928125)+(num-test (numerator -362880/500029) -362880)+(num-test (denominator -362880/500029) 500029)+(num-test (numerator 362880/362880) 1)+(num-test (denominator 362880/362880) 1)+(num-test (numerator 5/2) 5)+(num-test (numerator (/ 8 -6)) -4)+(num-test (denominator 5/2) 2)+(num-test (denominator (/ 8 -6)) 3)+++;; -------- modulo, remainder, quotient+;;; (modulo x 0) -> x?  I seem to be getting errors instead; maxima returns x and refers to Section 3.4, of "Concrete Mathematics," by Graham, Knuth, and Patashnik+;;; (mod x 1.0) = sawtooth+(num-test (modulo 0 1) 0)+(num-test (modulo 3 1) 0)+(num-test (modulo -3 1) 0)+(num-test (modulo 3 -1) 0)+(num-test (remainder 0 1) 0)+(num-test (quotient 0 1) 0)+(num-test (modulo 0 1) 0)+(num-test (remainder 0 1) 0)+(num-test (quotient 0 1) 0)+(num-test (modulo 0 -1) 0)+(num-test (remainder 0 -1) 0)+(num-test (quotient 0 -1) 0)+(num-test (modulo 0 -1) 0)+(num-test (remainder 0 -1) 0)+(num-test (quotient 0 -1) 0)+(num-test (modulo 0 2) 0)+(num-test (remainder 0 2) 0)+(num-test (quotient 0 2) 0)+(num-test (modulo 0 2) 0)+(num-test (remainder 0 2) 0)+(num-test (quotient 0 2) 0)+(num-test (modulo 0 -2) 0)+(num-test (remainder 0 -2) 0)+(num-test (quotient 0 -2) 0)+(num-test (modulo 0 -2) 0)+(num-test (remainder 0 -2) 0)+(num-test (quotient 0 -2) 0)+(num-test (modulo 0 3) 0)+(num-test (remainder 0 3) 0)+(num-test (quotient 0 3) 0)+(num-test (modulo 0 3) 0)+(num-test (remainder 0 3) 0)+(num-test (quotient 0 3) 0)+(num-test (modulo 0 -3) 0)+(num-test (remainder 0 -3) 0)+(num-test (quotient 0 -3) 0)+(num-test (modulo 0 -3) 0)+(num-test (remainder 0 -3) 0)+(num-test (quotient 0 -3) 0)+(num-test (modulo 0 10) 0)+(num-test (remainder 0 10) 0)+(num-test (quotient 0 10) 0)+(num-test (modulo 0 10) 0)+(num-test (remainder 0 10) 0)+(num-test (quotient 0 10) 0)+(num-test (modulo 0 -10) 0)+(num-test (remainder 0 -10) 0)+(num-test (quotient 0 -10) 0)+(num-test (modulo 0 -10) 0)+(num-test (remainder 0 -10) 0)+(num-test (quotient 0 -10) 0)+(num-test (modulo 0 1234) 0)+(num-test (remainder 0 1234) 0)+(num-test (quotient 0 1234) 0)+(num-test (modulo 0 1234) 0)+(num-test (remainder 0 1234) 0)+(num-test (quotient 0 1234) 0)+(num-test (modulo 0 -1234) 0)+(num-test (remainder 0 -1234) 0)+(num-test (quotient 0 -1234) 0)+(num-test (modulo 0 -1234) 0)+(num-test (remainder 0 -1234) 0)+(num-test (quotient 0 -1234) 0)+(num-test (modulo 0 1234000000) 0)+(num-test (remainder 0 1234000000) 0)+(num-test (quotient 0 1234000000) 0)+(num-test (modulo 0 1234000000) 0)+(num-test (remainder 0 1234000000) 0)+(num-test (quotient 0 1234000000) 0)+(num-test (modulo 0 -1234000000) 0)+(num-test (remainder 0 -1234000000) 0)+(num-test (quotient 0 -1234000000) 0)+(num-test (modulo 0 -1234000000) 0)+(num-test (remainder 0 -1234000000) 0)+(num-test (quotient 0 -1234000000) 0)+(num-test (modulo 0 500029) 0)+(num-test (remainder 0 500029) 0)+(num-test (quotient 0 500029) 0)+(num-test (modulo 0 500029) 0)+(num-test (remainder 0 500029) 0)+(num-test (quotient 0 500029) 0)+(num-test (modulo 0 -500029) 0)+(num-test (remainder 0 -500029) 0)+(num-test (quotient 0 -500029) 0)+(num-test (modulo 0 -500029) 0)+(num-test (remainder 0 -500029) 0)+(num-test (quotient 0 -500029) 0)+(num-test (modulo 0 362880) 0)+(num-test (remainder 0 362880) 0)+(num-test (quotient 0 362880) 0)+(num-test (modulo 0 362880) 0)+(num-test (remainder 0 362880) 0)+(num-test (quotient 0 362880) 0)+(num-test (modulo 0 -362880) 0)+(num-test (remainder 0 -362880) 0)+(num-test (quotient 0 -362880) 0)+(num-test (modulo 0 -362880) 0)+(num-test (remainder 0 -362880) 0)+(num-test (quotient 0 -362880) 0)+(num-test (modulo 1 1) 0)+(num-test (remainder 1 1) 0)+(num-test (quotient 1 1) 1)+(num-test (modulo -1 1) 0)+(num-test (remainder -1 1) 0)+(num-test (quotient -1 1) -1)+(num-test (modulo 1 -1) 0)+(num-test (remainder 1 -1) 0)+(num-test (quotient 1 -1) -1)+(num-test (modulo -1 -1) 0)+(num-test (remainder -1 -1) 0)+(num-test (quotient -1 -1) 1)+(num-test (modulo 1 2) 1)+(num-test (remainder 1 2) 1)+(num-test (quotient 1 2) 0)+(num-test (modulo -1 2) 1)+(num-test (remainder -1 2) -1)+(num-test (quotient -1 2) 0)+(num-test (modulo 1 -2) -1)+(num-test (remainder 1 -2) 1)+(num-test (quotient 1 -2) 0)+(num-test (modulo -1 -2) -1)+(num-test (remainder -1 -2) -1)+(num-test (quotient -1 -2) 0)+(num-test (modulo 1 3) 1)+(num-test (remainder 1 3) 1)+(num-test (quotient 1 3) 0)+(num-test (modulo -1 3) 2)+(num-test (remainder -1 3) -1)+(num-test (quotient -1 3) 0)+(num-test (modulo 1 -3) -2)+(num-test (remainder 1 -3) 1)+(num-test (quotient 1 -3) 0)+(num-test (modulo -1 -3) -1)+(num-test (remainder -1 -3) -1)+(num-test (quotient -1 -3) 0)+(num-test (modulo 1 10) 1)+(num-test (remainder 1 10) 1)+(num-test (quotient 1 10) 0)+(num-test (modulo -1 10) 9)+(num-test (remainder -1 10) -1)+(num-test (quotient -1 10) 0)+(num-test (modulo 1 -10) -9)+(num-test (remainder 1 -10) 1)+(num-test (quotient 1 -10) 0)+(num-test (modulo -1 -10) -1)+(num-test (remainder -1 -10) -1)+(num-test (quotient -1 -10) 0)+(num-test (modulo 1 1234) 1)+(num-test (remainder 1 1234) 1)+(num-test (quotient 1 1234) 0)+(num-test (modulo -1 1234) 1233)+(num-test (remainder -1 1234) -1)+(num-test (quotient -1 1234) 0)+(num-test (modulo 1 -1234) -1233)+(num-test (remainder 1 -1234) 1)+(num-test (quotient 1 -1234) 0)+(num-test (modulo -1 -1234) -1)+(num-test (remainder -1 -1234) -1)+(num-test (quotient -1 -1234) 0)+(num-test (modulo 1 1234000000) 1)+(num-test (remainder 1 1234000000) 1)+(num-test (quotient 1 1234000000) 0)+(num-test (modulo -1 1234000000) 1233999999)+(num-test (remainder -1 1234000000) -1)+(num-test (quotient -1 1234000000) 0)+(num-test (modulo 1 -1234000000) -1233999999)+(num-test (remainder 1 -1234000000) 1)+(num-test (quotient 1 -1234000000) 0)+(num-test (modulo -1 -1234000000) -1)+(num-test (remainder -1 -1234000000) -1)+(num-test (quotient -1 -1234000000) 0)+(num-test (modulo 1 500029) 1)+(num-test (remainder 1 500029) 1)+(num-test (quotient 1 500029) 0)+(num-test (modulo -1 500029) 500028)+(num-test (remainder -1 500029) -1)+(num-test (quotient -1 500029) 0)+(num-test (modulo 1 -500029) -500028)+(num-test (remainder 1 -500029) 1)+(num-test (quotient 1 -500029) 0)+(num-test (modulo -1 -500029) -1)+(num-test (remainder -1 -500029) -1)+(num-test (quotient -1 -500029) 0)+(num-test (modulo 1 362880) 1)+(num-test (remainder 1 362880) 1)+(num-test (quotient 1 362880) 0)+(num-test (modulo -1 362880) 362879)+(num-test (remainder -1 362880) -1)+(num-test (quotient -1 362880) 0)+(num-test (modulo 1 -362880) -362879)+(num-test (remainder 1 -362880) 1)+(num-test (quotient 1 -362880) 0)+(num-test (modulo -1 -362880) -1)+(num-test (remainder -1 -362880) -1)+(num-test (quotient -1 -362880) 0)+(num-test (modulo 2 1) 0)+(num-test (remainder 2 1) 0)+(num-test (quotient 2 1) 2)+(num-test (modulo -2 1) 0)+(num-test (remainder -2 1) 0)+(num-test (quotient -2 1) -2)+(num-test (modulo 2 -1) 0)+(num-test (remainder 2 -1) 0)+(num-test (quotient 2 -1) -2)+(num-test (modulo -2 -1) 0)+(num-test (remainder -2 -1) 0)+(num-test (quotient -2 -1) 2)+(num-test (modulo 2 2) 0)+(num-test (remainder 2 2) 0)+(num-test (quotient 2 2) 1)+(num-test (modulo -2 2) 0)+(num-test (remainder -2 2) 0)+(num-test (quotient -2 2) -1)+(num-test (modulo 2 -2) 0)+(num-test (remainder 2 -2) 0)+(num-test (quotient 2 -2) -1)+(num-test (modulo -2 -2) 0)+(num-test (remainder -2 -2) 0)+(num-test (quotient -2 -2) 1)+(num-test (modulo 2 3) 2)+(num-test (remainder 2 3) 2)+(num-test (quotient 2 3) 0)+(num-test (modulo -2 3) 1)+(num-test (remainder -2 3) -2)+(num-test (quotient -2 3) 0)+(num-test (modulo 2 -3) -1)+(num-test (remainder 2 -3) 2)+(num-test (quotient 2 -3) 0)+(num-test (modulo -2 -3) -2)+(num-test (remainder -2 -3) -2)+(num-test (quotient -2 -3) 0)+(num-test (modulo 2 10) 2)+(num-test (remainder 2 10) 2)+(num-test (quotient 2 10) 0)+(num-test (modulo -2 10) 8)+(num-test (remainder -2 10) -2)+(num-test (quotient -2 10) 0)+(num-test (modulo 2 -10) -8)+(num-test (remainder 2 -10) 2)+(num-test (quotient 2 -10) 0)+(num-test (modulo -2 -10) -2)+(num-test (remainder -2 -10) -2)+(num-test (quotient -2 -10) 0)+(num-test (modulo 2 1234) 2)+(num-test (remainder 2 1234) 2)+(num-test (quotient 2 1234) 0)+(num-test (modulo -2 1234) 1232)+(num-test (remainder -2 1234) -2)+(num-test (quotient -2 1234) 0)+(num-test (modulo 2 -1234) -1232)+(num-test (remainder 2 -1234) 2)+(num-test (quotient 2 -1234) 0)+(num-test (modulo -2 -1234) -2)+(num-test (remainder -2 -1234) -2)+(num-test (quotient -2 -1234) 0)+(num-test (modulo 2 1234000000) 2)+(num-test (remainder 2 1234000000) 2)+(num-test (quotient 2 1234000000) 0)+(num-test (modulo -2 1234000000) 1233999998)+(num-test (remainder -2 1234000000) -2)+(num-test (quotient -2 1234000000) 0)+(num-test (modulo 2 -1234000000) -1233999998)+(num-test (remainder 2 -1234000000) 2)+(num-test (quotient 2 -1234000000) 0)+(num-test (modulo -2 -1234000000) -2)+(num-test (remainder -2 -1234000000) -2)+(num-test (quotient -2 -1234000000) 0)+(num-test (modulo 2 500029) 2)+(num-test (remainder 2 500029) 2)+(num-test (quotient 2 500029) 0)+(num-test (modulo -2 500029) 500027)+(num-test (remainder -2 500029) -2)+(num-test (quotient -2 500029) 0)+(num-test (modulo 2 -500029) -500027)+(num-test (remainder 2 -500029) 2)+(num-test (quotient 2 -500029) 0)+(num-test (modulo -2 -500029) -2)+(num-test (remainder -2 -500029) -2)+(num-test (quotient -2 -500029) 0)+(num-test (modulo 2 362880) 2)+(num-test (remainder 2 362880) 2)+(num-test (quotient 2 362880) 0)+(num-test (modulo -2 362880) 362878)+(num-test (remainder -2 362880) -2)+(num-test (quotient -2 362880) 0)+(num-test (modulo 2 -362880) -362878)+(num-test (remainder 2 -362880) 2)+(num-test (quotient 2 -362880) 0)+(num-test (modulo -2 -362880) -2)+(num-test (remainder -2 -362880) -2)+(num-test (quotient -2 -362880) 0)+(num-test (modulo 3 1) 0)+(num-test (remainder 3 1) 0)+(num-test (quotient 3 1) 3)+(num-test (modulo -3 1) 0)+(num-test (remainder -3 1) 0)+(num-test (quotient -3 1) -3)+(num-test (modulo 3 -1) 0)+(num-test (remainder 3 -1) 0)+(num-test (quotient 3 -1) -3)+(num-test (modulo -3 -1) 0)+(num-test (remainder -3 -1) 0)+(num-test (quotient -3 -1) 3)+(num-test (modulo 3 2) 1)+(num-test (remainder 3 2) 1)+(num-test (quotient 3 2) 1)+(num-test (modulo -3 2) 1)+(num-test (remainder -3 2) -1)+(num-test (quotient -3 2) -1)+(num-test (modulo 3 -2) -1)+(num-test (remainder 3 -2) 1)+(num-test (quotient 3 -2) -1)+(num-test (modulo -3 -2) -1)+(num-test (remainder -3 -2) -1)+(num-test (quotient -3 -2) 1)+(num-test (modulo 3 3) 0)+(num-test (remainder 3 3) 0)+(num-test (quotient 3 3) 1)+(num-test (modulo -3 3) 0)+(num-test (remainder -3 3) 0)+(num-test (quotient -3 3) -1)+(num-test (modulo 3 -3) 0)+(num-test (remainder 3 -3) 0)+(num-test (quotient 3 -3) -1)+(num-test (modulo -3 -3) 0)+(num-test (remainder -3 -3) 0)+(num-test (quotient -3 -3) 1)+(num-test (modulo 3 10) 3)+(num-test (remainder 3 10) 3)+(num-test (quotient 3 10) 0)+(num-test (modulo -3 10) 7)+(num-test (remainder -3 10) -3)+(num-test (quotient -3 10) 0)+(num-test (modulo 3 -10) -7)+(num-test (remainder 3 -10) 3)+(num-test (quotient 3 -10) 0)+(num-test (modulo -3 -10) -3)+(num-test (remainder -3 -10) -3)+(num-test (quotient -3 -10) 0)+(num-test (modulo 3 1234) 3)+(num-test (remainder 3 1234) 3)+(num-test (quotient 3 1234) 0)+(num-test (modulo -3 1234) 1231)+(num-test (remainder -3 1234) -3)+(num-test (quotient -3 1234) 0)+(num-test (modulo 3 -1234) -1231)+(num-test (remainder 3 -1234) 3)+(num-test (quotient 3 -1234) 0)+(num-test (modulo -3 -1234) -3)+(num-test (remainder -3 -1234) -3)+(num-test (quotient -3 -1234) 0)+(num-test (modulo 3 1234000000) 3)+(num-test (remainder 3 1234000000) 3)+(num-test (quotient 3 1234000000) 0)+(num-test (modulo -3 1234000000) 1233999997)+(num-test (remainder -3 1234000000) -3)+(num-test (quotient -3 1234000000) 0)+(num-test (modulo 3 -1234000000) -1233999997)+(num-test (remainder 3 -1234000000) 3)+(num-test (quotient 3 -1234000000) 0)+(num-test (modulo -3 -1234000000) -3)+(num-test (remainder -3 -1234000000) -3)+(num-test (quotient -3 -1234000000) 0)+(num-test (modulo 3 500029) 3)+(num-test (remainder 3 500029) 3)+(num-test (quotient 3 500029) 0)+(num-test (modulo -3 500029) 500026)+(num-test (remainder -3 500029) -3)+(num-test (quotient -3 500029) 0)+(num-test (modulo 3 -500029) -500026)+(num-test (remainder 3 -500029) 3)+(num-test (quotient 3 -500029) 0)+(num-test (modulo -3 -500029) -3)+(num-test (remainder -3 -500029) -3)+(num-test (quotient -3 -500029) 0)+(num-test (modulo 3 362880) 3)+(num-test (remainder 3 362880) 3)+(num-test (quotient 3 362880) 0)+(num-test (modulo -3 362880) 362877)+(num-test (remainder -3 362880) -3)+(num-test (quotient -3 362880) 0)+(num-test (modulo 3 -362880) -362877)+(num-test (remainder 3 -362880) 3)+(num-test (quotient 3 -362880) 0)+(num-test (modulo -3 -362880) -3)+(num-test (remainder -3 -362880) -3)+(num-test (quotient -3 -362880) 0)+(num-test (modulo 10 1) 0)+(num-test (remainder 10 1) 0)+(num-test (quotient 10 1) 10)+(num-test (modulo -10 1) 0)+(num-test (remainder -10 1) 0)+(num-test (quotient -10 1) -10)+(num-test (modulo 10 -1) 0)+(num-test (remainder 10 -1) 0)+(num-test (quotient 10 -1) -10)+(num-test (modulo -10 -1) 0)+(num-test (remainder -10 -1) 0)+(num-test (quotient -10 -1) 10)+(num-test (modulo 10 2) 0)+(num-test (remainder 10 2) 0)+(num-test (quotient 10 2) 5)+(num-test (modulo -10 2) 0)+(num-test (remainder -10 2) 0)+(num-test (quotient -10 2) -5)+(num-test (modulo 10 -2) 0)+(num-test (remainder 10 -2) 0)+(num-test (quotient 10 -2) -5)+(num-test (modulo -10 -2) 0)+(num-test (remainder -10 -2) 0)+(num-test (quotient -10 -2) 5)+(num-test (modulo 10 3) 1)+(num-test (remainder 10 3) 1)+(num-test (quotient 10 3) 3)+(num-test (modulo -10 3) 2)+(num-test (remainder -10 3) -1)+(num-test (quotient -10 3) -3)+(num-test (modulo 10 -3) -2)+(num-test (remainder 10 -3) 1)+(num-test (quotient 10 -3) -3)+(num-test (modulo -10 -3) -1)+(num-test (remainder -10 -3) -1)+(num-test (quotient -10 -3) 3)+(num-test (modulo 10 10) 0)+(num-test (remainder 10 10) 0)+(num-test (quotient 10 10) 1)+(num-test (modulo -10 10) 0)+(num-test (remainder -10 10) 0)+(num-test (quotient -10 10) -1)+(num-test (modulo 10 -10) 0)+(num-test (remainder 10 -10) 0)+(num-test (quotient 10 -10) -1)+(num-test (modulo -10 -10) 0)+(num-test (remainder -10 -10) 0)+(num-test (quotient -10 -10) 1)+(num-test (modulo 10 1234) 10)+(num-test (remainder 10 1234) 10)+(num-test (quotient 10 1234) 0)+(num-test (modulo -10 1234) 1224)+(num-test (remainder -10 1234) -10)+(num-test (quotient -10 1234) 0)+(num-test (modulo 10 -1234) -1224)+(num-test (remainder 10 -1234) 10)+(num-test (quotient 10 -1234) 0)+(num-test (modulo -10 -1234) -10)+(num-test (remainder -10 -1234) -10)+(num-test (quotient -10 -1234) 0)+(num-test (modulo 10 1234000000) 10)+(num-test (remainder 10 1234000000) 10)+(num-test (quotient 10 1234000000) 0)+(num-test (modulo -10 1234000000) 1233999990)+(num-test (remainder -10 1234000000) -10)+(num-test (quotient -10 1234000000) 0)+(num-test (modulo 10 -1234000000) -1233999990)+(num-test (remainder 10 -1234000000) 10)+(num-test (quotient 10 -1234000000) 0)+(num-test (modulo -10 -1234000000) -10)+(num-test (remainder -10 -1234000000) -10)+(num-test (quotient -10 -1234000000) 0)+(num-test (modulo 10 500029) 10)+(num-test (remainder 10 500029) 10)+(num-test (quotient 10 500029) 0)+(num-test (modulo -10 500029) 500019)+(num-test (remainder -10 500029) -10)+(num-test (quotient -10 500029) 0)+(num-test (modulo 10 -500029) -500019)+(num-test (remainder 10 -500029) 10)+(num-test (quotient 10 -500029) 0)+(num-test (modulo -10 -500029) -10)+(num-test (remainder -10 -500029) -10)+(num-test (quotient -10 -500029) 0)+(num-test (modulo 10 362880) 10)+(num-test (remainder 10 362880) 10)+(num-test (quotient 10 362880) 0)+(num-test (modulo -10 362880) 362870)+(num-test (remainder -10 362880) -10)+(num-test (quotient -10 362880) 0)+(num-test (modulo 10 -362880) -362870)+(num-test (remainder 10 -362880) 10)+(num-test (quotient 10 -362880) 0)+(num-test (modulo -10 -362880) -10)+(num-test (remainder -10 -362880) -10)+(num-test (quotient -10 -362880) 0)+(num-test (modulo 1234 1) 0)+(num-test (remainder 1234 1) 0)+(num-test (quotient 1234 1) 1234)+(num-test (modulo -1234 1) 0)+(num-test (remainder -1234 1) 0)+(num-test (quotient -1234 1) -1234)+(num-test (modulo 1234 -1) 0)+(num-test (remainder 1234 -1) 0)+(num-test (quotient 1234 -1) -1234)+(num-test (modulo -1234 -1) 0)+(num-test (remainder -1234 -1) 0)+(num-test (quotient -1234 -1) 1234)+(num-test (modulo 1234 2) 0)+(num-test (remainder 1234 2) 0)+(num-test (quotient 1234 2) 617)+(num-test (modulo -1234 2) 0)+(num-test (remainder -1234 2) 0)+(num-test (quotient -1234 2) -617)+(num-test (modulo 1234 -2) 0)+(num-test (remainder 1234 -2) 0)+(num-test (quotient 1234 -2) -617)+(num-test (modulo -1234 -2) 0)+(num-test (remainder -1234 -2) 0)+(num-test (quotient -1234 -2) 617)+(num-test (modulo 1234 3) 1)+(num-test (remainder 1234 3) 1)+(num-test (quotient 1234 3) 411)+(num-test (modulo -1234 3) 2)+(num-test (remainder -1234 3) -1)+(num-test (quotient -1234 3) -411)+(num-test (modulo 1234 -3) -2)+(num-test (remainder 1234 -3) 1)+(num-test (quotient 1234 -3) -411)+(num-test (modulo -1234 -3) -1)+(num-test (remainder -1234 -3) -1)+(num-test (quotient -1234 -3) 411)+(num-test (modulo 1234 10) 4)+(num-test (remainder 1234 10) 4)+(num-test (quotient 1234 10) 123)+(num-test (modulo -1234 10) 6)+(num-test (remainder -1234 10) -4)+(num-test (quotient -1234 10) -123)+(num-test (modulo 1234 -10) -6)+(num-test (remainder 1234 -10) 4)+(num-test (quotient 1234 -10) -123)+(num-test (modulo -1234 -10) -4)+(num-test (remainder -1234 -10) -4)+(num-test (quotient -1234 -10) 123)+(num-test (modulo 1234 1234) 0)+(num-test (remainder 1234 1234) 0)+(num-test (quotient 1234 1234) 1)+(num-test (modulo -1234 1234) 0)+(num-test (remainder -1234 1234) 0)+(num-test (quotient -1234 1234) -1)+(num-test (modulo 1234 -1234) 0)+(num-test (remainder 1234 -1234) 0)+(num-test (quotient 1234 -1234) -1)+(num-test (modulo -1234 -1234) 0)+(num-test (remainder -1234 -1234) 0)+(num-test (quotient -1234 -1234) 1)+(num-test (modulo 1234 1234000000) 1234)+(num-test (remainder 1234 1234000000) 1234)+(num-test (quotient 1234 1234000000) 0)+(num-test (modulo -1234 1234000000) 1233998766)+(num-test (remainder -1234 1234000000) -1234)+(num-test (quotient -1234 1234000000) 0)+(num-test (modulo 1234 -1234000000) -1233998766)+(num-test (remainder 1234 -1234000000) 1234)+(num-test (quotient 1234 -1234000000) 0)+(num-test (modulo -1234 -1234000000) -1234)+(num-test (remainder -1234 -1234000000) -1234)+(num-test (quotient -1234 -1234000000) 0)+(num-test (modulo 1234 500029) 1234)+(num-test (remainder 1234 500029) 1234)+(num-test (quotient 1234 500029) 0)+(num-test (modulo -1234 500029) 498795)+(num-test (remainder -1234 500029) -1234)+(num-test (quotient -1234 500029) 0)+(num-test (modulo 1234 -500029) -498795)+(num-test (remainder 1234 -500029) 1234)+(num-test (quotient 1234 -500029) 0)+(num-test (modulo -1234 -500029) -1234)+(num-test (remainder -1234 -500029) -1234)+(num-test (quotient -1234 -500029) 0)+(num-test (modulo 1234 362880) 1234)+(num-test (remainder 1234 362880) 1234)+(num-test (quotient 1234 362880) 0)+(num-test (modulo -1234 362880) 361646)+(num-test (remainder -1234 362880) -1234)+(num-test (quotient -1234 362880) 0)+(num-test (modulo 1234 -362880) -361646)+(num-test (remainder 1234 -362880) 1234)+(num-test (quotient 1234 -362880) 0)+(num-test (modulo -1234 -362880) -1234)+(num-test (remainder -1234 -362880) -1234)+(num-test (quotient -1234 -362880) 0)+(num-test (modulo 1234000000 1) 0)+(num-test (remainder 1234000000 1) 0)+(num-test (quotient 1234000000 1) 1234000000)+(num-test (modulo -1234000000 1) 0)+(num-test (remainder -1234000000 1) 0)+(num-test (quotient -1234000000 1) -1234000000)+(num-test (modulo 1234000000 -1) 0)+(num-test (remainder 1234000000 -1) 0)+(num-test (quotient 1234000000 -1) -1234000000)+(num-test (modulo -1234000000 -1) 0)+(num-test (remainder -1234000000 -1) 0)+(num-test (quotient -1234000000 -1) 1234000000)+(num-test (modulo 1234000000 2) 0)+(num-test (remainder 1234000000 2) 0)+(num-test (quotient 1234000000 2) 617000000)+(num-test (modulo -1234000000 2) 0)+(num-test (remainder -1234000000 2) 0)+(num-test (quotient -1234000000 2) -617000000)+(num-test (modulo 1234000000 -2) 0)+(num-test (remainder 1234000000 -2) 0)+(num-test (quotient 1234000000 -2) -617000000)+(num-test (modulo -1234000000 -2) 0)+(num-test (remainder -1234000000 -2) 0)+(num-test (quotient -1234000000 -2) 617000000)+(num-test (modulo 1234000000 3) 1)+(num-test (remainder 1234000000 3) 1)+(num-test (quotient 1234000000 3) 411333333)+(num-test (modulo -1234000000 3) 2)+(num-test (remainder -1234000000 3) -1)+(num-test (quotient -1234000000 3) -411333333)+(num-test (modulo 1234000000 -3) -2)+(num-test (remainder 1234000000 -3) 1)+(num-test (quotient 1234000000 -3) -411333333)+(num-test (modulo -1234000000 -3) -1)+(num-test (remainder -1234000000 -3) -1)+(num-test (quotient -1234000000 -3) 411333333)+(num-test (modulo 1234000000 10) 0)+(num-test (remainder 1234000000 10) 0)+(num-test (quotient 1234000000 10) 123400000)+(num-test (modulo -1234000000 10) 0)+(num-test (remainder -1234000000 10) 0)+(num-test (quotient -1234000000 10) -123400000)+(num-test (modulo 1234000000 -10) 0)+(num-test (remainder 1234000000 -10) 0)+(num-test (quotient 1234000000 -10) -123400000)+(num-test (modulo -1234000000 -10) 0)+(num-test (remainder -1234000000 -10) 0)+(num-test (quotient -1234000000 -10) 123400000)+(num-test (modulo 1234000000 1234) 0)+(num-test (remainder 1234000000 1234) 0)+(num-test (quotient 1234000000 1234) 1000000)+(num-test (modulo -1234000000 1234) 0)+(num-test (remainder -1234000000 1234) 0)+(num-test (quotient -1234000000 1234) -1000000)+(num-test (modulo 1234000000 -1234) 0)+(num-test (remainder 1234000000 -1234) 0)+(num-test (quotient 1234000000 -1234) -1000000)+(num-test (modulo -1234000000 -1234) 0)+(num-test (remainder -1234000000 -1234) 0)+(num-test (quotient -1234000000 -1234) 1000000)+(num-test (modulo 1234000000 1234000000) 0)+(num-test (remainder 1234000000 1234000000) 0)+(num-test (quotient 1234000000 1234000000) 1)+(num-test (modulo -1234000000 1234000000) 0)+(num-test (remainder -1234000000 1234000000) 0)+(num-test (quotient -1234000000 1234000000) -1)+(num-test (modulo 1234000000 -1234000000) 0)+(num-test (remainder 1234000000 -1234000000) 0)+(num-test (quotient 1234000000 -1234000000) -1)+(num-test (modulo -1234000000 -1234000000) 0)+(num-test (remainder -1234000000 -1234000000) 0)+(num-test (quotient -1234000000 -1234000000) 1)+(num-test (modulo 1234000000 500029) 428457)+(num-test (remainder 1234000000 500029) 428457)+(num-test (quotient 1234000000 500029) 2467)+(num-test (modulo -1234000000 500029) 71572)+(num-test (remainder -1234000000 500029) -428457)+(num-test (quotient -1234000000 500029) -2467)+(num-test (modulo 1234000000 -500029) -71572)+(num-test (remainder 1234000000 -500029) 428457)+(num-test (quotient 1234000000 -500029) -2467)+(num-test (modulo -1234000000 -500029) -428457)+(num-test (remainder -1234000000 -500029) -428457)+(num-test (quotient -1234000000 -500029) 2467)+(num-test (modulo 1234000000 362880) 208000)+(num-test (remainder 1234000000 362880) 208000)+(num-test (quotient 1234000000 362880) 3400)+(num-test (modulo -1234000000 362880) 154880)+(num-test (remainder -1234000000 362880) -208000)+(num-test (quotient -1234000000 362880) -3400)+(num-test (modulo 1234000000 -362880) -154880)+(num-test (remainder 1234000000 -362880) 208000)+(num-test (quotient 1234000000 -362880) -3400)+(num-test (modulo -1234000000 -362880) -208000)+(num-test (remainder -1234000000 -362880) -208000)+(num-test (quotient -1234000000 -362880) 3400)+(num-test (modulo 500029 1) 0)+(num-test (remainder 500029 1) 0)+(num-test (quotient 500029 1) 500029)+(num-test (modulo -500029 1) 0)+(num-test (remainder -500029 1) 0)+(num-test (quotient -500029 1) -500029)+(num-test (modulo 500029 -1) 0)+(num-test (remainder 500029 -1) 0)+(num-test (quotient 500029 -1) -500029)+(num-test (modulo -500029 -1) 0)+(num-test (remainder -500029 -1) 0)+(num-test (quotient -500029 -1) 500029)+(num-test (modulo 500029 2) 1)+(num-test (remainder 500029 2) 1)+(num-test (quotient 500029 2) 250014)+(num-test (modulo -500029 2) 1)+(num-test (remainder -500029 2) -1)+(num-test (quotient -500029 2) -250014)+(num-test (modulo 500029 -2) -1)+(num-test (remainder 500029 -2) 1)+(num-test (quotient 500029 -2) -250014)+(num-test (modulo -500029 -2) -1)+(num-test (remainder -500029 -2) -1)+(num-test (quotient -500029 -2) 250014)+(num-test (modulo 500029 3) 1)+(num-test (remainder 500029 3) 1)+(num-test (quotient 500029 3) 166676)+(num-test (modulo -500029 3) 2)+(num-test (remainder -500029 3) -1)+(num-test (quotient -500029 3) -166676)+(num-test (modulo 500029 -3) -2)+(num-test (remainder 500029 -3) 1)+(num-test (quotient 500029 -3) -166676)+(num-test (modulo -500029 -3) -1)+(num-test (remainder -500029 -3) -1)+(num-test (quotient -500029 -3) 166676)+(num-test (modulo 500029 10) 9)+(num-test (remainder 500029 10) 9)+(num-test (quotient 500029 10) 50002)+(num-test (modulo -500029 10) 1)+(num-test (remainder -500029 10) -9)+(num-test (quotient -500029 10) -50002)+(num-test (modulo 500029 -10) -1)+(num-test (remainder 500029 -10) 9)+(num-test (quotient 500029 -10) -50002)+(num-test (modulo -500029 -10) -9)+(num-test (remainder -500029 -10) -9)+(num-test (quotient -500029 -10) 50002)+(num-test (modulo 500029 1234) 259)+(num-test (remainder 500029 1234) 259)+(num-test (quotient 500029 1234) 405)+(num-test (modulo -500029 1234) 975)+(num-test (remainder -500029 1234) -259)+(num-test (quotient -500029 1234) -405)+(num-test (modulo 500029 -1234) -975)+(num-test (remainder 500029 -1234) 259)+(num-test (quotient 500029 -1234) -405)+(num-test (modulo -500029 -1234) -259)+(num-test (remainder -500029 -1234) -259)+(num-test (quotient -500029 -1234) 405)+(num-test (modulo 500029 1234000000) 500029)+(num-test (remainder 500029 1234000000) 500029)+(num-test (quotient 500029 1234000000) 0)+(num-test (modulo -500029 1234000000) 1233499971)+(num-test (remainder -500029 1234000000) -500029)+(num-test (quotient -500029 1234000000) 0)+(num-test (modulo 500029 -1234000000) -1233499971)+(num-test (remainder 500029 -1234000000) 500029)+(num-test (quotient 500029 -1234000000) 0)+(num-test (modulo -500029 -1234000000) -500029)+(num-test (remainder -500029 -1234000000) -500029)+(num-test (quotient -500029 -1234000000) 0)+(num-test (modulo 500029 500029) 0)+(num-test (remainder 500029 500029) 0)+(num-test (quotient 500029 500029) 1)+(num-test (modulo -500029 500029) 0)+(num-test (remainder -500029 500029) 0)+(num-test (quotient -500029 500029) -1)+(num-test (modulo 500029 -500029) 0)+(num-test (remainder 500029 -500029) 0)+(num-test (quotient 500029 -500029) -1)+(num-test (modulo -500029 -500029) 0)+(num-test (remainder -500029 -500029) 0)+(num-test (quotient -500029 -500029) 1)+(num-test (modulo 500029 362880) 137149)+(num-test (remainder 500029 362880) 137149)+(num-test (quotient 500029 362880) 1)+(num-test (modulo -500029 362880) 225731)+(num-test (remainder -500029 362880) -137149)+(num-test (quotient -500029 362880) -1)+(num-test (modulo 500029 -362880) -225731)+(num-test (remainder 500029 -362880) 137149)+(num-test (quotient 500029 -362880) -1)+(num-test (modulo -500029 -362880) -137149)+(num-test (remainder -500029 -362880) -137149)+(num-test (quotient -500029 -362880) 1)+(num-test (modulo 362880 1) 0)+(num-test (remainder 362880 1) 0)+(num-test (quotient 362880 1) 362880)+(num-test (modulo -362880 1) 0)+(num-test (remainder -362880 1) 0)+(num-test (quotient -362880 1) -362880)+(num-test (modulo 362880 -1) 0)+(num-test (remainder 362880 -1) 0)+(num-test (quotient 362880 -1) -362880)+(num-test (modulo -362880 -1) 0)+(num-test (remainder -362880 -1) 0)+(num-test (quotient -362880 -1) 362880)+(num-test (modulo 362880 2) 0)+(num-test (remainder 362880 2) 0)+(num-test (quotient 362880 2) 181440)+(num-test (modulo -362880 2) 0)+(num-test (remainder -362880 2) 0)+(num-test (quotient -362880 2) -181440)+(num-test (modulo 362880 -2) 0)+(num-test (remainder 362880 -2) 0)+(num-test (quotient 362880 -2) -181440)+(num-test (modulo -362880 -2) 0)+(num-test (remainder -362880 -2) 0)+(num-test (quotient -362880 -2) 181440)+(num-test (modulo 362880 3) 0)+(num-test (remainder 362880 3) 0)+(num-test (quotient 362880 3) 120960)+(num-test (modulo -362880 3) 0)+(num-test (remainder -362880 3) 0)+(num-test (quotient -362880 3) -120960)+(num-test (modulo 362880 -3) 0)+(num-test (remainder 362880 -3) 0)+(num-test (quotient 362880 -3) -120960)+(num-test (modulo -362880 -3) 0)+(num-test (remainder -362880 -3) 0)+(num-test (quotient -362880 -3) 120960)+(num-test (modulo 362880 10) 0)+(num-test (remainder 362880 10) 0)+(num-test (quotient 362880 10) 36288)+(num-test (modulo -362880 10) 0)+(num-test (remainder -362880 10) 0)+(num-test (quotient -362880 10) -36288)+(num-test (modulo 362880 -10) 0)+(num-test (remainder 362880 -10) 0)+(num-test (quotient 362880 -10) -36288)+(num-test (modulo -362880 -10) 0)+(num-test (remainder -362880 -10) 0)+(num-test (quotient -362880 -10) 36288)+(num-test (modulo 362880 1234) 84)+(num-test (remainder 362880 1234) 84)+(num-test (quotient 362880 1234) 294)+(num-test (modulo -362880 1234) 1150)+(num-test (remainder -362880 1234) -84)+(num-test (quotient -362880 1234) -294)+(num-test (modulo 362880 -1234) -1150)+(num-test (remainder 362880 -1234) 84)+(num-test (quotient 362880 -1234) -294)+(num-test (modulo -362880 -1234) -84)+(num-test (remainder -362880 -1234) -84)+(num-test (quotient -362880 -1234) 294)+(num-test (modulo 362880 1234000000) 362880)+(num-test (remainder 362880 1234000000) 362880)+(num-test (quotient 362880 1234000000) 0)+(num-test (modulo -362880 1234000000) 1233637120)+(num-test (remainder -362880 1234000000) -362880)+(num-test (quotient -362880 1234000000) 0)+(num-test (modulo 362880 -1234000000) -1233637120)+(num-test (remainder 362880 -1234000000) 362880)+(num-test (quotient 362880 -1234000000) 0)+(num-test (modulo -362880 -1234000000) -362880)+(num-test (remainder -362880 -1234000000) -362880)+(num-test (quotient -362880 -1234000000) 0)+(num-test (modulo 362880 500029) 362880)+(num-test (remainder 362880 500029) 362880)+(num-test (quotient 362880 500029) 0)+(num-test (modulo -362880 500029) 137149)+(num-test (remainder -362880 500029) -362880)+(num-test (quotient -362880 500029) 0)+(num-test (modulo 362880 -500029) -137149)+(num-test (remainder 362880 -500029) 362880)+(num-test (quotient 362880 -500029) 0)+(num-test (modulo -362880 -500029) -362880)+(num-test (remainder -362880 -500029) -362880)+(num-test (quotient -362880 -500029) 0)+(num-test (modulo 362880 362880) 0)+(num-test (remainder 362880 362880) 0)+(num-test (quotient 362880 362880) 1)+(num-test (modulo -362880 362880) 0)+(num-test (remainder -362880 362880) 0)+(num-test (quotient -362880 362880) -1)+(num-test (modulo 362880 -362880) 0)+(num-test (remainder 362880 -362880) 0)+(num-test (quotient 362880 -362880) -1)+(num-test (modulo -362880 -362880) 0)+(num-test (remainder -362880 -362880) 0)+(num-test (quotient -362880 -362880) 1)++(num-test (modulo 13 4) 1)+(num-test (modulo -13 4) 3)+(num-test (quotient 35 7) 5 )+(num-test (quotient -35 7) -5)+(num-test (quotient 35 -7) -5)+(num-test (quotient -35 -7) 5)+(num-test (modulo 13 4) 1)+(num-test (remainder 13 4) 1)+(num-test (modulo -13 4) 3)+(num-test (remainder -13 4) -1)+(num-test (modulo 13 -4) -3)+(num-test (remainder 13 -4) 1)+(num-test (modulo -13 -4) -1)+(num-test (remainder -13 -4) -1)+(num-test (modulo 0 86400) 0)+(num-test (modulo 0 -86400) 0)++(let ((top-exp 60))+  (let ((happy #t))+    (do ((i 2 (+ i 1)))+	((or (not happy) (> i top-exp)))+      (let* ((val1 (inexact->exact (expt 2 i)))+	     (val2 (+ val1 1))+	     (mv (modulo val2 2))+	     (qv (quotient val2 2))+	     (rv (remainder val2 2)))+	(if (not (= mv 1))+	    (begin (set! happy #f) (display "(modulo ") (display val2) (display " 2) = ") (display mv) (display "?") (newline)))+	(if (not (= qv (/ val1 2)))+	    (begin (set! happy #f) (display "(quotient ") (display val2) (display " 2) = ") (display qv) (display "?") (newline)))+	(if (not (= rv 1))+	    (begin (set! happy #f) (display "(remainder ") (display val2) (display " 2) = ") (display rv) (display "?") (newline))))))+  )+++;; -------- abs and magnitude++(num-test (abs 0) 0)+(num-test (abs -0) 0)+(num-test (magnitude 0) 0)+(num-test (magnitude -0) 0)+(num-test (abs 0/1) 0/1)+(num-test (abs -0/1) 0/1)+(num-test (magnitude 0/1) 0/1)+(num-test (magnitude -0/1) 0/1)+(num-test (abs 0/2) 0/2)+(num-test (abs -0/2) 0/2)+(num-test (magnitude 0/2) 0/2)+(num-test (magnitude -0/2) 0/2)+(num-test (abs 0/3) 0/3)+(num-test (abs -0/3) 0/3)+(num-test (magnitude 0/3) 0/3)+(num-test (magnitude -0/3) 0/3)+(num-test (abs 0/10) 0/10)+(num-test (abs -0/10) 0/10)+(num-test (magnitude 0/10) 0/10)+(num-test (magnitude -0/10) 0/10)+(num-test (abs 0/1234) 0/1234)+(num-test (abs -0/1234) 0/1234)+(num-test (magnitude 0/1234) 0/1234)+(num-test (magnitude -0/1234) 0/1234)+(num-test (abs 0/1234000000) 0/1234000000)+(num-test (abs -0/1234000000) 0/1234000000)+(num-test (magnitude 0/1234000000) 0/1234000000)+(num-test (magnitude -0/1234000000) 0/1234000000)+(num-test (abs 1) 1)+(num-test (abs -1) 1)+(num-test (magnitude 1) 1)+(num-test (magnitude -1) 1)+(num-test (abs 0/362880) 0/362880)+(num-test (abs -0/362880) 0/362880)+(num-test (magnitude 0/362880) 0/362880)+(num-test (magnitude -0/362880) 0/362880)+(num-test (abs 0/500029) 0/500029)+(num-test (abs -0/500029) 0/500029)+(num-test (magnitude 0/500029) 0/500029)+(num-test (magnitude -0/500029) 0/500029)+(num-test (abs 1/1) 1/1)+(num-test (abs -1/1) 1/1)+(num-test (magnitude 1/1) 1/1)+(num-test (magnitude -1/1) 1/1)+(num-test (abs 1/2) 1/2)+(num-test (abs -1/2) 1/2)+(num-test (magnitude 1/2) 1/2)+(num-test (magnitude -1/2) 1/2)+(num-test (abs 1/3) 1/3)+(num-test (abs -1/3) 1/3)+(num-test (magnitude 1/3) 1/3)+(num-test (magnitude -1/3) 1/3)+(num-test (abs 1/10) 1/10)+(num-test (abs -1/10) 1/10)+(num-test (magnitude 1/10) 1/10)+(num-test (magnitude -1/10) 1/10)+(num-test (abs 1/1234) 1/1234)+(num-test (abs -1/1234) 1/1234)+(num-test (magnitude 1/1234) 1/1234)+(num-test (magnitude -1/1234) 1/1234)+(num-test (abs 1/1234000000) 1/1234000000)+(num-test (abs -1/1234000000) 1/1234000000)+(num-test (magnitude 1/1234000000) 1/1234000000)+(num-test (magnitude -1/1234000000) 1/1234000000)+(num-test (abs 1/500029) 1/500029)+(num-test (abs -1/500029) 1/500029)+(num-test (magnitude 1/500029) 1/500029)+(num-test (magnitude -1/500029) 1/500029)+(num-test (abs 1/362880) 1/362880)+(num-test (abs -1/362880) 1/362880)+(num-test (magnitude 1/362880) 1/362880)+(num-test (magnitude -1/362880) 1/362880)+(num-test (abs 2) 2)+(num-test (abs -2) 2)+(num-test (magnitude 2) 2)+(num-test (magnitude -2) 2)+(num-test (abs 2/1) 2/1)+(num-test (abs -2/1) 2/1)+(num-test (magnitude 2/1) 2/1)+(num-test (magnitude -2/1) 2/1)+(num-test (abs 2/2) 2/2)+(num-test (abs -2/2) 2/2)+(num-test (magnitude 2/2) 2/2)+(num-test (magnitude -2/2) 2/2)+(num-test (abs 2/3) 2/3)+(num-test (abs -2/3) 2/3)+(num-test (magnitude 2/3) 2/3)+(num-test (magnitude -2/3) 2/3)+(num-test (abs 2/10) 2/10)+(num-test (abs -2/10) 2/10)+(num-test (magnitude 2/10) 2/10)+(num-test (magnitude -2/10) 2/10)+(num-test (abs 2/1234) 2/1234)+(num-test (abs -2/1234) 2/1234)+(num-test (magnitude 2/1234) 2/1234)+(num-test (magnitude -2/1234) 2/1234)+(num-test (abs 2/1234000000) 2/1234000000)+(num-test (abs -2/1234000000) 2/1234000000)+(num-test (magnitude 2/1234000000) 2/1234000000)+(num-test (magnitude -2/1234000000) 2/1234000000)+(num-test (abs 2/500029) 2/500029)+(num-test (abs -2/500029) 2/500029)+(num-test (magnitude 2/500029) 2/500029)+(num-test (magnitude -2/500029) 2/500029)+(num-test (abs 2/362880) 2/362880)+(num-test (abs -2/362880) 2/362880)+(num-test (magnitude 2/362880) 2/362880)+(num-test (magnitude -2/362880) 2/362880)+(num-test (abs 3) 3)+(num-test (abs -3) 3)+(num-test (magnitude 3) 3)+(num-test (magnitude -3) 3)+(num-test (abs 3/1) 3/1)+(num-test (abs -3/1) 3/1)+(num-test (magnitude 3/1) 3/1)+(num-test (magnitude -3/1) 3/1)+(num-test (abs 3/2) 3/2)+(num-test (abs -3/2) 3/2)+(num-test (magnitude 3/2) 3/2)+(num-test (magnitude -3/2) 3/2)+(num-test (abs 3/3) 3/3)+(num-test (abs -3/3) 3/3)+(num-test (magnitude 3/3) 3/3)+(num-test (magnitude -3/3) 3/3)+(num-test (abs 3/10) 3/10)+(num-test (abs -3/10) 3/10)+(num-test (magnitude 3/10) 3/10)+(num-test (magnitude -3/10) 3/10)+(num-test (abs 3/1234) 3/1234)+(num-test (abs -3/1234) 3/1234)+(num-test (magnitude 3/1234) 3/1234)+(num-test (magnitude -3/1234) 3/1234)+(num-test (abs 3/1234000000) 3/1234000000)+(num-test (abs -3/1234000000) 3/1234000000)+(num-test (magnitude 3/1234000000) 3/1234000000)+(num-test (magnitude -3/1234000000) 3/1234000000)+(num-test (abs 3/500029) 3/500029)+(num-test (abs -3/500029) 3/500029)+(num-test (magnitude 3/500029) 3/500029)+(num-test (magnitude -3/500029) 3/500029)+(num-test (abs 3/362880) 3/362880)+(num-test (abs -3/362880) 3/362880)+(num-test (magnitude 3/362880) 3/362880)+(num-test (magnitude -3/362880) 3/362880)+(num-test (abs 10) 10)+(num-test (abs -10) 10)+(num-test (magnitude 10) 10)+(num-test (magnitude -10) 10)+(num-test (abs 10/1) 10/1)+(num-test (abs -10/1) 10/1)+(num-test (magnitude 10/1) 10/1)+(num-test (magnitude -10/1) 10/1)+(num-test (abs 10/2) 10/2)+(num-test (abs -10/2) 10/2)+(num-test (magnitude 10/2) 10/2)+(num-test (magnitude -10/2) 10/2)+(num-test (abs 10/3) 10/3)+(num-test (abs -10/3) 10/3)+(num-test (magnitude 10/3) 10/3)+(num-test (magnitude -10/3) 10/3)+(num-test (abs 10/10) 10/10)+(num-test (abs -10/10) 10/10)+(num-test (magnitude 10/10) 10/10)+(num-test (magnitude -10/10) 10/10)+(num-test (abs 10/1234) 10/1234)+(num-test (abs -10/1234) 10/1234)+(num-test (magnitude 10/1234) 10/1234)+(num-test (magnitude -10/1234) 10/1234)+(num-test (abs 10/1234000000) 10/1234000000)+(num-test (abs -10/1234000000) 10/1234000000)+(num-test (magnitude 10/1234000000) 10/1234000000)+(num-test (magnitude -10/1234000000) 10/1234000000)+(num-test (abs 10/500029) 10/500029)+(num-test (abs -10/500029) 10/500029)+(num-test (magnitude 10/500029) 10/500029)+(num-test (magnitude -10/500029) 10/500029)+(num-test (abs 10/362880) 10/362880)+(num-test (abs -10/362880) 10/362880)+(num-test (magnitude 10/362880) 10/362880)+(num-test (magnitude -10/362880) 10/362880)+(num-test (abs 1234) 1234)+(num-test (abs -1234) 1234)+(num-test (magnitude 1234) 1234)+(num-test (magnitude -1234) 1234)+(num-test (abs 1234/1) 1234/1)+(num-test (abs -1234/1) 1234/1)+(num-test (magnitude 1234/1) 1234/1)+(num-test (magnitude -1234/1) 1234/1)+(num-test (abs 1234/2) 1234/2)+(num-test (abs -1234/2) 1234/2)+(num-test (magnitude 1234/2) 1234/2)+(num-test (magnitude -1234/2) 1234/2)+(num-test (abs 1234/3) 1234/3)+(num-test (abs -1234/3) 1234/3)+(num-test (magnitude 1234/3) 1234/3)+(num-test (magnitude -1234/3) 1234/3)+(num-test (abs 1234/10) 1234/10)+(num-test (abs -1234/10) 1234/10)+(num-test (magnitude 1234/10) 1234/10)+(num-test (magnitude -1234/10) 1234/10)+(num-test (abs 1234/1234) 1234/1234)+(num-test (abs -1234/1234) 1234/1234)+(num-test (magnitude 1234/1234) 1234/1234)+(num-test (magnitude -1234/1234) 1234/1234)+(num-test (abs 1234/1234000000) 1234/1234000000)+(num-test (abs -1234/1234000000) 1234/1234000000)+(num-test (magnitude 1234/1234000000) 1234/1234000000)+(num-test (magnitude -1234/1234000000) 1234/1234000000)+(num-test (abs 1234/500029) 1234/500029)+(num-test (abs -1234/500029) 1234/500029)+(num-test (magnitude 1234/500029) 1234/500029)+(num-test (magnitude -1234/500029) 1234/500029)+(num-test (abs 1234/362880) 1234/362880)+(num-test (abs -1234/362880) 1234/362880)+(num-test (magnitude 1234/362880) 1234/362880)+(num-test (magnitude -1234/362880) 1234/362880)+(num-test (abs 1234000000) 1234000000)+(num-test (abs -1234000000) 1234000000)+(num-test (magnitude 1234000000) 1234000000)+(num-test (magnitude -1234000000) 1234000000)+(num-test (abs 1234000000/1) 1234000000/1)+(num-test (abs -1234000000/1) 1234000000/1)+(num-test (magnitude 1234000000/1) 1234000000/1)+(num-test (magnitude -1234000000/1) 1234000000/1)+(num-test (abs 1234000000/2) 1234000000/2)+(num-test (abs -1234000000/2) 1234000000/2)+(num-test (magnitude 1234000000/2) 1234000000/2)+(num-test (magnitude -1234000000/2) 1234000000/2)+(num-test (abs 1234000000/3) 1234000000/3)+(num-test (abs -1234000000/3) 1234000000/3)+(num-test (magnitude 1234000000/3) 1234000000/3)+(num-test (magnitude -1234000000/3) 1234000000/3)+(num-test (abs 1234000000/10) 1234000000/10)+(num-test (abs -1234000000/10) 1234000000/10)+(num-test (magnitude 1234000000/10) 1234000000/10)+(num-test (magnitude -1234000000/10) 1234000000/10)+(num-test (abs 1234000000/1234) 1234000000/1234)+(num-test (abs -1234000000/1234) 1234000000/1234)+(num-test (magnitude 1234000000/1234) 1234000000/1234)+(num-test (magnitude -1234000000/1234) 1234000000/1234)+(num-test (abs 1234000000/1234000000) 1234000000/1234000000)+(num-test (abs -1234000000/1234000000) 1234000000/1234000000)+(num-test (magnitude 1234000000/1234000000) 1234000000/1234000000)+(num-test (magnitude -1234000000/1234000000) 1234000000/1234000000)+(num-test (abs 1234000000/500029) 1234000000/500029)+(num-test (abs -1234000000/500029) 1234000000/500029)+(num-test (magnitude 1234000000/500029) 1234000000/500029)+(num-test (magnitude -1234000000/500029) 1234000000/500029)+(num-test (abs 1234000000/362880) 1234000000/362880)+(num-test (abs -1234000000/362880) 1234000000/362880)+(num-test (magnitude 1234000000/362880) 1234000000/362880)+(num-test (magnitude -1234000000/362880) 1234000000/362880)+(num-test (abs 500029) 500029)+(num-test (abs -500029) 500029)+(num-test (magnitude 500029) 500029)+(num-test (magnitude -500029) 500029)+(num-test (abs 500029/1) 500029/1)+(num-test (abs -500029/1) 500029/1)+(num-test (magnitude 500029/1) 500029/1)+(num-test (magnitude -500029/1) 500029/1)+(num-test (abs 500029/2) 500029/2)+(num-test (abs -500029/2) 500029/2)+(num-test (magnitude 500029/2) 500029/2)+(num-test (magnitude -500029/2) 500029/2)+(num-test (abs 500029/3) 500029/3)+(num-test (abs -500029/3) 500029/3)+(num-test (magnitude 500029/3) 500029/3)+(num-test (magnitude -500029/3) 500029/3)+(num-test (abs 500029/10) 500029/10)+(num-test (abs -500029/10) 500029/10)+(num-test (magnitude 500029/10) 500029/10)+(num-test (magnitude -500029/10) 500029/10)+(num-test (abs 500029/1234) 500029/1234)+(num-test (abs -500029/1234) 500029/1234)+(num-test (magnitude 500029/1234) 500029/1234)+(num-test (magnitude -500029/1234) 500029/1234)+(num-test (abs 500029/1234000000) 500029/1234000000)+(num-test (abs -500029/1234000000) 500029/1234000000)+(num-test (magnitude 500029/1234000000) 500029/1234000000)+(num-test (magnitude -500029/1234000000) 500029/1234000000)+(num-test (abs 500029/500029) 500029/500029)+(num-test (abs -500029/500029) 500029/500029)+(num-test (magnitude 500029/500029) 500029/500029)+(num-test (magnitude -500029/500029) 500029/500029)+(num-test (abs 500029/362880) 500029/362880)+(num-test (abs -500029/362880) 500029/362880)+(num-test (magnitude 500029/362880) 500029/362880)+(num-test (magnitude -500029/362880) 500029/362880)+(num-test (abs 362880) 362880)+(num-test (abs -362880) 362880)+(num-test (magnitude 362880) 362880)+(num-test (magnitude -362880) 362880)+(num-test (abs 362880/1) 362880/1)+(num-test (abs -362880/1) 362880/1)+(num-test (magnitude 362880/1) 362880/1)+(num-test (magnitude -362880/1) 362880/1)+(num-test (abs 362880/2) 362880/2)+(num-test (abs -362880/2) 362880/2)+(num-test (magnitude 362880/2) 362880/2)+(num-test (magnitude -362880/2) 362880/2)+(num-test (abs 362880/3) 362880/3)+(num-test (abs -362880/3) 362880/3)+(num-test (magnitude 362880/3) 362880/3)+(num-test (magnitude -362880/3) 362880/3)+(num-test (abs 362880/10) 362880/10)+(num-test (abs -362880/10) 362880/10)+(num-test (magnitude 362880/10) 362880/10)+(num-test (magnitude -362880/10) 362880/10)+(num-test (abs 362880/1234) 362880/1234)+(num-test (abs -362880/1234) 362880/1234)+(num-test (magnitude 362880/1234) 362880/1234)+(num-test (magnitude -362880/1234) 362880/1234)+(num-test (abs 362880/1234000000) 362880/1234000000)+(num-test (abs -362880/1234000000) 362880/1234000000)+(num-test (magnitude 362880/1234000000) 362880/1234000000)+(num-test (magnitude -362880/1234000000) 362880/1234000000)+(num-test (abs 362880/500029) 362880/500029)+(num-test (abs -362880/500029) 362880/500029)+(num-test (magnitude 362880/500029) 362880/500029)+(num-test (magnitude -362880/500029) 362880/500029)+(num-test (abs 362880/362880) 362880/362880)+(num-test (abs -362880/362880) 362880/362880)+(num-test (magnitude 362880/362880) 362880/362880)+(num-test (magnitude -362880/362880) 362880/362880)+(num-test (abs 0.0) 0.0)+(num-test (abs -0.0) 0.0)+(num-test (magnitude 0.0) 0.0)+(num-test (magnitude -0.0) 0.0)+(num-test (abs 0.00000001) 0.00000001)+(num-test (abs -0.00000001) 0.00000001)+(num-test (magnitude 0.00000001) 0.00000001)+(num-test (magnitude -0.00000001) 0.00000001)+(num-test (abs 1.0) 1.0)+(num-test (abs -1.0) 1.0)+(num-test (magnitude 1.0) 1.0)+(num-test (magnitude -1.0) 1.0)+(num-test (abs our-pi) our-pi)+(num-test (abs -3.14159265358979) our-pi)+(num-test (magnitude our-pi) our-pi)+(num-test (magnitude -3.14159265358979) our-pi)+(num-test (abs 2.71828182845905) 2.71828182845905)+(num-test (abs -2.71828182845905) 2.71828182845905)+(num-test (magnitude 2.71828182845905) 2.71828182845905)+(num-test (magnitude -2.71828182845905) 2.71828182845905)+(num-test (abs 1234.0) 1234.0)+(num-test (abs -1234.0) 1234.0)+(num-test (magnitude 1234.0) 1234.0)+(num-test (magnitude -1234.0) 1234.0)+(num-test (abs 1234000000.0) 1234000000.0)+(num-test (abs -1234000000.0) 1234000000.0)+(num-test (magnitude 1234000000.0) 1234000000.0)+(num-test (magnitude -1234000000.0) 1234000000.0)+(num-test (abs 0) 0)+(num-test (abs 2) 2)+(num-test (abs -2) 2)+(num-test (abs 10) 10)+(num-test (abs -10) 10)+(num-test (abs 1234000000) 1234000000)+(num-test (abs -1234000000) 1234000000)+(num-test (abs 362880) 362880)+(num-test (abs -362880) 362880)+(num-test (abs 0/1) 0/1)+(num-test (abs 0/1) 0/1)+(num-test (abs 2/2) 2/2)+(num-test (abs -2/2) 2/2)+(num-test (abs 10/3) 10/3)+(num-test (abs -10/3) 10/3)+(num-test (abs 1234000000/10) 1234000000/10)+(num-test (abs -1234000000/10) 1234000000/10)+(num-test (abs 362880/1234) 362880/1234)+(num-test (abs -362880/1234) 362880/1234)+(num-test (abs 0.0) 0.0)+(num-test (abs -0.0) 0.0)+(num-test (abs 1.0) 1.0)+(num-test (abs -1.0) 1.0)+(num-test (abs 2.71828182845905) 2.71828182845905)+(num-test (abs -2.71828182845905) 2.71828182845905)+(num-test (abs 1234000000.0) 1234000000.0)+(num-test (abs -1234000000.0) 1234000000.0)+(num-test (abs 6) 6)+(num-test (abs -6) 6)+(num-test (abs -123456789) 123456789)+(num-test (abs -1234567890) 1234567890)+(num-test (abs -7) 7)+(num-test (abs 7) 7)+(num-test (abs 0) 0)+(num-test (magnitude 0.0+0.00000001i) 0.00000001)+(num-test (magnitude 0.0e+00+0.0e+00i) 0e0+0.0i)+(num-test (magnitude 0.0e+00+1.19209289550781250e-07i) 1.1920928955078125e-7+0.0i)+(num-test (magnitude 0.0e+00-1.19209289550781250e-07i) 1.1920928955078125e-7+0.0i)+(num-test (magnitude 0.0e+00+5.0e-01i) 5e-1+0.0i)+(num-test (magnitude 0.0e+00-5.0e-01i) 5e-1+0.0i)+(num-test (magnitude 0.0e+00+1.0e+00i) 1e0+0.0i)+(num-test (magnitude 0.0e+00-1.0e+00i) 1e0+0.0i)+(num-test (magnitude 0.0e+00+2.0e+00i) 2e0+0.0i)+(num-test (magnitude 0.0e+00-2.0e+00i) 2e0+0.0i)+(num-test (magnitude 0.0e+00+8.3886080e+06i) 8.388608e6+0.0i)+(num-test (magnitude 0.0e+00-8.3886080e+06i) 8.388608e6+0.0i)+(num-test (magnitude 1.19209289550781250e-07+0.0e+00i) 1.1920928955078125e-7+0.0i)+(num-test (magnitude -1.19209289550781250e-07+0.0e+00i) 1.1920928955078125e-7+0.0i)+(num-test (magnitude 1.19209289550781250e-07+1.19209289550781250e-07i) 1.6858739404357612715e-7+0.0i)+(num-test (magnitude 1.19209289550781250e-07-1.19209289550781250e-07i) 1.6858739404357612715e-7+0.0i)+(num-test (magnitude -1.19209289550781250e-07+1.19209289550781250e-07i) 1.6858739404357612715e-7+0.0i)+(num-test (magnitude -1.19209289550781250e-07-1.19209289550781250e-07i) 1.6858739404357612715e-7+0.0i)+(num-test (magnitude 1.19209289550781250e-07+5.0e-01i) 5.0000000000001421085e-1+0.0i)+(num-test (magnitude 1.19209289550781250e-07-5.0e-01i) 5.0000000000001421085e-1+0.0i)+(num-test (magnitude -1.19209289550781250e-07+5.0e-01i) 5.0000000000001421085e-1+0.0i)+(num-test (magnitude -1.19209289550781250e-07-5.0e-01i) 5.0000000000001421085e-1+0.0i)+(num-test (magnitude 1.19209289550781250e-07+1.0e+00i) 1.0000000000000071054e0+0.0i)+(num-test (magnitude 1.19209289550781250e-07-1.0e+00i) 1.0000000000000071054e0+0.0i)+(num-test (magnitude -1.19209289550781250e-07+1.0e+00i) 1.0000000000000071054e0+0.0i)+(num-test (magnitude -1.19209289550781250e-07-1.0e+00i) 1.0000000000000071054e0+0.0i)+(num-test (magnitude 1.19209289550781250e-07+2.0e+00i) 2.0000000000000035527e0+0.0i)+(num-test (magnitude 1.19209289550781250e-07-2.0e+00i) 2.0000000000000035527e0+0.0i)+(num-test (magnitude -1.19209289550781250e-07+2.0e+00i) 2.0000000000000035527e0+0.0i)+(num-test (magnitude -1.19209289550781250e-07-2.0e+00i) 2.0000000000000035527e0+0.0i)+(num-test (magnitude 1.19209289550781250e-07+8.3886080e+06i) 8.3886080e6+0.0i)+(num-test (magnitude 1.19209289550781250e-07-8.3886080e+06i) 8.3886080e6+0.0i)+(num-test (magnitude -1.19209289550781250e-07+8.3886080e+06i) 8.3886080e6+0.0i)+(num-test (magnitude -1.19209289550781250e-07-8.3886080e+06i) 8.3886080e6+0.0i)+(num-test (magnitude 5.0e-01+0.0e+00i) 5e-1+0.0i)+(num-test (magnitude -5.0e-01+0.0e+00i) 5e-1+0.0i)+(num-test (magnitude 5.0e-01+1.19209289550781250e-07i) 5.0000000000001421085e-1+0.0i)+(num-test (magnitude 5.0e-01-1.19209289550781250e-07i) 5.0000000000001421085e-1+0.0i)+(num-test (magnitude -5.0e-01+1.19209289550781250e-07i) 5.0000000000001421085e-1+0.0i)+(num-test (magnitude -5.0e-01-1.19209289550781250e-07i) 5.0000000000001421085e-1+0.0i)+(num-test (magnitude 5.0e-01+5.0e-01i) 7.0710678118654752440e-1+0.0i)+(num-test (magnitude 5.0e-01-5.0e-01i) 7.0710678118654752440e-1+0.0i)+(num-test (magnitude -5.0e-01+5.0e-01i) 7.0710678118654752440e-1+0.0i)+(num-test (magnitude -5.0e-01-5.0e-01i) 7.0710678118654752440e-1+0.0i)+(num-test (magnitude 5.0e-01+1.0e+00i) 1.1180339887498948482e0+0.0i)+(num-test (magnitude 5.0e-01-1.0e+00i) 1.1180339887498948482e0+0.0i)+(num-test (magnitude -5.0e-01+1.0e+00i) 1.1180339887498948482e0+0.0i)+(num-test (magnitude -5.0e-01-1.0e+00i) 1.1180339887498948482e0+0.0i)+(num-test (magnitude 5.0e-01+2.0e+00i) 2.0615528128088302749e0+0.0i)+(num-test (magnitude 5.0e-01-2.0e+00i) 2.0615528128088302749e0+0.0i)+(num-test (magnitude -5.0e-01+2.0e+00i) 2.0615528128088302749e0+0.0i)+(num-test (magnitude -5.0e-01-2.0e+00i) 2.0615528128088302749e0+0.0i)+(num-test (magnitude 5.0e-01+8.3886080e+06i) 8.3886080000000149012e6+0.0i)+(num-test (magnitude 5.0e-01-8.3886080e+06i) 8.3886080000000149012e6+0.0i)+(num-test (magnitude -5.0e-01+8.3886080e+06i) 8.3886080000000149012e6+0.0i)+(num-test (magnitude -5.0e-01-8.3886080e+06i) 8.3886080000000149012e6+0.0i)+(num-test (magnitude 1.0e+00+0.0e+00i) 1e0+0.0i)+(num-test (magnitude -1.0e+00+0.0e+00i) 1e0+0.0i)+(num-test (magnitude 1.0e+00+1.19209289550781250e-07i) 1.0000000000000071054e0+0.0i)+(num-test (magnitude 1.0e+00-1.19209289550781250e-07i) 1.0000000000000071054e0+0.0i)+(num-test (magnitude -1.0e+00+1.19209289550781250e-07i) 1.0000000000000071054e0+0.0i)+(num-test (magnitude -1.0e+00-1.19209289550781250e-07i) 1.0000000000000071054e0+0.0i)+(num-test (magnitude 1.0e+00+5.0e-01i) 1.1180339887498948482e0+0.0i)+(num-test (magnitude 1.0e+00-5.0e-01i) 1.1180339887498948482e0+0.0i)+(num-test (magnitude -1.0e+00+5.0e-01i) 1.1180339887498948482e0+0.0i)+(num-test (magnitude -1.0e+00-5.0e-01i) 1.1180339887498948482e0+0.0i)+(num-test (magnitude 1.0e+00+1.0e+00i) 1.4142135623730950488e0+0.0i)+(num-test (magnitude 1.0e+00-1.0e+00i) 1.4142135623730950488e0+0.0i)+(num-test (magnitude -1.0e+00+1.0e+00i) 1.4142135623730950488e0+0.0i)+(num-test (magnitude -1.0e+00-1.0e+00i) 1.4142135623730950488e0+0.0i)+(num-test (magnitude 1.0e+00+2.0e+00i) 2.2360679774997896964e0+0.0i)+(num-test (magnitude 1.0e+00-2.0e+00i) 2.2360679774997896964e0+0.0i)+(num-test (magnitude -1.0e+00+2.0e+00i) 2.2360679774997896964e0+0.0i)+(num-test (magnitude -1.0e+00-2.0e+00i) 2.2360679774997896964e0+0.0i)+(num-test (magnitude 1.0e+00+8.3886080e+06i) 8.3886080000000596046e6+0.0i)+(num-test (magnitude 1.0e+00-8.3886080e+06i) 8.3886080000000596046e6+0.0i)+(num-test (magnitude -1.0e+00+8.3886080e+06i) 8.3886080000000596046e6+0.0i)+(num-test (magnitude -1.0e+00-8.3886080e+06i) 8.3886080000000596046e6+0.0i)+(num-test (magnitude 2.0e+00+0.0e+00i) 2e0+0.0i)+(num-test (magnitude -2.0e+00+0.0e+00i) 2e0+0.0i)+(num-test (magnitude 2.0e+00+1.19209289550781250e-07i) 2.0000000000000035527e0+0.0i)+(num-test (magnitude 2.0e+00-1.19209289550781250e-07i) 2.0000000000000035527e0+0.0i)+(num-test (magnitude -2.0e+00+1.19209289550781250e-07i) 2.0000000000000035527e0+0.0i)+(num-test (magnitude -2.0e+00-1.19209289550781250e-07i) 2.0000000000000035527e0+0.0i)+(num-test (magnitude 2.0e+00+5.0e-01i) 2.0615528128088302749e0+0.0i)+(num-test (magnitude 2.0e+00-5.0e-01i) 2.0615528128088302749e0+0.0i)+(num-test (magnitude -2.0e+00+5.0e-01i) 2.0615528128088302749e0+0.0i)+(num-test (magnitude -2.0e+00-5.0e-01i) 2.0615528128088302749e0+0.0i)+(num-test (magnitude 2.0e+00+1.0e+00i) 2.2360679774997896964e0+0.0i)+(num-test (magnitude 2.0e+00-1.0e+00i) 2.2360679774997896964e0+0.0i)+(num-test (magnitude -2.0e+00+1.0e+00i) 2.2360679774997896964e0+0.0i)+(num-test (magnitude -2.0e+00-1.0e+00i) 2.2360679774997896964e0+0.0i)+(num-test (magnitude 2.0e+00+2.0e+00i) 2.8284271247461900976e0+0.0i)+(num-test (magnitude 2.0e+00-2.0e+00i) 2.8284271247461900976e0+0.0i)+(num-test (magnitude -2.0e+00+2.0e+00i) 2.8284271247461900976e0+0.0i)+(num-test (magnitude -2.0e+00-2.0e+00i) 2.8284271247461900976e0+0.0i)+(num-test (magnitude 2.0e+00+8.3886080e+06i) 8.3886080000002384186e6+0.0i)+(num-test (magnitude 2.0e+00-8.3886080e+06i) 8.3886080000002384186e6+0.0i)+(num-test (magnitude -2.0e+00+8.3886080e+06i) 8.3886080000002384186e6+0.0i)+(num-test (magnitude -2.0e+00-8.3886080e+06i) 8.3886080000002384186e6+0.0i)+(num-test (magnitude 8.3886080e+06+0.0e+00i) 8.388608e6+0.0i)+(num-test (magnitude -8.3886080e+06+0.0e+00i) 8.388608e6+0.0i)+(num-test (magnitude 8.3886080e+06+1.19209289550781250e-07i) 8.3886080e6+0.0i)+(num-test (magnitude 8.3886080e+06-1.19209289550781250e-07i) 8.3886080e6+0.0i)+(num-test (magnitude -8.3886080e+06+1.19209289550781250e-07i) 8.3886080e6+0.0i)+(num-test (magnitude -8.3886080e+06-1.19209289550781250e-07i) 8.3886080e6+0.0i)+(num-test (magnitude 8.3886080e+06+5.0e-01i) 8.3886080000000149012e6+0.0i)+(num-test (magnitude 8.3886080e+06-5.0e-01i) 8.3886080000000149012e6+0.0i)+(num-test (magnitude -8.3886080e+06+5.0e-01i) 8.3886080000000149012e6+0.0i)+(num-test (magnitude -8.3886080e+06-5.0e-01i) 8.3886080000000149012e6+0.0i)+(num-test (magnitude 8.3886080e+06+1.0e+00i) 8.3886080000000596046e6+0.0i)+(num-test (magnitude 8.3886080e+06-1.0e+00i) 8.3886080000000596046e6+0.0i)+(num-test (magnitude -8.3886080e+06+1.0e+00i) 8.3886080000000596046e6+0.0i)+(num-test (magnitude -8.3886080e+06-1.0e+00i) 8.3886080000000596046e6+0.0i)+(num-test (magnitude 8.3886080e+06+2.0e+00i) 8.3886080000002384186e6+0.0i)+(num-test (magnitude 8.3886080e+06-2.0e+00i) 8.3886080000002384186e6+0.0i)+(num-test (magnitude -8.3886080e+06+2.0e+00i) 8.3886080000002384186e6+0.0i)+(num-test (magnitude -8.3886080e+06-2.0e+00i) 8.3886080000002384186e6+0.0i)+(num-test (magnitude 8.3886080e+06+8.3886080e+06i) 1.1863283203031444111e7+0.0i)+(num-test (magnitude 8.3886080e+06-8.3886080e+06i) 1.1863283203031444111e7+0.0i)+(num-test (magnitude -8.3886080e+06+8.3886080e+06i) 1.1863283203031444111e7+0.0i)+(num-test (magnitude -8.3886080e+06-8.3886080e+06i) 1.1863283203031444111e7+0.0i)+(num-test (magnitude 0.0-0.00000001i) 0.00000001)+(num-test (magnitude -0.0+0.00000001i) 0.00000001)+(num-test (magnitude -0.0-0.00000001i) 0.00000001)+(num-test (magnitude 0.0+1.0i) 1.0)+(num-test (magnitude -0.0+1.0i) 1.0)+(num-test (magnitude 0.0-1.0i) 1.0)+(num-test (magnitude -0.0-1.0i) 1.0)+(num-test (magnitude 0.0+3.14159265358979i) 3.14159265358979)+(num-test (magnitude -0.0+3.14159265358979i) 3.14159265358979)+(num-test (magnitude 0.0-3.14159265358979i) 3.14159265358979)+(num-test (magnitude -0.0-3.14159265358979i) 3.14159265358979)+(num-test (magnitude 0.0+2.71828182845905i) 2.71828182845905)+(num-test (magnitude -0.0+2.71828182845905i) 2.71828182845905)+(num-test (magnitude 0.0-2.71828182845905i) 2.71828182845905)+(num-test (magnitude -0.0-2.71828182845905i) 2.71828182845905)+(num-test (magnitude 0.0+1234.0i) 1234.0)+(num-test (magnitude -0.0+1234.0i) 1234.0)+(num-test (magnitude 0.0-1234.0i) 1234.0)+(num-test (magnitude -0.0-1234.0i) 1234.0)+(num-test (magnitude 0.0+1234000000.0i) 1234000000.0)+(num-test (magnitude -0.0+1234000000.0i) 1234000000.0)+(num-test (magnitude 0.0-1234000000.0i) 1234000000.0)+(num-test (magnitude -0.0-1234000000.0i) 1234000000.0)+(num-test (magnitude 0.00000001+0.00000001i) 0.00000001414214)+(num-test (magnitude -0.00000001+0.00000001i) 0.00000001414214)+(num-test (magnitude 0.00000001-0.00000001i) 0.00000001414214)+(num-test (magnitude -0.00000001-0.00000001i) 0.00000001414214)+(num-test (magnitude 0.00000001+1.0i) 1.0)+(num-test (magnitude -0.00000001+1.0i) 1.0)+(num-test (magnitude 0.00000001-1.0i) 1.0)+(num-test (magnitude -0.00000001-1.0i) 1.0)+(num-test (magnitude 0.00000001+3.14159265358979i) our-pi)+(num-test (magnitude -0.00000001+3.14159265358979i) our-pi)+(num-test (magnitude 0.00000001-3.14159265358979i) our-pi)+(num-test (magnitude -0.00000001-3.14159265358979i) our-pi)+(num-test (magnitude 0.00000001+2.71828182845905i) 2.71828182845905)+(num-test (magnitude -0.00000001+2.71828182845905i) 2.71828182845905)+(num-test (magnitude 0.00000001-2.71828182845905i) 2.71828182845905)+(num-test (magnitude -0.00000001-2.71828182845905i) 2.71828182845905)+(num-test (magnitude 0.00000001+1234.0i) 1234.0)+(num-test (magnitude -0.00000001+1234.0i) 1234.0)+(num-test (magnitude 0.00000001-1234.0i) 1234.0)+(num-test (magnitude -0.00000001-1234.0i) 1234.0)+(num-test (magnitude 0.00000001+1234000000.0i) 1234000000.0)+(num-test (magnitude -0.00000001+1234000000.0i) 1234000000.0)+(num-test (magnitude 0.00000001-1234000000.0i) 1234000000.0)+(num-test (magnitude -0.00000001-1234000000.0i) 1234000000.0)+(num-test (magnitude 1.0+0.00000001i) 1.0)+(num-test (magnitude -1.0+0.00000001i) 1.0)+(num-test (magnitude 1.0-0.00000001i) 1.0)+(num-test (magnitude -1.0-0.00000001i) 1.0)+(num-test (magnitude 1.0+1.0i) 1.41421356237310)+(num-test (magnitude -1.0+1.0i) 1.41421356237310)+(num-test (magnitude 1.0-1.0i) 1.41421356237310)+(num-test (magnitude -1.0-1.0i) 1.41421356237310)+(num-test (magnitude 1.0+3.14159265358979i) 3.29690830947562)+(num-test (magnitude -1.0+3.14159265358979i) 3.29690830947562)+(num-test (magnitude 1.0-3.14159265358979i) 3.29690830947562)+(num-test (magnitude -1.0-3.14159265358979i) 3.29690830947562)+(num-test (magnitude 1.0+2.71828182845905i) 2.89638673159001)+(num-test (magnitude -1.0+2.71828182845905i) 2.89638673159001)+(num-test (magnitude 1.0-2.71828182845905i) 2.89638673159001)+(num-test (magnitude -1.0-2.71828182845905i) 2.89638673159001)+(num-test (magnitude 1.0+1234.0i) 1234.00040518631931)+(num-test (magnitude -1.0+1234.0i) 1234.00040518631931)+(num-test (magnitude 1.0-1234.0i) 1234.00040518631931)+(num-test (magnitude -1.0-1234.0i) 1234.00040518631931)+(num-test (magnitude 1.0+1234000000.0i) 1234000000.0)+(num-test (magnitude -1.0+1234000000.0i) 1234000000.0)+(num-test (magnitude 1.0-1234000000.0i) 1234000000.0)+(num-test (magnitude -1.0-1234000000.0i) 1234000000.0)+(num-test (magnitude 3.14159265358979+0.00000001i) our-pi)+(num-test (magnitude -3.14159265358979+0.00000001i) our-pi)+(num-test (magnitude 3.14159265358979-0.00000001i) our-pi)+(num-test (magnitude -3.14159265358979-0.00000001i) our-pi)+(num-test (magnitude 3.14159265358979+1.0i) 3.29690830947562)+(num-test (magnitude -3.14159265358979+1.0i) 3.29690830947562)+(num-test (magnitude 3.14159265358979-1.0i) 3.29690830947562)+(num-test (magnitude -3.14159265358979-1.0i) 3.29690830947562)+(num-test (magnitude 3.14159265358979+3.14159265358979i) 4.44288293815837)+(num-test (magnitude -3.14159265358979+3.14159265358979i) 4.44288293815837)+(num-test (magnitude 3.14159265358979-3.14159265358979i) 4.44288293815837)+(num-test (magnitude -3.14159265358979-3.14159265358979i) 4.44288293815837)+(num-test (magnitude 3.14159265358979+2.71828182845905i) 4.15435440231331)+(num-test (magnitude -3.14159265358979+2.71828182845905i) 4.15435440231331)+(num-test (magnitude 3.14159265358979-2.71828182845905i) 4.15435440231331)+(num-test (magnitude -3.14159265358979-2.71828182845905i) 4.15435440231331)+(num-test (magnitude 3.14159265358979+1234.0i) 1234.00399902285608)+(num-test (magnitude -3.14159265358979+1234.0i) 1234.00399902285608)+(num-test (magnitude 3.14159265358979-1234.0i) 1234.00399902285608)+(num-test (magnitude -3.14159265358979-1234.0i) 1234.00399902285608)+(num-test (magnitude 3.14159265358979+1234000000.0i) 1234000000.0)+(num-test (magnitude -3.14159265358979+1234000000.0i) 1234000000.0)+(num-test (magnitude 3.14159265358979-1234000000.0i) 1234000000.0)+(num-test (magnitude -3.14159265358979-1234000000.0i) 1234000000.0)+(num-test (magnitude 2.71828182845905+0.00000001i) 2.71828182845905)+(num-test (magnitude -2.71828182845905+0.00000001i) 2.71828182845905)+(num-test (magnitude 2.71828182845905-0.00000001i) 2.71828182845905)+(num-test (magnitude -2.71828182845905-0.00000001i) 2.71828182845905)+(num-test (magnitude 2.71828182845905+1.0i) 2.89638673159001)+(num-test (magnitude -2.71828182845905+1.0i) 2.89638673159001)+(num-test (magnitude 2.71828182845905-1.0i) 2.89638673159001)+(num-test (magnitude -2.71828182845905-1.0i) 2.89638673159001)+(num-test (magnitude 2.71828182845905+3.14159265358979i) 4.15435440231331)+(num-test (magnitude -2.71828182845905+3.14159265358979i) 4.15435440231331)+(num-test (magnitude 2.71828182845905-3.14159265358979i) 4.15435440231331)+(num-test (magnitude -2.71828182845905-3.14159265358979i) 4.15435440231331)+(num-test (magnitude 2.71828182845905+2.71828182845905i) 3.84423102815912)+(num-test (magnitude -2.71828182845905+2.71828182845905i) 3.84423102815912)+(num-test (magnitude 2.71828182845905-2.71828182845905i) 3.84423102815912)+(num-test (magnitude -2.71828182845905-2.71828182845905i) 3.84423102815912)+(num-test (magnitude 2.71828182845905+1234.0i) 1234.00299394130275)+(num-test (magnitude -2.71828182845905+1234.0i) 1234.00299394130275)+(num-test (magnitude 2.71828182845905-1234.0i) 1234.00299394130275)+(num-test (magnitude -2.71828182845905-1234.0i) 1234.00299394130275)+(num-test (magnitude 2.71828182845905+1234000000.0i) 1234000000.0)+(num-test (magnitude -2.71828182845905+1234000000.0i) 1234000000.0)+(num-test (magnitude 2.71828182845905-1234000000.0i) 1234000000.0)+(num-test (magnitude -2.71828182845905-1234000000.0i) 1234000000.0)+(num-test (magnitude 1234.0+0.00000001i) 1234.0)+(num-test (magnitude -1234.0+0.00000001i) 1234.0)+(num-test (magnitude 1234.0-0.00000001i) 1234.0)+(num-test (magnitude -1234.0-0.00000001i) 1234.0)+(num-test (magnitude 1234.0+1.0i) 1234.00040518631931)+(num-test (magnitude -1234.0+1.0i) 1234.00040518631931)+(num-test (magnitude 1234.0-1.0i) 1234.00040518631931)+(num-test (magnitude -1234.0-1.0i) 1234.00040518631931)+(num-test (magnitude 1234.0+3.14159265358979i) 1234.00399902285608)+(num-test (magnitude -1234.0+3.14159265358979i) 1234.00399902285608)+(num-test (magnitude 1234.0-3.14159265358979i) 1234.00399902285608)+(num-test (magnitude -1234.0-3.14159265358979i) 1234.00399902285608)+(num-test (magnitude 1234.0+2.71828182845905i) 1234.00299394130275)+(num-test (magnitude -1234.0+2.71828182845905i) 1234.00299394130275)+(num-test (magnitude 1234.0-2.71828182845905i) 1234.00299394130275)+(num-test (magnitude -1234.0-2.71828182845905i) 1234.00299394130275)+(num-test (magnitude 1234.0+1234.0i) 1745.13953596839929)+(num-test (magnitude -1234.0+1234.0i) 1745.13953596839929)+(num-test (magnitude 1234.0-1234.0i) 1745.13953596839929)+(num-test (magnitude -1234.0-1234.0i) 1745.13953596839929)+(num-test (magnitude 1234.0+1234000000.0i) 1234000000.00061702728271)+(num-test (magnitude -1234.0+1234000000.0i) 1234000000.00061702728271)+(num-test (magnitude 1234.0-1234000000.0i) 1234000000.00061702728271)+(num-test (magnitude -1234.0-1234000000.0i) 1234000000.00061702728271)+(num-test (magnitude 1234000000.0+0.00000001i) 1234000000.0)+(num-test (magnitude -1234000000.0+0.00000001i) 1234000000.0)+(num-test (magnitude 1234000000.0-0.00000001i) 1234000000.0)+(num-test (magnitude -1234000000.0-0.00000001i) 1234000000.0)+(num-test (magnitude 1234000000.0+1.0i) 1234000000.0)+(num-test (magnitude -1234000000.0+1.0i) 1234000000.0)+(num-test (magnitude 1234000000.0-1.0i) 1234000000.0)+(num-test (magnitude -1234000000.0-1.0i) 1234000000.0)+(num-test (magnitude 1234000000.0+3.14159265358979i) 1234000000.0)+(num-test (magnitude -1234000000.0+3.14159265358979i) 1234000000.0)+(num-test (magnitude 1234000000.0-3.14159265358979i) 1234000000.0)+(num-test (magnitude -1234000000.0-3.14159265358979i) 1234000000.0)+(num-test (magnitude 1234000000.0+2.71828182845905i) 1234000000.0)+(num-test (magnitude -1234000000.0+2.71828182845905i) 1234000000.0)+(num-test (magnitude 1234000000.0-2.71828182845905i) 1234000000.0)+(num-test (magnitude -1234000000.0-2.71828182845905i) 1234000000.0)+(num-test (magnitude 1234000000.0+1234.0i) 1234000000.00061702728271)+(num-test (magnitude -1234000000.0+1234.0i) 1234000000.00061702728271)+(num-test (magnitude 1234000000.0-1234.0i) 1234000000.00061702728271)+(num-test (magnitude -1234000000.0-1234.0i) 1234000000.00061702728271)+(num-test (magnitude 1234000000.0+1234000000.0i) 1745139535.96839928627014)+(num-test (magnitude -1234000000.0+1234000000.0i) 1745139535.96839928627014)+(num-test (magnitude 1234000000.0-1234000000.0i) 1745139535.96839928627014)+(num-test (magnitude -1234000000.0-1234000000.0i) 1745139535.96839928627014)+(num-test (magnitude 0.0+0.00000001i) 0.00000001)+(num-test (magnitude -0.0+0.00000001i) 0.00000001)+(num-test (magnitude 1.0+1.0i) 1.41421356237310)+(num-test (magnitude -1.0+1.0i) 1.41421356237310)+(num-test (magnitude 2.71828182845905+3.14159265358979i) 4.15435440231331)+(num-test (magnitude -2.71828182845905+3.14159265358979i) 4.15435440231331)+(num-test (magnitude 1234000000.0+2.71828182845905i) 1234000000.0)+(num-test (magnitude -1234000000.0+2.71828182845905i) 1234000000.0)+(num-test (magnitude 0) 0)+++;; -------- make-polar and make-rectangular++(num-test (make-rectangular 0 1) 0.0+1.0i)+(num-test (make-rectangular -0 1) -0.0+1.0i)+(num-test (make-rectangular 0 -1) 0.0-1.0i)+(num-test (make-rectangular -0 -1) -0.0-1.0i)+(num-test (make-polar 0 1) 0.0)+(num-test (make-polar -0 1) -0.0)+(num-test (make-polar 0 -1) 0.0)+(num-test (make-polar -0 -1) 0.0)+(num-test (make-rectangular 0 2) 0.0+2.0i)+(num-test (make-rectangular -0 2) -0.0+2.0i)+(num-test (make-rectangular 0 -2) 0.0-2.0i)+(num-test (make-rectangular -0 -2) -0.0-2.0i)+(num-test (make-polar 0 2) -0.0)+(num-test (make-polar -0 2) 0.0)+(num-test (make-polar 0 -2) 0.0)+(num-test (make-polar -0 -2) 0.0)+(num-test (make-rectangular 0 3) 0.0+3.0i)+(num-test (make-rectangular -0 3) -0.0+3.0i)+(num-test (make-rectangular 0 -3) 0.0-3.0i)+(num-test (make-rectangular -0 -3) -0.0-3.0i)+(num-test (make-polar 0 3) -0.0)+(num-test (make-polar -0 3) 0.0)+(num-test (make-polar 0 -3) 0.0)+(num-test (make-polar -0 -3) 0.0)+(num-test (make-rectangular 0 10) 0.0+10.0i)+(num-test (make-rectangular -0 10) -0.0+10.0i)+(num-test (make-rectangular 0 -10) 0.0-10.0i)+(num-test (make-rectangular -0 -10) -0.0-10.0i)+(num-test (make-polar 0 10) 0.0)+(num-test (make-polar -0 10) 0.0)+(num-test (make-polar 0 -10) -0.0)+(num-test (make-polar -0 -10) 0.0)+(num-test (make-rectangular 0 1234) 0.0+1234.0i)+(num-test (make-rectangular -0 1234) -0.0+1234.0i)+(num-test (make-rectangular 0 -1234) 0.0-1234.0i)+(num-test (make-rectangular -0 -1234) -0.0-1234.0i)+(num-test (make-polar 0 1234) -0.0)+(num-test (make-polar -0 1234) 0.0)+(num-test (make-polar 0 -1234) 0.0)+(num-test (make-polar -0 -1234) 0.0)+(num-test (make-rectangular 0 1234000000) 0.0+1234000000.0i)+(num-test (make-rectangular -0 1234000000) -0.0+1234000000.0i)+(num-test (make-rectangular 0 -1234000000) 0.0-1234000000.0i)+(num-test (make-rectangular -0 -1234000000) -0.0-1234000000.0i)+(num-test (make-polar 0 1234000000) 0.0)+(num-test (make-polar -0 1234000000) 0.0)+(num-test (make-polar 0 -1234000000) 0.0)+(num-test (make-polar -0 -1234000000) -0.0)+(num-test (make-rectangular 0 500029) 0.0+500029.0i)+(num-test (make-rectangular -0 500029) -0.0+500029.0i)+(num-test (make-rectangular 0 -500029) 0.0-500029.0i)+(num-test (make-rectangular -0 -500029) -0.0-500029.0i)+(num-test (make-polar 0 500029) 0.0)+(num-test (make-polar -0 500029) -0.0)+(num-test (make-polar 0 -500029) 0.0)+(num-test (make-polar -0 -500029) 0.0)+(num-test (make-rectangular 0 362880) 0.0+362880.0i)+(num-test (make-rectangular -0 362880) -0.0+362880.0i)+(num-test (make-rectangular 0 -362880) 0.0-362880.0i)+(num-test (make-rectangular -0 -362880) -0.0-362880.0i)+(num-test (make-polar 0 362880) 0.0)+(num-test (make-polar -0 362880) -0.0)+(num-test (make-polar 0 -362880) 0.0)+(num-test (make-polar -0 -362880) 0.0)+(num-test (make-rectangular 1 1) 1.0+1.0i)+(num-test (make-rectangular -1 1) -1.0+1.0i)+(num-test (make-rectangular 1 -1) 1.0-1.0i)+(num-test (make-rectangular -1 -1) -1.0-1.0i)+(num-test (make-polar 1 1) 0.54030230586814+0.84147098480790i)+(num-test (make-polar -1 1) -0.54030230586814-0.84147098480790i)+(num-test (make-polar 1 -1) 0.54030230586814-0.84147098480790i)+(num-test (make-polar -1 -1) -0.54030230586814+0.84147098480790i)+(num-test (make-rectangular 1 2) 1.0+2.0i)+(num-test (make-rectangular -1 2) -1.0+2.0i)+(num-test (make-rectangular 1 -2) 1.0-2.0i)+(num-test (make-rectangular -1 -2) -1.0-2.0i)+(num-test (make-polar 1 2) -0.41614683654714+0.90929742682568i)+(num-test (make-polar -1 2) 0.41614683654714-0.90929742682568i)+(num-test (make-polar 1 -2) -0.41614683654714-0.90929742682568i)+(num-test (make-polar -1 -2) 0.41614683654714+0.90929742682568i)+(num-test (make-rectangular 1 3) 1.0+3.0i)+(num-test (make-rectangular -1 3) -1.0+3.0i)+(num-test (make-rectangular 1 -3) 1.0-3.0i)+(num-test (make-rectangular -1 -3) -1.0-3.0i)+(num-test (make-polar 1 3) -0.98999249660045+0.14112000805987i)+(num-test (make-polar -1 3) 0.98999249660045-0.14112000805987i)+(num-test (make-polar 1 -3) -0.98999249660045-0.14112000805987i)+(num-test (make-polar -1 -3) 0.98999249660045+0.14112000805987i)+(num-test (make-rectangular 1 10) 1.0+10.0i)+(num-test (make-rectangular -1 10) -1.0+10.0i)+(num-test (make-rectangular 1 -10) 1.0-10.0i)+(num-test (make-rectangular -1 -10) -1.0-10.0i)+(num-test (make-polar 1 10) -0.83907152907645-0.54402111088937i)+(num-test (make-polar -1 10) 0.83907152907645+0.54402111088937i)+(num-test (make-polar 1 -10) -0.83907152907645+0.54402111088937i)+(num-test (make-polar -1 -10) 0.83907152907645-0.54402111088937i)+(num-test (make-rectangular 1 1234) 1.0+1234.0i)+(num-test (make-rectangular -1 1234) -1.0+1234.0i)+(num-test (make-rectangular 1 -1234) 1.0-1234.0i)+(num-test (make-rectangular -1 -1234) -1.0-1234.0i)+(num-test (make-polar 1 1234) -0.79855062358758+0.60192765476250i)+(num-test (make-polar -1 1234) 0.79855062358758-0.60192765476250i)+(num-test (make-polar 1 -1234) -0.79855062358758-0.60192765476250i)+(num-test (make-polar -1 -1234) 0.79855062358758+0.60192765476250i)+(num-test (make-rectangular 1 1234000000) 1.0+1234000000.0i)+(num-test (make-rectangular -1 1234000000) -1.0+1234000000.0i)+(num-test (make-rectangular 1 -1234000000) 1.0-1234000000.0i)+(num-test (make-rectangular -1 -1234000000) -1.0-1234000000.0i)+(num-test (make-polar 1 1234000000) 0.15890913095152-0.98729321283003i)+(num-test (make-polar -1 1234000000) -0.15890913095152+0.98729321283003i)+(num-test (make-polar 1 -1234000000) 0.15890913095152+0.98729321283003i)+(num-test (make-polar -1 -1234000000) -0.15890913095152-0.98729321283003i)+(num-test (make-rectangular 1 500029) 1.0+500029.0i)+(num-test (make-rectangular -1 500029) -1.0+500029.0i)+(num-test (make-rectangular 1 -500029) 1.0-500029.0i)+(num-test (make-rectangular -1 -500029) -1.0-500029.0i)+(num-test (make-polar 1 500029) 0.85414905629947+0.52002825848479i)+(num-test (make-polar -1 500029) -0.85414905629947-0.52002825848479i)+(num-test (make-polar 1 -500029) 0.85414905629947-0.52002825848479i)+(num-test (make-polar -1 -500029) -0.85414905629947+0.52002825848479i)+(num-test (make-rectangular 1 362880) 1.0+362880.0i)+(num-test (make-rectangular -1 362880) -1.0+362880.0i)+(num-test (make-rectangular 1 -362880) 1.0-362880.0i)+(num-test (make-rectangular -1 -362880) -1.0-362880.0i)+(num-test (make-polar 1 362880) 0.60918079547638+0.79303137291204i)+(num-test (make-polar -1 362880) -0.60918079547638-0.79303137291204i)+(num-test (make-polar 1 -362880) 0.60918079547638-0.79303137291204i)+(num-test (make-polar -1 -362880) -0.60918079547638+0.79303137291204i)+(num-test (make-rectangular 2 1) 2.0+1.0i)+(num-test (make-rectangular -2 1) -2.0+1.0i)+(num-test (make-rectangular 2 -1) 2.0-1.0i)+(num-test (make-rectangular -2 -1) -2.0-1.0i)+(num-test (make-polar 2 1) 1.08060461173628+1.68294196961579i)+(num-test (make-polar -2 1) -1.08060461173628-1.68294196961579i)+(num-test (make-polar 2 -1) 1.08060461173628-1.68294196961579i)+(num-test (make-polar -2 -1) -1.08060461173628+1.68294196961579i)+(num-test (make-rectangular 2 2) 2.0+2.0i)+(num-test (make-rectangular -2 2) -2.0+2.0i)+(num-test (make-rectangular 2 -2) 2.0-2.0i)+(num-test (make-rectangular -2 -2) -2.0-2.0i)+(num-test (make-polar 2 2) -0.83229367309428+1.81859485365136i)+(num-test (make-polar -2 2) 0.83229367309428-1.81859485365136i)+(num-test (make-polar 2 -2) -0.83229367309428-1.81859485365136i)+(num-test (make-polar -2 -2) 0.83229367309428+1.81859485365136i)+(num-test (make-rectangular 2 3) 2.0+3.0i)+(num-test (make-rectangular -2 3) -2.0+3.0i)+(num-test (make-rectangular 2 -3) 2.0-3.0i)+(num-test (make-rectangular -2 -3) -2.0-3.0i)+(num-test (make-polar 2 3) -1.97998499320089+0.28224001611973i)+(num-test (make-polar -2 3) 1.97998499320089-0.28224001611973i)+(num-test (make-polar 2 -3) -1.97998499320089-0.28224001611973i)+(num-test (make-polar -2 -3) 1.97998499320089+0.28224001611973i)+(num-test (make-rectangular 2 10) 2.0+10.0i)+(num-test (make-rectangular -2 10) -2.0+10.0i)+(num-test (make-rectangular 2 -10) 2.0-10.0i)+(num-test (make-rectangular -2 -10) -2.0-10.0i)+(num-test (make-polar 2 10) -1.67814305815290-1.08804222177874i)+(num-test (make-polar -2 10) 1.67814305815290+1.08804222177874i)+(num-test (make-polar 2 -10) -1.67814305815290+1.08804222177874i)+(num-test (make-polar -2 -10) 1.67814305815290-1.08804222177874i)+(num-test (make-rectangular 2 1234) 2.0+1234.0i)+(num-test (make-rectangular -2 1234) -2.0+1234.0i)+(num-test (make-rectangular 2 -1234) 2.0-1234.0i)+(num-test (make-rectangular -2 -1234) -2.0-1234.0i)+(num-test (make-polar 2 1234) -1.59710124717517+1.20385530952499i)+(num-test (make-polar -2 1234) 1.59710124717517-1.20385530952499i)+(num-test (make-polar 2 -1234) -1.59710124717517-1.20385530952499i)+(num-test (make-polar -2 -1234) 1.59710124717517+1.20385530952499i)+(num-test (make-rectangular 2 1234000000) 2.0+1234000000.0i)+(num-test (make-rectangular -2 1234000000) -2.0+1234000000.0i)+(num-test (make-rectangular 2 -1234000000) 2.0-1234000000.0i)+(num-test (make-rectangular -2 -1234000000) -2.0-1234000000.0i)+(num-test (make-polar 2 1234000000) 0.31781826190303-1.97458642566005i)+(num-test (make-polar -2 1234000000) -0.31781826190303+1.97458642566005i)+(num-test (make-polar 2 -1234000000) 0.31781826190303+1.97458642566005i)+(num-test (make-polar -2 -1234000000) -0.31781826190303-1.97458642566005i)+(num-test (make-rectangular 2 500029) 2.0+500029.0i)+(num-test (make-rectangular -2 500029) -2.0+500029.0i)+(num-test (make-rectangular 2 -500029) 2.0-500029.0i)+(num-test (make-rectangular -2 -500029) -2.0-500029.0i)+(num-test (make-polar 2 500029) 1.70829811259895+1.04005651696957i)+(num-test (make-polar -2 500029) -1.70829811259895-1.04005651696957i)+(num-test (make-polar 2 -500029) 1.70829811259895-1.04005651696957i)+(num-test (make-polar -2 -500029) -1.70829811259895+1.04005651696957i)+(num-test (make-rectangular 2 362880) 2.0+362880.0i)+(num-test (make-rectangular -2 362880) -2.0+362880.0i)+(num-test (make-rectangular 2 -362880) 2.0-362880.0i)+(num-test (make-rectangular -2 -362880) -2.0-362880.0i)+(num-test (make-polar 2 362880) 1.21836159095277+1.58606274582408i)+(num-test (make-polar -2 362880) -1.21836159095277-1.58606274582408i)+(num-test (make-polar 2 -362880) 1.21836159095277-1.58606274582408i)+(num-test (make-polar -2 -362880) -1.21836159095277+1.58606274582408i)+(num-test (make-rectangular 3 1) 3.0+1.0i)+(num-test (make-rectangular -3 1) -3.0+1.0i)+(num-test (make-rectangular 3 -1) 3.0-1.0i)+(num-test (make-rectangular -3 -1) -3.0-1.0i)+(num-test (make-polar 3 1) 1.62090691760442+2.52441295442369i)+(num-test (make-polar -3 1) -1.62090691760442-2.52441295442369i)+(num-test (make-polar 3 -1) 1.62090691760442-2.52441295442369i)+(num-test (make-polar -3 -1) -1.62090691760442+2.52441295442369i)+(num-test (make-rectangular 3 2) 3.0+2.0i)+(num-test (make-rectangular -3 2) -3.0+2.0i)+(num-test (make-rectangular 3 -2) 3.0-2.0i)+(num-test (make-rectangular -3 -2) -3.0-2.0i)+(num-test (make-polar 3 2) -1.24844050964143+2.72789228047704i)+(num-test (make-polar -3 2) 1.24844050964143-2.72789228047704i)+(num-test (make-polar 3 -2) -1.24844050964143-2.72789228047704i)+(num-test (make-polar -3 -2) 1.24844050964143+2.72789228047704i)+(num-test (make-rectangular 3 3) 3.0+3.0i)+(num-test (make-rectangular -3 3) -3.0+3.0i)+(num-test (make-rectangular 3 -3) 3.0-3.0i)+(num-test (make-rectangular -3 -3) -3.0-3.0i)+(num-test (make-polar 3 3) -2.96997748980134+0.42336002417960i)+(num-test (make-polar -3 3) 2.96997748980134-0.42336002417960i)+(num-test (make-polar 3 -3) -2.96997748980134-0.42336002417960i)+(num-test (make-polar -3 -3) 2.96997748980134+0.42336002417960i)+(num-test (make-rectangular 3 10) 3.0+10.0i)+(num-test (make-rectangular -3 10) -3.0+10.0i)+(num-test (make-rectangular 3 -10) 3.0-10.0i)+(num-test (make-rectangular -3 -10) -3.0-10.0i)+(num-test (make-polar 3 10) -2.51721458722936-1.63206333266811i)+(num-test (make-polar -3 10) 2.51721458722936+1.63206333266811i)+(num-test (make-polar 3 -10) -2.51721458722936+1.63206333266811i)+(num-test (make-polar -3 -10) 2.51721458722936-1.63206333266811i)+(num-test (make-rectangular 3 1234) 3.0+1234.0i)+(num-test (make-rectangular -3 1234) -3.0+1234.0i)+(num-test (make-rectangular 3 -1234) 3.0-1234.0i)+(num-test (make-rectangular -3 -1234) -3.0-1234.0i)+(num-test (make-polar 3 1234) -2.39565187076275+1.80578296428749i)+(num-test (make-polar -3 1234) 2.39565187076275-1.80578296428749i)+(num-test (make-polar 3 -1234) -2.39565187076275-1.80578296428749i)+(num-test (make-polar -3 -1234) 2.39565187076275+1.80578296428749i)+(num-test (make-rectangular 3 1234000000) 3.0+1234000000.0i)+(num-test (make-rectangular -3 1234000000) -3.0+1234000000.0i)+(num-test (make-rectangular 3 -1234000000) 3.0-1234000000.0i)+(num-test (make-rectangular -3 -1234000000) -3.0-1234000000.0i)+(num-test (make-polar 3 1234000000) 0.47672739285455-2.96187963849008i)+(num-test (make-polar -3 1234000000) -0.47672739285455+2.96187963849008i)+(num-test (make-polar 3 -1234000000) 0.47672739285455+2.96187963849008i)+(num-test (make-polar -3 -1234000000) -0.47672739285455-2.96187963849008i)+(num-test (make-rectangular 3 500029) 3.0+500029.0i)+(num-test (make-rectangular -3 500029) -3.0+500029.0i)+(num-test (make-rectangular 3 -500029) 3.0-500029.0i)+(num-test (make-rectangular -3 -500029) -3.0-500029.0i)+(num-test (make-polar 3 500029) 2.56244716889842+1.56008477545436i)+(num-test (make-polar -3 500029) -2.56244716889842-1.56008477545436i)+(num-test (make-polar 3 -500029) 2.56244716889842-1.56008477545436i)+(num-test (make-polar -3 -500029) -2.56244716889842+1.56008477545436i)+(num-test (make-rectangular 3 362880) 3.0+362880.0i)+(num-test (make-rectangular -3 362880) -3.0+362880.0i)+(num-test (make-rectangular 3 -362880) 3.0-362880.0i)+(num-test (make-rectangular -3 -362880) -3.0-362880.0i)+(num-test (make-polar 3 362880) 1.82754238642915+2.37909411873613i)+(num-test (make-polar -3 362880) -1.82754238642915-2.37909411873613i)+(num-test (make-polar 3 -362880) 1.82754238642915-2.37909411873613i)+(num-test (make-polar -3 -362880) -1.82754238642915+2.37909411873613i)+(num-test (make-rectangular 10 1) 10.0+1.0i)+(num-test (make-rectangular -10 1) -10.0+1.0i)+(num-test (make-rectangular 10 -1) 10.0-1.0i)+(num-test (make-rectangular -10 -1) -10.0-1.0i)+(num-test (make-polar 10 1) 5.40302305868140+8.41470984807897i)+(num-test (make-polar -10 1) -5.40302305868140-8.41470984807897i)+(num-test (make-polar 10 -1) 5.40302305868140-8.41470984807897i)+(num-test (make-polar -10 -1) -5.40302305868140+8.41470984807897i)+(num-test (make-rectangular 10 2) 10.0+2.0i)+(num-test (make-rectangular -10 2) -10.0+2.0i)+(num-test (make-rectangular 10 -2) 10.0-2.0i)+(num-test (make-rectangular -10 -2) -10.0-2.0i)+(num-test (make-polar 10 2) -4.16146836547142+9.09297426825682i)+(num-test (make-polar -10 2) 4.16146836547142-9.09297426825682i)+(num-test (make-polar 10 -2) -4.16146836547142-9.09297426825682i)+(num-test (make-polar -10 -2) 4.16146836547142+9.09297426825682i)+(num-test (make-rectangular 10 3) 10.0+3.0i)+(num-test (make-rectangular -10 3) -10.0+3.0i)+(num-test (make-rectangular 10 -3) 10.0-3.0i)+(num-test (make-rectangular -10 -3) -10.0-3.0i)+(num-test (make-polar 10 3) -9.89992496600445+1.41120008059867i)+(num-test (make-polar -10 3) 9.89992496600445-1.41120008059867i)+(num-test (make-polar 10 -3) -9.89992496600445-1.41120008059867i)+(num-test (make-polar -10 -3) 9.89992496600445+1.41120008059867i)+(num-test (make-rectangular 10 10) 10.0+10.0i)+(num-test (make-rectangular -10 10) -10.0+10.0i)+(num-test (make-rectangular 10 -10) 10.0-10.0i)+(num-test (make-rectangular -10 -10) -10.0-10.0i)+(num-test (make-polar 10 10) -8.39071529076452-5.44021110889370i)+(num-test (make-polar -10 10) 8.39071529076452+5.44021110889370i)+(num-test (make-polar 10 -10) -8.39071529076452+5.44021110889370i)+(num-test (make-polar -10 -10) 8.39071529076452-5.44021110889370i)+(num-test (make-rectangular 10 1234) 10.0+1234.0i)+(num-test (make-rectangular -10 1234) -10.0+1234.0i)+(num-test (make-rectangular 10 -1234) 10.0-1234.0i)+(num-test (make-rectangular -10 -1234) -10.0-1234.0i)+(num-test (make-polar 10 1234) -7.98550623587584+6.01927654762497i)+(num-test (make-polar -10 1234) 7.98550623587584-6.01927654762497i)+(num-test (make-polar 10 -1234) -7.98550623587584-6.01927654762497i)+(num-test (make-polar -10 -1234) 7.98550623587584+6.01927654762497i)+(num-test (make-rectangular 10 1234000000) 10.0+1234000000.0i)+(num-test (make-rectangular -10 1234000000) -10.0+1234000000.0i)+(num-test (make-rectangular 10 -1234000000) 10.0-1234000000.0i)+(num-test (make-rectangular -10 -1234000000) -10.0-1234000000.0i)+(num-test (make-polar 10 1234000000) 1.58909130951517-9.87293212830025i)+(num-test (make-polar -10 1234000000) -1.58909130951517+9.87293212830025i)+(num-test (make-polar 10 -1234000000) 1.58909130951517+9.87293212830025i)+(num-test (make-polar -10 -1234000000) -1.58909130951517-9.87293212830025i)+(num-test (make-rectangular 10 500029) 10.0+500029.0i)+(num-test (make-rectangular -10 500029) -10.0+500029.0i)+(num-test (make-rectangular 10 -500029) 10.0-500029.0i)+(num-test (make-rectangular -10 -500029) -10.0-500029.0i)+(num-test (make-polar 10 500029) 8.54149056299473+5.20028258484786i)+(num-test (make-polar -10 500029) -8.54149056299473-5.20028258484786i)+(num-test (make-polar 10 -500029) 8.54149056299473-5.20028258484786i)+(num-test (make-polar -10 -500029) -8.54149056299473+5.20028258484786i)+(num-test (make-rectangular 10 362880) 10.0+362880.0i)+(num-test (make-rectangular -10 362880) -10.0+362880.0i)+(num-test (make-rectangular 10 -362880) 10.0-362880.0i)+(num-test (make-rectangular -10 -362880) -10.0-362880.0i)+(num-test (make-polar 10 362880) 6.09180795476385+7.93031372912042i)+(num-test (make-polar -10 362880) -6.09180795476385-7.93031372912042i)+(num-test (make-polar 10 -362880) 6.09180795476385-7.93031372912042i)+(num-test (make-polar -10 -362880) -6.09180795476385+7.93031372912042i)+(num-test (make-rectangular 1234 1) 1234.0+1.0i)+(num-test (make-rectangular -1234 1) -1234.0+1.0i)+(num-test (make-rectangular 1234 -1) 1234.0-1.0i)+(num-test (make-rectangular -1234 -1) -1234.0-1.0i)+(num-test (make-polar 1234 1) 666.73304544128450+1038.37519525294420i)+(num-test (make-polar -1234 1) -666.73304544128450-1038.37519525294420i)+(num-test (make-polar 1234 -1) 666.73304544128450-1038.37519525294420i)+(num-test (make-polar -1234 -1) -666.73304544128450+1038.37519525294420i)+(num-test (make-rectangular 1234 2) 1234.0+2.0i)+(num-test (make-rectangular -1234 2) -1234.0+2.0i)+(num-test (make-rectangular 1234 -2) 1234.0-2.0i)+(num-test (make-rectangular -1234 -2) -1234.0-2.0i)+(num-test (make-polar 1234 2) -513.52519629917379+1122.07302470289119i)+(num-test (make-polar -1234 2) 513.52519629917379-1122.07302470289119i)+(num-test (make-polar 1234 -2) -513.52519629917379-1122.07302470289119i)+(num-test (make-polar -1234 -2) 513.52519629917379+1122.07302470289119i)+(num-test (make-rectangular 1234 3) 1234.0+3.0i)+(num-test (make-rectangular -1234 3) -1234.0+3.0i)+(num-test (make-rectangular 1234 -3) 1234.0-3.0i)+(num-test (make-rectangular -1234 -3) -1234.0-3.0i)+(num-test (make-polar 1234 3) -1221.65074080494969+174.14208994587614i)+(num-test (make-polar -1234 3) 1221.65074080494969-174.14208994587614i)+(num-test (make-polar 1234 -3) -1221.65074080494969-174.14208994587614i)+(num-test (make-polar -1234 -3) 1221.65074080494969+174.14208994587614i)+(num-test (make-rectangular 1234 10) 1234.0+10.0i)+(num-test (make-rectangular -1234 10) -1234.0+10.0i)+(num-test (make-rectangular 1234 -10) 1234.0-10.0i)+(num-test (make-rectangular -1234 -10) -1234.0-10.0i)+(num-test (make-polar 1234 10) -1035.41426688034221-671.32205083748227i)+(num-test (make-polar -1234 10) 1035.41426688034221+671.32205083748227i)+(num-test (make-polar 1234 -10) -1035.41426688034221+671.32205083748227i)+(num-test (make-polar -1234 -10) 1035.41426688034221-671.32205083748227i)+(num-test (make-rectangular 1234 1234) 1234.0+1234.0i)+(num-test (make-rectangular -1234 1234) -1234.0+1234.0i)+(num-test (make-rectangular 1234 -1234) 1234.0-1234.0i)+(num-test (make-rectangular -1234 -1234) -1234.0-1234.0i)+(num-test (make-polar 1234 1234) -985.41146950707912+742.77872597692169i)+(num-test (make-polar -1234 1234) 985.41146950707912-742.77872597692169i)+(num-test (make-polar 1234 -1234) -985.41146950707912-742.77872597692169i)+(num-test (make-polar -1234 -1234) 985.41146950707912+742.77872597692169i)+(num-test (make-rectangular 1234 1234000000) 1234.0+1234000000.0i)+(num-test (make-rectangular -1234 1234000000) -1234.0+1234000000.0i)+(num-test (make-rectangular 1234 -1234000000) 1234.0-1234000000.0i)+(num-test (make-rectangular -1234 -1234000000) -1234.0-1234000000.0i)+(num-test (make-polar 1234 1234000000) 196.09386759417183-1218.31982463225131i)+(num-test (make-polar -1234 1234000000) -196.09386759417183+1218.31982463225131i)+(num-test (make-polar 1234 -1234000000) 196.09386759417183+1218.31982463225131i)+(num-test (make-polar -1234 -1234000000) -196.09386759417183-1218.31982463225131i)+(num-test (make-rectangular 1234 500029) 1234.0+500029.0i)+(num-test (make-rectangular -1234 500029) -1234.0+500029.0i)+(num-test (make-rectangular 1234 -500029) 1234.0-500029.0i)+(num-test (make-rectangular -1234 -500029) -1234.0-500029.0i)+(num-test (make-polar 1234 500029) 1054.01993547355005+641.71487097022577i)+(num-test (make-polar -1234 500029) -1054.01993547355005-641.71487097022577i)+(num-test (make-polar 1234 -500029) 1054.01993547355005-641.71487097022577i)+(num-test (make-polar -1234 -500029) -1054.01993547355005+641.71487097022577i)+(num-test (make-rectangular 1234 362880) 1234.0+362880.0i)+(num-test (make-rectangular -1234 362880) -1234.0+362880.0i)+(num-test (make-rectangular 1234 -362880) 1234.0-362880.0i)+(num-test (make-rectangular -1234 -362880) -1234.0-362880.0i)+(num-test (make-polar 1234 362880) 751.72910161785899+978.60071417346035i)+(num-test (make-polar -1234 362880) -751.72910161785899-978.60071417346035i)+(num-test (make-polar 1234 -362880) 751.72910161785899-978.60071417346035i)+(num-test (make-polar -1234 -362880) -751.72910161785899+978.60071417346035i)+(num-test (make-rectangular 1234000000 1) 1234000000.0+1.0i)+(num-test (make-rectangular -1234000000 1) -1234000000.0+1.0i)+(num-test (make-rectangular 1234000000 -1) 1234000000.0-1.0i)+(num-test (make-rectangular -1234000000 -1) -1234000000.0-1.0i)+(num-test (make-polar 1234000000 1) 666733045.44128441810608+1038375195.25294423103333i)+(num-test (make-polar -1234000000 1) -666733045.44128441810608-1038375195.25294423103333i)+(num-test (make-polar 1234000000 -1) 666733045.44128441810608-1038375195.25294423103333i)+(num-test (make-polar -1234000000 -1) -666733045.44128441810608+1038375195.25294423103333i)+(num-test (make-rectangular 1234000000 2) 1234000000.0+2.0i)+(num-test (make-rectangular -1234000000 2) -1234000000.0+2.0i)+(num-test (make-rectangular 1234000000 -2) 1234000000.0-2.0i)+(num-test (make-rectangular -1234000000 -2) -1234000000.0-2.0i)+(num-test (make-polar 1234000000 2) -513525196.29917371273041+1122073024.70289111137390i)+(num-test (make-polar -1234000000 2) 513525196.29917371273041-1122073024.70289111137390i)+(num-test (make-polar 1234000000 -2) -513525196.29917371273041-1122073024.70289111137390i)+(num-test (make-polar -1234000000 -2) 513525196.29917371273041+1122073024.70289111137390i)+(num-test (make-rectangular 1234000000 3) 1234000000.0+3.0i)+(num-test (make-rectangular -1234000000 3) -1234000000.0+3.0i)+(num-test (make-rectangular 1234000000 -3) 1234000000.0-3.0i)+(num-test (make-rectangular -1234000000 -3) -1234000000.0-3.0i)+(num-test (make-polar 1234000000 3) -1221650740.80494976043701+174142089.94587615132332i)+(num-test (make-polar -1234000000 3) 1221650740.80494976043701-174142089.94587615132332i)+(num-test (make-polar 1234000000 -3) -1221650740.80494976043701-174142089.94587615132332i)+(num-test (make-polar -1234000000 -3) 1221650740.80494976043701+174142089.94587615132332i)+(num-test (make-rectangular 1234000000 10) 1234000000.0+10.0i)+(num-test (make-rectangular -1234000000 10) -1234000000.0+10.0i)+(num-test (make-rectangular 1234000000 -10) 1234000000.0-10.0i)+(num-test (make-rectangular -1234000000 -10) -1234000000.0-10.0i)+(num-test (make-polar 1234000000 10) -1035414266.88034236431122-671322050.83748233318329i)+(num-test (make-polar -1234000000 10) 1035414266.88034236431122+671322050.83748233318329i)+(num-test (make-polar 1234000000 -10) -1035414266.88034236431122+671322050.83748233318329i)+(num-test (make-polar -1234000000 -10) 1035414266.88034236431122-671322050.83748233318329i)+(num-test (make-rectangular 1234000000 1234) 1234000000.0+1234.0i)+(num-test (make-rectangular -1234000000 1234) -1234000000.0+1234.0i)+(num-test (make-rectangular 1234000000 -1234) 1234000000.0-1234.0i)+(num-test (make-rectangular -1234000000 -1234) -1234000000.0-1234.0i)+(num-test (make-polar 1234000000 1234) -985411469.50707900524139+742778725.97692167758942i)+(num-test (make-polar -1234000000 1234) 985411469.50707900524139-742778725.97692167758942i)+(num-test (make-polar 1234000000 -1234) -985411469.50707900524139-742778725.97692167758942i)+(num-test (make-polar -1234000000 -1234) 985411469.50707900524139+742778725.97692167758942i)+(num-test (make-rectangular 1234000000 1234000000) 1234000000.0+1234000000.0i)+(num-test (make-rectangular -1234000000 1234000000) -1234000000.0+1234000000.0i)+(num-test (make-rectangular 1234000000 -1234000000) 1234000000.0-1234000000.0i)+(num-test (make-rectangular -1234000000 -1234000000) -1234000000.0-1234000000.0i)+(num-test (make-polar 1234000000 1234000000) 196093867.59417182207108-1218319824.63225126266479i)+(num-test (make-polar -1234000000 1234000000) -196093867.59417182207108+1218319824.63225126266479i)+(num-test (make-polar 1234000000 -1234000000) 196093867.59417182207108+1218319824.63225126266479i)+(num-test (make-polar -1234000000 -1234000000) -196093867.59417182207108-1218319824.63225126266479i)+(num-test (make-rectangular 1234000000 500029) 1234000000.0+500029.0i)+(num-test (make-rectangular -1234000000 500029) -1234000000.0+500029.0i)+(num-test (make-rectangular 1234000000 -500029) 1234000000.0-500029.0i)+(num-test (make-rectangular -1234000000 -500029) -1234000000.0-500029.0i)+(num-test (make-polar 1234000000 500029) 1054019935.47354996204376+641714870.97022569179535i)+(num-test (make-polar -1234000000 500029) -1054019935.47354996204376-641714870.97022569179535i)+(num-test (make-polar 1234000000 -500029) 1054019935.47354996204376-641714870.97022569179535i)+(num-test (make-polar -1234000000 -500029) -1054019935.47354996204376+641714870.97022569179535i)+(num-test (make-rectangular 1234000000 362880) 1234000000.0+362880.0i)+(num-test (make-rectangular -1234000000 362880) -1234000000.0+362880.0i)+(num-test (make-rectangular 1234000000 -362880) 1234000000.0-362880.0i)+(num-test (make-rectangular -1234000000 -362880) -1234000000.0-362880.0i)+(num-test (make-polar 1234000000 362880) 751729101.61785900592804+978600714.17346036434174i)+(num-test (make-polar -1234000000 362880) -751729101.61785900592804-978600714.17346036434174i)+(num-test (make-polar 1234000000 -362880) 751729101.61785900592804-978600714.17346036434174i)+(num-test (make-polar -1234000000 -362880) -751729101.61785900592804+978600714.17346036434174i)+(num-test (make-rectangular 500029 1) 500029.0+1.0i)+(num-test (make-rectangular -500029 1) -500029.0+1.0i)+(num-test (make-rectangular 500029 -1) 500029.0-1.0i)+(num-test (make-rectangular -500029 -1) -500029.0-1.0i)+(num-test (make-polar 500029 1) 270166.82170094008325+420759.89506250765407i)+(num-test (make-polar -500029 1) -270166.82170094008325-420759.89506250765407i)+(num-test (make-polar 500029 -1) 270166.82170094008325-420759.89506250765407i)+(num-test (make-polar -500029 -1) -270166.82170094008325+420759.89506250765407i)+(num-test (make-rectangular 500029 2) 500029.0+2.0i)+(num-test (make-rectangular -500029 2) -500029.0+2.0i)+(num-test (make-rectangular 500029 -2) 500029.0-2.0i)+(num-test (make-rectangular -500029 -2) -500029.0-2.0i)+(num-test (make-polar 500029 2) -208085.48653183106217+454675.08303821878508i)+(num-test (make-polar -500029 2) 208085.48653183106217-454675.08303821878508i)+(num-test (make-polar 500029 -2) -208085.48653183106217-454675.08303821878508i)+(num-test (make-polar -500029 -2) 208085.48653183106217+454675.08303821878508i)+(num-test (make-rectangular 500029 3) 500029.0+3.0i)+(num-test (make-rectangular -500029 3) -500029.0+3.0i)+(num-test (make-rectangular 500029 -3) 500029.0-3.0i)+(num-test (make-rectangular -500029 -3) -500029.0-3.0i)+(num-test (make-polar 500029 3) -495024.95808262412902+70564.09651016735006i)+(num-test (make-polar -500029 3) 495024.95808262412902-70564.09651016735006i)+(num-test (make-polar 500029 -3) -495024.95808262412902-70564.09651016735006i)+(num-test (make-polar -500029 -3) 495024.95808262412902+70564.09651016735006i)+(num-test (make-rectangular 500029 10) 500029.0+10.0i)+(num-test (make-rectangular -500029 10) -500029.0+10.0i)+(num-test (make-rectangular 500029 -10) 500029.0-10.0i)+(num-test (make-rectangular -500029 -10) -500029.0-10.0i)+(num-test (make-polar 500029 10) -419560.09761256945785-272026.33205690066097i)+(num-test (make-polar -500029 10) 419560.09761256945785+272026.33205690066097i)+(num-test (make-polar 500029 -10) -419560.09761256945785+272026.33205690066097i)+(num-test (make-polar -500029 -10) 419560.09761256945785-272026.33205690066097i)+(num-test (make-rectangular 500029 1234) 500029.0+1234.0i)+(num-test (make-rectangular -500029 1234) -500029.0+1234.0i)+(num-test (make-rectangular 500029 -1234) 500029.0-1234.0i)+(num-test (make-rectangular -500029 -1234) -500029.0-1234.0i)+(num-test (make-polar 500029 1234) -399298.46976187621476+300981.28328323678579i)+(num-test (make-polar -500029 1234) 399298.46976187621476-300981.28328323678579i)+(num-test (make-polar 500029 -1234) -399298.46976187621476-300981.28328323678579i)+(num-test (make-polar -500029 -1234) 399298.46976187621476+300981.28328323678579i)+(num-test (make-rectangular 500029 1234000000) 500029.0+1234000000.0i)+(num-test (make-rectangular -500029 1234000000) -500029.0+1234000000.0i)+(num-test (make-rectangular 500029 -1234000000) 500029.0-1234000000.0i)+(num-test (make-rectangular -500029 -1234000000) -500029.0-1234000000.0i)+(num-test (make-polar 500029 1234000000) 79459.17384055603179-493675.23791818472091i)+(num-test (make-polar -500029 1234000000) -79459.17384055603179+493675.23791818472091i)+(num-test (make-polar 500029 -1234000000) 79459.17384055603179+493675.23791818472091i)+(num-test (make-polar -500029 -1234000000) -79459.17384055603179-493675.23791818472091i)+(num-test (make-rectangular 500029 500029) 500029.0+500029.0i)+(num-test (make-rectangular -500029 500029) -500029.0+500029.0i)+(num-test (make-rectangular 500029 -500029) 500029.0-500029.0i)+(num-test (make-rectangular -500029 -500029) -500029.0-500029.0i)+(num-test (make-polar 500029 500029) 427099.29847236932255+260029.21006188896718i)+(num-test (make-polar -500029 500029) -427099.29847236932255-260029.21006188896718i)+(num-test (make-polar 500029 -500029) 427099.29847236932255-260029.21006188896718i)+(num-test (make-polar -500029 -500029) -427099.29847236932255+260029.21006188896718i)+(num-test (make-rectangular 500029 362880) 500029.0+362880.0i)+(num-test (make-rectangular -500029 362880) -500029.0+362880.0i)+(num-test (make-rectangular 500029 -362880) 500029.0-362880.0i)+(num-test (make-rectangular -500029 -362880) -500029.0-362880.0i)+(num-test (make-polar 500029 362880) 304608.06398126127897+396538.68436583562288i)+(num-test (make-polar -500029 362880) -304608.06398126127897-396538.68436583562288i)+(num-test (make-polar 500029 -362880) 304608.06398126127897-396538.68436583562288i)+(num-test (make-polar -500029 -362880) -304608.06398126127897+396538.68436583562288i)+(num-test (make-rectangular 362880 1) 362880.0+1.0i)+(num-test (make-rectangular -362880 1) -362880.0+1.0i)+(num-test (make-rectangular 362880 -1) 362880.0-1.0i)+(num-test (make-rectangular -362880 -1) -362880.0-1.0i)+(num-test (make-polar 362880 1) 196064.90075343055651+305352.99096708948491i)+(num-test (make-polar -362880 1) -196064.90075343055651-305352.99096708948491i)+(num-test (make-polar 362880 -1) 196064.90075343055651-305352.99096708948491i)+(num-test (make-polar -362880 -1) -196064.90075343055651+305352.99096708948491i)+(num-test (make-rectangular 362880 2) 362880.0+2.0i)+(num-test (make-rectangular -362880 2) -362880.0+2.0i)+(num-test (make-rectangular 362880 -2) 362880.0-2.0i)+(num-test (make-rectangular -362880 -2) -362880.0-2.0i)+(num-test (make-polar 362880 2) -151011.36404622704140+329965.85024650336709i)+(num-test (make-polar -362880 2) 151011.36404622704140-329965.85024650336709i)+(num-test (make-polar 362880 -2) -151011.36404622704140-329965.85024650336709i)+(num-test (make-polar -362880 -2) 151011.36404622704140+329965.85024650336709i)+(num-test (make-rectangular 362880 3) 362880.0+3.0i)+(num-test (make-rectangular -362880 3) -362880.0+3.0i)+(num-test (make-rectangular 362880 -3) 362880.0-3.0i)+(num-test (make-rectangular -362880 -3) -362880.0-3.0i)+(num-test (make-polar 362880 3) -359248.47716636961559+51209.62852476461558i)+(num-test (make-polar -362880 3) 359248.47716636961559-51209.62852476461558i)+(num-test (make-polar 362880 -3) -359248.47716636961559-51209.62852476461558i)+(num-test (make-polar -362880 -3) 359248.47716636961559+51209.62852476461558i)+(num-test (make-rectangular 362880 10) 362880.0+10.0i)+(num-test (make-rectangular -362880 10) -362880.0+10.0i)+(num-test (make-rectangular 362880 -10) 362880.0-10.0i)+(num-test (make-rectangular -362880 -10) -362880.0-10.0i)+(num-test (make-polar 362880 10) -304482.27647126308875-197414.38071953449980i)+(num-test (make-polar -362880 10) 304482.27647126308875+197414.38071953449980i)+(num-test (make-polar 362880 -10) -304482.27647126308875+197414.38071953449980i)+(num-test (make-polar -362880 -10) 304482.27647126308875-197414.38071953449980i)+(num-test (make-rectangular 362880 1234) 362880.0+1234.0i)+(num-test (make-rectangular -362880 1234) -362880.0+1234.0i)+(num-test (make-rectangular 362880 -1234) 362880.0-1234.0i)+(num-test (make-rectangular -362880 -1234) -362880.0-1234.0i)+(num-test (make-polar 362880 1234) -289778.05028746259632+218427.50736021503690i)+(num-test (make-polar -362880 1234) 289778.05028746259632-218427.50736021503690i)+(num-test (make-polar 362880 -1234) -289778.05028746259632-218427.50736021503690i)+(num-test (make-polar -362880 -1234) 289778.05028746259632+218427.50736021503690i)+(num-test (make-rectangular 362880 1234000000) 362880.0+1234000000.0i)+(num-test (make-rectangular -362880 1234000000) -362880.0+1234000000.0i)+(num-test (make-rectangular 362880 -1234000000) 362880.0-1234000000.0i)+(num-test (make-rectangular -362880 -1234000000) -362880.0-1234000000.0i)+(num-test (make-polar 362880 1234000000) 57664.94543968644575-358268.96107175957877i)+(num-test (make-polar -362880 1234000000) -57664.94543968644575+358268.96107175957877i)+(num-test (make-polar 362880 -1234000000) 57664.94543968644575+358268.96107175957877i)+(num-test (make-polar -362880 -1234000000) -57664.94543968644575-358268.96107175957877i)+(num-test (make-rectangular 362880 500029) 362880.0+500029.0i)+(num-test (make-rectangular -362880 500029) -362880.0+500029.0i)+(num-test (make-rectangular 362880 -500029) 362880.0-500029.0i)+(num-test (make-rectangular -362880 -500029) -362880.0-500029.0i)+(num-test (make-polar 362880 500029) 309953.60954995284555+188707.85443895909702i)+(num-test (make-polar -362880 500029) -309953.60954995284555-188707.85443895909702i)+(num-test (make-polar 362880 -500029) 309953.60954995284555-188707.85443895909702i)+(num-test (make-polar -362880 -500029) -309953.60954995284555+188707.85443895909702i)+(num-test (make-rectangular 362880 362880) 362880.0+362880.0i)+(num-test (make-rectangular -362880 362880) -362880.0+362880.0i)+(num-test (make-rectangular 362880 -362880) 362880.0-362880.0i)+(num-test (make-rectangular -362880 -362880) -362880.0-362880.0i)+(num-test (make-polar 362880 362880) 221059.52706247055903+287775.22460232191952i)+(num-test (make-polar -362880 362880) -221059.52706247055903-287775.22460232191952i)+(num-test (make-polar 362880 -362880) 221059.52706247055903-287775.22460232191952i)+(num-test (make-polar -362880 -362880) -221059.52706247055903+287775.22460232191952i)+(num-test (make-rectangular 0.0 0.00000001) 0.0+0.00000001i)+(num-test (make-rectangular -0.0 0.00000001) -0.0+0.00000001i)+(num-test (make-rectangular 0.0 -0.00000001) 0.0-0.00000001i)+(num-test (make-rectangular -0.0 -0.00000001) -0.0-0.00000001i)+(num-test (make-polar 0.0 0.00000001) 0.0)+(num-test (make-polar -0.0 0.00000001) -0.0)+(num-test (make-polar 0.0 -0.00000001) 0.0)+(num-test (make-polar -0.0 -0.00000001) 0.0)+(num-test (make-rectangular 0.0 1.0) 0.0+1.0i)+(num-test (make-rectangular -0.0 1.0) -0.0+1.0i)+(num-test (make-rectangular 0.0 -1.0) 0.0-1.0i)+(num-test (make-rectangular -0.0 -1.0) -0.0-1.0i)+(num-test (make-polar 0.0 1.0) 0.0)+(num-test (make-polar -0.0 1.0) -0.0)+(num-test (make-polar 0.0 -1.0) 0.0)+(num-test (make-polar -0.0 -1.0) 0.0)+(num-test (make-rectangular 0.0 our-pi) 0.0+3.14159265358979i)+(num-test (make-rectangular -0.0 our-pi) -0.0+3.14159265358979i)+(num-test (make-rectangular 0.0 -3.14159265358979) 0.0-3.14159265358979i)+(num-test (make-rectangular -0.0 -3.14159265358979) -0.0-3.14159265358979i)+(num-test (make-polar 0.0 our-pi) -0.0)+(num-test (make-polar -0.0 our-pi) 0.0)+(num-test (make-polar 0.0 -3.14159265358979) 0.0)+(num-test (make-polar -0.0 -3.14159265358979) 0.0)+(num-test (make-rectangular 0.0 2.71828182845905) 0.0+2.71828182845905i)+(num-test (make-rectangular -0.0 2.71828182845905) -0.0+2.71828182845905i)+(num-test (make-rectangular 0.0 -2.71828182845905) 0.0-2.71828182845905i)+(num-test (make-rectangular -0.0 -2.71828182845905) -0.0-2.71828182845905i)+(num-test (make-polar 0.0 2.71828182845905) -0.0)+(num-test (make-polar -0.0 2.71828182845905) 0.0)+(num-test (make-polar 0.0 -2.71828182845905) 0.0)+(num-test (make-polar -0.0 -2.71828182845905) 0.0)+(num-test (make-rectangular 0.0 1234.0) 0.0+1234.0i)+(num-test (make-rectangular -0.0 1234.0) -0.0+1234.0i)+(num-test (make-rectangular 0.0 -1234.0) 0.0-1234.0i)+(num-test (make-rectangular -0.0 -1234.0) -0.0-1234.0i)+(num-test (make-polar 0.0 1234.0) -0.0)+(num-test (make-polar -0.0 1234.0) 0.0)+(num-test (make-polar 0.0 -1234.0) 0.0)+(num-test (make-polar -0.0 -1234.0) 0.0)+(num-test (make-rectangular 0.0 1234000000.0) 0.0+1234000000.0i)+(num-test (make-rectangular -0.0 1234000000.0) -0.0+1234000000.0i)+(num-test (make-rectangular 0.0 -1234000000.0) 0.0-1234000000.0i)+(num-test (make-rectangular -0.0 -1234000000.0) -0.0-1234000000.0i)+(num-test (make-polar 0.0 1234000000.0) 0.0)+(num-test (make-polar -0.0 1234000000.0) 0.0)+(num-test (make-polar 0.0 -1234000000.0) 0.0)+(num-test (make-polar -0.0 -1234000000.0) -0.0)+(num-test (make-rectangular 0.00000001 0.00000001) 0.00000001+0.00000001i)+(num-test (make-rectangular -0.00000001 0.00000001) -0.00000001+0.00000001i)+(num-test (make-rectangular 0.00000001 -0.00000001) 0.00000001-0.00000001i)+(num-test (make-rectangular -0.00000001 -0.00000001) -0.00000001-0.00000001i)+(num-test (make-polar 0.00000001 0.00000001) 0.00000001+1e-16i)+(num-test (make-polar -0.00000001 0.00000001) -0.00000001-1e-16i)+(num-test (make-polar 0.00000001 -0.00000001) 0.00000001-1e-16i)+(num-test (make-polar -0.00000001 -0.00000001) -0.00000001+1e-16i)+(num-test (make-rectangular 0.00000001 1.0) 0.00000001+1.0i)+(num-test (make-rectangular -0.00000001 1.0) -0.00000001+1.0i)+(num-test (make-rectangular 0.00000001 -1.0) 0.00000001-1.0i)+(num-test (make-rectangular -0.00000001 -1.0) -0.00000001-1.0i)+(num-test (make-polar 0.00000001 1.0) 0.00000000540302+0.00000000841471i)+(num-test (make-polar -0.00000001 1.0) -0.00000000540302-0.00000000841471i)+(num-test (make-polar 0.00000001 -1.0) 0.00000000540302-0.00000000841471i)+(num-test (make-polar -0.00000001 -1.0) -0.00000000540302+0.00000000841471i)+(num-test (make-rectangular 0.00000001 our-pi) 0.00000001+3.14159265358979i)+(num-test (make-rectangular -0.00000001 our-pi) -0.00000001+3.14159265358979i)+(num-test (make-rectangular 0.00000001 -3.14159265358979) 0.00000001-3.14159265358979i)+(num-test (make-rectangular -0.00000001 -3.14159265358979) -0.00000001-3.14159265358979i)+(num-test (make-polar 0.00000001 our-pi) -0.00000001+0.0i)+(num-test (make-polar -0.00000001 our-pi) 0.00000001-0.0i)+(num-test (make-polar 0.00000001 -3.14159265358979) -0.00000001-0.0i)+(num-test (make-polar -0.00000001 -3.14159265358979) 0.00000001+0.0i)+(num-test (make-rectangular 0.00000001 2.71828182845905) 0.00000001+2.71828182845905i)+(num-test (make-rectangular -0.00000001 2.71828182845905) -0.00000001+2.71828182845905i)+(num-test (make-rectangular 0.00000001 -2.71828182845905) 0.00000001-2.71828182845905i)+(num-test (make-rectangular -0.00000001 -2.71828182845905) -0.00000001-2.71828182845905i)+(num-test (make-polar 0.00000001 2.71828182845905) -0.00000000911734+0.00000000410781i)+(num-test (make-polar -0.00000001 2.71828182845905) 0.00000000911734-0.00000000410781i)+(num-test (make-polar 0.00000001 -2.71828182845905) -0.00000000911734-0.00000000410781i)+(num-test (make-polar -0.00000001 -2.71828182845905) 0.00000000911734+0.00000000410781i)+(num-test (make-rectangular 0.00000001 1234.0) 0.00000001+1234.0i)+(num-test (make-rectangular -0.00000001 1234.0) -0.00000001+1234.0i)+(num-test (make-rectangular 0.00000001 -1234.0) 0.00000001-1234.0i)+(num-test (make-rectangular -0.00000001 -1234.0) -0.00000001-1234.0i)+(num-test (make-polar 0.00000001 1234.0) -0.00000000798551+0.00000000601928i)+(num-test (make-polar -0.00000001 1234.0) 0.00000000798551-0.00000000601928i)+(num-test (make-polar 0.00000001 -1234.0) -0.00000000798551-0.00000000601928i)+(num-test (make-polar -0.00000001 -1234.0) 0.00000000798551+0.00000000601928i)+(num-test (make-rectangular 0.00000001 1234000000.0) 0.00000001+1234000000.0i)+(num-test (make-rectangular -0.00000001 1234000000.0) -0.00000001+1234000000.0i)+(num-test (make-rectangular 0.00000001 -1234000000.0) 0.00000001-1234000000.0i)+(num-test (make-rectangular -0.00000001 -1234000000.0) -0.00000001-1234000000.0i)+(num-test (make-polar 0.00000001 1234000000.0) 0.00000000158909-0.00000000987293i)+(num-test (make-polar -0.00000001 1234000000.0) -0.00000000158909+0.00000000987293i)+(num-test (make-polar 0.00000001 -1234000000.0) 0.00000000158909+0.00000000987293i)+(num-test (make-polar -0.00000001 -1234000000.0) -0.00000000158909-0.00000000987293i)+(num-test (make-rectangular 1.0 0.00000001) 1.0+0.00000001i)+(num-test (make-rectangular -1.0 0.00000001) -1.0+0.00000001i)+(num-test (make-rectangular 1.0 -0.00000001) 1.0-0.00000001i)+(num-test (make-rectangular -1.0 -0.00000001) -1.0-0.00000001i)+(num-test (make-polar 1.0 0.00000001) 1.0+0.00000001i)+(num-test (make-polar -1.0 0.00000001) -1.0-0.00000001i)+(num-test (make-polar 1.0 -0.00000001) 1.0-0.00000001i)+(num-test (make-polar -1.0 -0.00000001) -1.0+0.00000001i)+(num-test (make-rectangular 1.0 1.0) 1.0+1.0i)+(num-test (make-rectangular -1.0 1.0) -1.0+1.0i)+(num-test (make-rectangular 1.0 -1.0) 1.0-1.0i)+(num-test (make-rectangular -1.0 -1.0) -1.0-1.0i)+(num-test (make-polar 1.0 1.0) 0.54030230586814+0.84147098480790i)+(num-test (make-polar -1.0 1.0) -0.54030230586814-0.84147098480790i)+(num-test (make-polar 1.0 -1.0) 0.54030230586814-0.84147098480790i)+(num-test (make-polar -1.0 -1.0) -0.54030230586814+0.84147098480790i)+(num-test (make-rectangular 1.0 our-pi) 1.0+3.14159265358979i)+(num-test (make-rectangular -1.0 our-pi) -1.0+3.14159265358979i)+(num-test (make-rectangular 1.0 -3.14159265358979) 1.0-3.14159265358979i)+(num-test (make-rectangular -1.0 -3.14159265358979) -1.0-3.14159265358979i)+(num-test (make-polar 1.0 our-pi) -1.0+0.0i)+(num-test (make-polar -1.0 our-pi) 1.0-0.0i)+(num-test (make-polar 1.0 -3.14159265358979) -1.0-0.0i)+(num-test (make-polar -1.0 -3.14159265358979) 1.0+0.0i)+(num-test (make-rectangular 1.0 2.71828182845905) 1.0+2.71828182845905i)+(num-test (make-rectangular -1.0 2.71828182845905) -1.0+2.71828182845905i)+(num-test (make-rectangular 1.0 -2.71828182845905) 1.0-2.71828182845905i)+(num-test (make-rectangular -1.0 -2.71828182845905) -1.0-2.71828182845905i)+(num-test (make-polar 1.0 2.71828182845905) -0.91173391478697+0.41078129050291i)+(num-test (make-polar -1.0 2.71828182845905) 0.91173391478697-0.41078129050291i)+(num-test (make-polar 1.0 -2.71828182845905) -0.91173391478697-0.41078129050291i)+(num-test (make-polar -1.0 -2.71828182845905) 0.91173391478697+0.41078129050291i)+(num-test (make-rectangular 1.0 1234.0) 1.0+1234.0i)+(num-test (make-rectangular -1.0 1234.0) -1.0+1234.0i)+(num-test (make-rectangular 1.0 -1234.0) 1.0-1234.0i)+(num-test (make-rectangular -1.0 -1234.0) -1.0-1234.0i)+(num-test (make-polar 1.0 1234.0) -0.79855062358758+0.60192765476250i)+(num-test (make-polar -1.0 1234.0) 0.79855062358758-0.60192765476250i)+(num-test (make-polar 1.0 -1234.0) -0.79855062358758-0.60192765476250i)+(num-test (make-polar -1.0 -1234.0) 0.79855062358758+0.60192765476250i)+(num-test (make-rectangular 1.0 1234000000.0) 1.0+1234000000.0i)+(num-test (make-rectangular -1.0 1234000000.0) -1.0+1234000000.0i)+(num-test (make-rectangular 1.0 -1234000000.0) 1.0-1234000000.0i)+(num-test (make-rectangular -1.0 -1234000000.0) -1.0-1234000000.0i)+(num-test (make-polar 1.0 1234000000.0) 0.15890913095152-0.98729321283003i)+(num-test (make-polar -1.0 1234000000.0) -0.15890913095152+0.98729321283003i)+(num-test (make-polar 1.0 -1234000000.0) 0.15890913095152+0.98729321283003i)+(num-test (make-polar -1.0 -1234000000.0) -0.15890913095152-0.98729321283003i)+(num-test (make-rectangular 3.14159265358979 0.00000001) 3.14159265358979+0.00000001i)+(num-test (make-rectangular -3.14159265358979 0.00000001) -3.14159265358979+0.00000001i)+(num-test (make-rectangular 3.14159265358979 -0.00000001) 3.14159265358979-0.00000001i)+(num-test (make-rectangular -3.14159265358979 -0.00000001) -3.14159265358979-0.00000001i)+(num-test (make-polar 3.14159265358979 0.00000001) 3.14159265358979+0.00000003141593i)+(num-test (make-polar -3.14159265358979 0.00000001) -3.14159265358979-0.00000003141593i)+(num-test (make-polar 3.14159265358979 -0.00000001) 3.14159265358979-0.00000003141593i)+(num-test (make-polar -3.14159265358979 -0.00000001) -3.14159265358979+0.00000003141593i)+(num-test (make-rectangular 3.14159265358979 1.0) 3.14159265358979+1.0i)+(num-test (make-rectangular -3.14159265358979 1.0) -3.14159265358979+1.0i)+(num-test (make-rectangular 3.14159265358979 -1.0) 3.14159265358979-1.0i)+(num-test (make-rectangular -3.14159265358979 -1.0) -3.14159265358979-1.0i)+(num-test (make-polar 3.14159265358979 1.0) 1.69740975483297+2.64355906408146i)+(num-test (make-polar -3.14159265358979 1.0) -1.69740975483297-2.64355906408146i)+(num-test (make-polar 3.14159265358979 -1.0) 1.69740975483297-2.64355906408146i)+(num-test (make-polar -3.14159265358979 -1.0) -1.69740975483297+2.64355906408146i)+(num-test (make-rectangular 3.14159265358979 our-pi) 3.14159265358979+3.14159265358979i)+(num-test (make-rectangular -3.14159265358979 our-pi) -3.14159265358979+3.14159265358979i)+(num-test (make-rectangular 3.14159265358979 -3.14159265358979) 3.14159265358979-3.14159265358979i)+(num-test (make-rectangular -3.14159265358979 -3.14159265358979) -3.14159265358979-3.14159265358979i)+(num-test (make-polar 3.14159265358979 our-pi) -3.14159265358979+0.0i)+(num-test (make-polar -3.14159265358979 our-pi) 3.14159265358979-0.0i)+(num-test (make-polar 3.14159265358979 -3.14159265358979) -3.14159265358979-0.0i)+(num-test (make-polar -3.14159265358979 -3.14159265358979) 3.14159265358979+0.0i)+(num-test (make-rectangular 3.14159265358979 2.71828182845905) 3.14159265358979+2.71828182845905i)+(num-test (make-rectangular -3.14159265358979 2.71828182845905) -3.14159265358979+2.71828182845905i)+(num-test (make-rectangular 3.14159265358979 -2.71828182845905) 3.14159265358979-2.71828182845905i)+(num-test (make-rectangular -3.14159265358979 -2.71828182845905) -3.14159265358979-2.71828182845905i)+(num-test (make-polar 3.14159265358979 2.71828182845905) -2.86429656872339+1.29050748447607i)+(num-test (make-polar -3.14159265358979 2.71828182845905) 2.86429656872339-1.29050748447607i)+(num-test (make-polar 3.14159265358979 -2.71828182845905) -2.86429656872339-1.29050748447607i)+(num-test (make-polar -3.14159265358979 -2.71828182845905) 2.86429656872339+1.29050748447607i)+(num-test (make-rectangular 3.14159265358979 1234.0) 3.14159265358979+1234.0i)+(num-test (make-rectangular -3.14159265358979 1234.0) -3.14159265358979+1234.0i)+(num-test (make-rectangular 3.14159265358979 -1234.0) 3.14159265358979-1234.0i)+(num-test (make-rectangular -3.14159265358979 -1234.0) -3.14159265358979-1234.0i)+(num-test (make-polar 3.14159265358979 1234.0) -2.50872077258230+1.89101149819439i)+(num-test (make-polar -3.14159265358979 1234.0) 2.50872077258230-1.89101149819439i)+(num-test (make-polar 3.14159265358979 -1234.0) -2.50872077258230-1.89101149819439i)+(num-test (make-polar -3.14159265358979 -1234.0) 2.50872077258230+1.89101149819439i)+(num-test (make-rectangular 3.14159265358979 1234000000.0) 3.14159265358979+1234000000.0i)+(num-test (make-rectangular -3.14159265358979 1234000000.0) -3.14159265358979+1234000000.0i)+(num-test (make-rectangular 3.14159265358979 -1234000000.0) 3.14159265358979-1234000000.0i)+(num-test (make-rectangular -3.14159265358979 -1234000000.0) -3.14159265358979-1234000000.0i)+(num-test (make-polar 3.14159265358979 1234000000.0) 0.49922775838562-3.10167310436587i)+(num-test (make-polar -3.14159265358979 1234000000.0) -0.49922775838562+3.10167310436587i)+(num-test (make-polar 3.14159265358979 -1234000000.0) 0.49922775838562+3.10167310436587i)+(num-test (make-polar -3.14159265358979 -1234000000.0) -0.49922775838562-3.10167310436587i)+(num-test (make-rectangular 2.71828182845905 0.00000001) 2.71828182845905+0.00000001i)+(num-test (make-rectangular -2.71828182845905 0.00000001) -2.71828182845905+0.00000001i)+(num-test (make-rectangular 2.71828182845905 -0.00000001) 2.71828182845905-0.00000001i)+(num-test (make-rectangular -2.71828182845905 -0.00000001) -2.71828182845905-0.00000001i)+(num-test (make-polar 2.71828182845905 0.00000001) 2.71828182845905+0.00000002718282i)+(num-test (make-polar -2.71828182845905 0.00000001) -2.71828182845905-0.00000002718282i)+(num-test (make-polar 2.71828182845905 -0.00000001) 2.71828182845905-0.00000002718282i)+(num-test (make-polar -2.71828182845905 -0.00000001) -2.71828182845905+0.00000002718282i)+(num-test (make-rectangular 2.71828182845905 1.0) 2.71828182845905+1.0i)+(num-test (make-rectangular -2.71828182845905 1.0) -2.71828182845905+1.0i)+(num-test (make-rectangular 2.71828182845905 -1.0) 2.71828182845905-1.0i)+(num-test (make-rectangular -2.71828182845905 -1.0) -2.71828182845905-1.0i)+(num-test (make-polar 2.71828182845905 1.0) 1.46869393991589+2.28735528717884i)+(num-test (make-polar -2.71828182845905 1.0) -1.46869393991589-2.28735528717884i)+(num-test (make-polar 2.71828182845905 -1.0) 1.46869393991589-2.28735528717884i)+(num-test (make-polar -2.71828182845905 -1.0) -1.46869393991589+2.28735528717884i)+(num-test (make-rectangular 2.71828182845905 our-pi) 2.71828182845905+3.14159265358979i)+(num-test (make-rectangular -2.71828182845905 our-pi) -2.71828182845905+3.14159265358979i)+(num-test (make-rectangular 2.71828182845905 -3.14159265358979) 2.71828182845905-3.14159265358979i)+(num-test (make-rectangular -2.71828182845905 -3.14159265358979) -2.71828182845905-3.14159265358979i)+(num-test (make-polar 2.71828182845905 our-pi) -2.71828182845905+0.0i)+(num-test (make-polar -2.71828182845905 our-pi) 2.71828182845905-0.0i)+(num-test (make-polar 2.71828182845905 -3.14159265358979) -2.71828182845905-0.0i)+(num-test (make-polar -2.71828182845905 -3.14159265358979) 2.71828182845905+0.0i)+(num-test (make-rectangular 2.71828182845905 2.71828182845905) 2.71828182845905+2.71828182845905i)+(num-test (make-rectangular -2.71828182845905 2.71828182845905) -2.71828182845905+2.71828182845905i)+(num-test (make-rectangular 2.71828182845905 -2.71828182845905) 2.71828182845905-2.71828182845905i)+(num-test (make-rectangular -2.71828182845905 -2.71828182845905) -2.71828182845905-2.71828182845905i)+(num-test (make-polar 2.71828182845905 2.71828182845905) -2.47834973295523+1.11661931744501i)+(num-test (make-polar -2.71828182845905 2.71828182845905) 2.47834973295523-1.11661931744501i)+(num-test (make-polar 2.71828182845905 -2.71828182845905) -2.47834973295523-1.11661931744501i)+(num-test (make-polar -2.71828182845905 -2.71828182845905) 2.47834973295523+1.11661931744501i)+(num-test (make-rectangular 2.71828182845905 1234.0) 2.71828182845905+1234.0i)+(num-test (make-rectangular -2.71828182845905 1234.0) -2.71828182845905+1234.0i)+(num-test (make-rectangular 2.71828182845905 -1234.0) 2.71828182845905-1234.0i)+(num-test (make-rectangular -2.71828182845905 -1234.0) -2.71828182845905-1234.0i)+(num-test (make-polar 2.71828182845905 1234.0) -2.17068564920277+1.63620900598787i)+(num-test (make-polar -2.71828182845905 1234.0) 2.17068564920277-1.63620900598787i)+(num-test (make-polar 2.71828182845905 -1234.0) -2.17068564920277-1.63620900598787i)+(num-test (make-polar -2.71828182845905 -1234.0) 2.17068564920277+1.63620900598787i)+(num-test (make-rectangular 2.71828182845905 1234000000.0) 2.71828182845905+1234000000.0i)+(num-test (make-rectangular -2.71828182845905 1234000000.0) -2.71828182845905+1234000000.0i)+(num-test (make-rectangular 2.71828182845905 -1234000000.0) 2.71828182845905-1234000000.0i)+(num-test (make-rectangular -2.71828182845905 -1234000000.0) -2.71828182845905-1234000000.0i)+(num-test (make-polar 2.71828182845905 1234000000.0) 0.43195980304173-2.68374119979681i)+(num-test (make-polar -2.71828182845905 1234000000.0) -0.43195980304173+2.68374119979681i)+(num-test (make-polar 2.71828182845905 -1234000000.0) 0.43195980304173+2.68374119979681i)+(num-test (make-polar -2.71828182845905 -1234000000.0) -0.43195980304173-2.68374119979681i)+(num-test (make-rectangular 1234.0 0.00000001) 1234.0+0.00000001i)+(num-test (make-rectangular -1234.0 0.00000001) -1234.0+0.00000001i)+(num-test (make-rectangular 1234.0 -0.00000001) 1234.0-0.00000001i)+(num-test (make-rectangular -1234.0 -0.00000001) -1234.0-0.00000001i)+(num-test (make-polar 1234.0 0.00000001) 1234.0+0.00001234000000i)+(num-test (make-polar -1234.0 0.00000001) -1234.0-0.00001234000000i)+(num-test (make-polar 1234.0 -0.00000001) 1234.0-0.00001234000000i)+(num-test (make-polar -1234.0 -0.00000001) -1234.0+0.00001234000000i)+(num-test (make-rectangular 1234.0 1.0) 1234.0+1.0i)+(num-test (make-rectangular -1234.0 1.0) -1234.0+1.0i)+(num-test (make-rectangular 1234.0 -1.0) 1234.0-1.0i)+(num-test (make-rectangular -1234.0 -1.0) -1234.0-1.0i)+(num-test (make-polar 1234.0 1.0) 666.73304544128450+1038.37519525294420i)+(num-test (make-polar -1234.0 1.0) -666.73304544128450-1038.37519525294420i)+(num-test (make-polar 1234.0 -1.0) 666.73304544128450-1038.37519525294420i)+(num-test (make-polar -1234.0 -1.0) -666.73304544128450+1038.37519525294420i)+(num-test (make-rectangular 1234.0 our-pi) 1234.0+3.14159265358979i)+(num-test (make-rectangular -1234.0 our-pi) -1234.0+3.14159265358979i)+(num-test (make-rectangular 1234.0 -3.14159265358979) 1234.0-3.14159265358979i)+(num-test (make-rectangular -1234.0 -3.14159265358979) -1234.0-3.14159265358979i)+(num-test (make-polar 1234.0 our-pi) -1234.0+0.00000000000015i)+(num-test (make-polar -1234.0 our-pi) 1234.0-0.00000000000015i)+(num-test (make-polar 1234.0 -3.14159265358979) -1234.0-0.00000000000015i)+(num-test (make-polar -1234.0 -3.14159265358979) 1234.0+0.00000000000015i)+(num-test (make-rectangular 1234.0 2.71828182845905) 1234.0+2.71828182845905i)+(num-test (make-rectangular -1234.0 2.71828182845905) -1234.0+2.71828182845905i)+(num-test (make-rectangular 1234.0 -2.71828182845905) 1234.0-2.71828182845905i)+(num-test (make-rectangular -1234.0 -2.71828182845905) -1234.0-2.71828182845905i)+(num-test (make-polar 1234.0 2.71828182845905) -1125.07965084711486+506.90411248058950i)+(num-test (make-polar -1234.0 2.71828182845905) 1125.07965084711486-506.90411248058950i)+(num-test (make-polar 1234.0 -2.71828182845905) -1125.07965084711486-506.90411248058950i)+(num-test (make-polar -1234.0 -2.71828182845905) 1125.07965084711486+506.90411248058950i)+(num-test (make-rectangular 1234.0 1234.0) 1234.0+1234.0i)+(num-test (make-rectangular -1234.0 1234.0) -1234.0+1234.0i)+(num-test (make-rectangular 1234.0 -1234.0) 1234.0-1234.0i)+(num-test (make-rectangular -1234.0 -1234.0) -1234.0-1234.0i)+(num-test (make-polar 1234.0 1234.0) -985.41146950707912+742.77872597692169i)+(num-test (make-polar -1234.0 1234.0) 985.41146950707912-742.77872597692169i)+(num-test (make-polar 1234.0 -1234.0) -985.41146950707912-742.77872597692169i)+(num-test (make-polar -1234.0 -1234.0) 985.41146950707912+742.77872597692169i)+(num-test (make-rectangular 1234.0 1234000000.0) 1234.0+1234000000.0i)+(num-test (make-rectangular -1234.0 1234000000.0) -1234.0+1234000000.0i)+(num-test (make-rectangular 1234.0 -1234000000.0) 1234.0-1234000000.0i)+(num-test (make-rectangular -1234.0 -1234000000.0) -1234.0-1234000000.0i)+(num-test (make-polar 1234.0 1234000000.0) 196.09386759417183-1218.31982463225131i)+(num-test (make-polar -1234.0 1234000000.0) -196.09386759417183+1218.31982463225131i)+(num-test (make-polar 1234.0 -1234000000.0) 196.09386759417183+1218.31982463225131i)+(num-test (make-polar -1234.0 -1234000000.0) -196.09386759417183-1218.31982463225131i)+(num-test (make-rectangular 1234000000.0 0.00000001) 1234000000.0+0.00000001i)+(num-test (make-rectangular -1234000000.0 0.00000001) -1234000000.0+0.00000001i)+(num-test (make-rectangular 1234000000.0 -0.00000001) 1234000000.0-0.00000001i)+(num-test (make-rectangular -1234000000.0 -0.00000001) -1234000000.0-0.00000001i)+(num-test (make-polar 1234000000.0 0.00000001) 1234000000.0+12.34000000000000i)+(num-test (make-polar -1234000000.0 0.00000001) -1234000000.0-12.34000000000000i)+(num-test (make-polar 1234000000.0 -0.00000001) 1234000000.0-12.34000000000000i)+(num-test (make-polar -1234000000.0 -0.00000001) -1234000000.0+12.34000000000000i)+(num-test (make-rectangular 1234000000.0 1.0) 1234000000.0+1.0i)+(num-test (make-rectangular -1234000000.0 1.0) -1234000000.0+1.0i)+(num-test (make-rectangular 1234000000.0 -1.0) 1234000000.0-1.0i)+(num-test (make-rectangular -1234000000.0 -1.0) -1234000000.0-1.0i)+(num-test (make-polar 1234000000.0 1.0) 666733045.44128441810608+1038375195.25294423103333i)+(num-test (make-polar -1234000000.0 1.0) -666733045.44128441810608-1038375195.25294423103333i)+(num-test (make-polar 1234000000.0 -1.0) 666733045.44128441810608-1038375195.25294423103333i)+(num-test (make-polar -1234000000.0 -1.0) -666733045.44128441810608+1038375195.25294423103333i)+(num-test (make-rectangular 1234000000.0 our-pi) 1234000000.0+3.14159265358979i)+(num-test (make-rectangular -1234000000.0 our-pi) -1234000000.0+3.14159265358979i)+(num-test (make-rectangular 1234000000.0 -3.14159265358979) 1234000000.0-3.14159265358979i)+(num-test (make-rectangular -1234000000.0 -3.14159265358979) -1234000000.0-3.14159265358979i)+(num-test (make-polar 1234000000.0 our-pi) -1234000000.0+0.00000015111642i)+(num-test (make-polar -1234000000.0 our-pi) 1234000000.0-0.00000015111642i)+(num-test (make-polar 1234000000.0 -3.14159265358979) -1234000000.0-0.00000015111642i)+(num-test (make-polar -1234000000.0 -3.14159265358979) 1234000000.0+0.00000015111642i)+(num-test (make-rectangular 1234000000.0 2.71828182845905) 1234000000.0+2.71828182845905i)+(num-test (make-rectangular -1234000000.0 2.71828182845905) -1234000000.0+2.71828182845905i)+(num-test (make-rectangular 1234000000.0 -2.71828182845905) 1234000000.0-2.71828182845905i)+(num-test (make-rectangular -1234000000.0 -2.71828182845905) -1234000000.0-2.71828182845905i)+(num-test (make-polar 1234000000.0 2.71828182845905) -1125079650.84711480140686+506904112.48058950901031i)+(num-test (make-polar -1234000000.0 2.71828182845905) 1125079650.84711480140686-506904112.48058950901031i)+(num-test (make-polar 1234000000.0 -2.71828182845905) -1125079650.84711480140686-506904112.48058950901031i)+(num-test (make-polar -1234000000.0 -2.71828182845905) 1125079650.84711480140686+506904112.48058950901031i)+(num-test (make-rectangular 1234000000.0 1234.0) 1234000000.0+1234.0i)+(num-test (make-rectangular -1234000000.0 1234.0) -1234000000.0+1234.0i)+(num-test (make-rectangular 1234000000.0 -1234.0) 1234000000.0-1234.0i)+(num-test (make-rectangular -1234000000.0 -1234.0) -1234000000.0-1234.0i)+(num-test (make-polar 1234000000.0 1234.0) -985411469.50707900524139+742778725.97692167758942i)+(num-test (make-polar -1234000000.0 1234.0) 985411469.50707900524139-742778725.97692167758942i)+(num-test (make-polar 1234000000.0 -1234.0) -985411469.50707900524139-742778725.97692167758942i)+(num-test (make-polar -1234000000.0 -1234.0) 985411469.50707900524139+742778725.97692167758942i)+(num-test (make-rectangular 1234000000.0 1234000000.0) 1234000000.0+1234000000.0i)+(num-test (make-rectangular -1234000000.0 1234000000.0) -1234000000.0+1234000000.0i)+(num-test (make-rectangular 1234000000.0 -1234000000.0) 1234000000.0-1234000000.0i)+(num-test (make-rectangular -1234000000.0 -1234000000.0) -1234000000.0-1234000000.0i)+(num-test (make-polar 1234000000.0 1234000000.0) 196093867.59417182207108-1218319824.63225126266479i)+(num-test (make-polar -1234000000.0 1234000000.0) -196093867.59417182207108+1218319824.63225126266479i)+(num-test (make-polar 1234000000.0 -1234000000.0) 196093867.59417182207108+1218319824.63225126266479i)+(num-test (make-polar -1234000000.0 -1234000000.0) -196093867.59417182207108-1218319824.63225126266479i)+(num-test (make-polar 0 0) 0)+(num-test (make-polar 0.0 0.0) 0.0)+(num-test (make-rectangular 0 0) 0)+(num-test (make-rectangular 0.0 0.0) 0.0)+++;; -------- angle+(num-test (angle 1) 0)+(num-test (angle -1) our-pi)+(num-test (angle 1/1) 0)+(num-test (angle -1/1) our-pi)+(num-test (angle 1/2) 0)+(num-test (angle -1/2) our-pi)+(num-test (angle 1/3) 0)+(num-test (angle -1/3) our-pi)+(num-test (angle 1/10) 0)+(num-test (angle -1/10) our-pi)+(num-test (angle 1/1234) 0)+(num-test (angle -1/1234) our-pi)+(num-test (angle 1/1234000000) 0)+(num-test (angle -1/1234000000) our-pi)+(num-test (angle 1/500029) 0)+(num-test (angle -1/500029) our-pi)+(num-test (angle 1/362880) 0)+(num-test (angle -1/362880) our-pi)+(num-test (angle 2) 0)+(num-test (angle -2) our-pi)+(num-test (angle 2/1) 0)+(num-test (angle -2/1) our-pi)+(num-test (angle 2/2) 0)+(num-test (angle -2/2) our-pi)+(num-test (angle 2/3) 0)+(num-test (angle -2/3) our-pi)+(num-test (angle 2/10) 0)+(num-test (angle -2/10) our-pi)+(num-test (angle 2/1234) 0)+(num-test (angle -2/1234) our-pi)+(num-test (angle 2/1234000000) 0)+(num-test (angle -2/1234000000) our-pi)+(num-test (angle 2/500029) 0)+(num-test (angle -2/500029) our-pi)+(num-test (angle 2/362880) 0)+(num-test (angle -2/362880) our-pi)+(num-test (angle 3) 0)+(num-test (angle -3) our-pi)+(num-test (angle 3/1) 0)+(num-test (angle -3/1) our-pi)+(num-test (angle 3/2) 0)+(num-test (angle -3/2) our-pi)+(num-test (angle 3/3) 0)+(num-test (angle -3/3) our-pi)+(num-test (angle 3/10) 0)+(num-test (angle -3/10) our-pi)+(num-test (angle 3/1234) 0)+(num-test (angle -3/1234) our-pi)+(num-test (angle 3/1234000000) 0)+(num-test (angle -3/1234000000) our-pi)+(num-test (angle 3/500029) 0)+(num-test (angle -3/500029) our-pi)+(num-test (angle 3/362880) 0)+(num-test (angle -3/362880) our-pi)+(num-test (angle 10) 0)+(num-test (angle -10) our-pi)+(num-test (angle 10/1) 0)+(num-test (angle -10/1) our-pi)+(num-test (angle 10/2) 0)+(num-test (angle -10/2) our-pi)+(num-test (angle 10/3) 0)+(num-test (angle -10/3) our-pi)+(num-test (angle 10/10) 0)+(num-test (angle -10/10) our-pi)+(num-test (angle 10/1234) 0)+(num-test (angle -10/1234) our-pi)+(num-test (angle 10/1234000000) 0)+(num-test (angle -10/1234000000) our-pi)+(num-test (angle 10/500029) 0)+(num-test (angle -10/500029) our-pi)+(num-test (angle 10/362880) 0)+(num-test (angle -10/362880) our-pi)+(num-test (angle 1234) 0)+(num-test (angle -1234) our-pi)+(num-test (angle 1234/1) 0)+(num-test (angle -1234/1) our-pi)+(num-test (angle 1234/2) 0)+(num-test (angle -1234/2) our-pi)+(num-test (angle 1234/3) 0)+(num-test (angle -1234/3) our-pi)+(num-test (angle 1234/10) 0)+(num-test (angle -1234/10) our-pi)+(num-test (angle 1234/1234) 0)+(num-test (angle -1234/1234) our-pi)+(num-test (angle 1234/1234000000) 0)+(num-test (angle -1234/1234000000) our-pi)+(num-test (angle 1234/500029) 0)+(num-test (angle -1234/500029) our-pi)+(num-test (angle 1234/362880) 0)+(num-test (angle -1234/362880) our-pi)+(num-test (angle 1234000000) 0)+(num-test (angle -1234000000) our-pi)+(num-test (angle 1234000000/1) 0)+(num-test (angle -1234000000/1) our-pi)+(num-test (angle 1234000000/2) 0)+(num-test (angle -1234000000/2) our-pi)+(num-test (angle 1234000000/3) 0)+(num-test (angle -1234000000/3) our-pi)+(num-test (angle 1234000000/10) 0)+(num-test (angle -1234000000/10) our-pi)+(num-test (angle 1234000000/1234) 0)+(num-test (angle -1234000000/1234) our-pi)+(num-test (angle 1234000000/1234000000) 0)+(num-test (angle -1234000000/1234000000) our-pi)+(num-test (angle 1234000000/500029) 0)+(num-test (angle -1234000000/500029) our-pi)+(num-test (angle 1234000000/362880) 0)+(num-test (angle -1234000000/362880) our-pi)+(num-test (angle 500029) 0)+(num-test (angle -500029) our-pi)+(num-test (angle 500029/1) 0)+(num-test (angle -500029/1) our-pi)+(num-test (angle 500029/2) 0)+(num-test (angle -500029/2) our-pi)+(num-test (angle 500029/3) 0)+(num-test (angle -500029/3) our-pi)+(num-test (angle 500029/10) 0)+(num-test (angle -500029/10) our-pi)+(num-test (angle 500029/1234) 0)+(num-test (angle -500029/1234) our-pi)+(num-test (angle 500029/1234000000) 0)+(num-test (angle -500029/1234000000) our-pi)+(num-test (angle 500029/500029) 0)+(num-test (angle -500029/500029) our-pi)+(num-test (angle 500029/362880) 0)+(num-test (angle -500029/362880) our-pi)+(num-test (angle 362880) 0)+(num-test (angle -362880) our-pi)+(num-test (angle 362880/1) 0)+(num-test (angle -362880/1) our-pi)+(num-test (angle 362880/2) 0)+(num-test (angle -362880/2) our-pi)+(num-test (angle 362880/3) 0)+(num-test (angle -362880/3) our-pi)+(num-test (angle 362880/10) 0)+(num-test (angle -362880/10) our-pi)+(num-test (angle 362880/1234) 0)+(num-test (angle -362880/1234) our-pi)+(num-test (angle 362880/1234000000) 0)+(num-test (angle -362880/1234000000) our-pi)+(num-test (angle 362880/500029) 0)+(num-test (angle -362880/500029) our-pi)+(num-test (angle 362880/362880) 0)+(num-test (angle -362880/362880) our-pi)+(num-test (angle 0.0+0.00000001i) 1.57079632679490)+(num-test (angle -0.0+0.00000001i) 1.57079632679490)+(num-test (angle 0.0-0.00000001i) -1.57079632679490)+(num-test (angle -0.0-0.00000001i) -1.57079632679490)+(num-test (angle 0.0+1.0i) 1.57079632679490)+(num-test (angle -0.0+1.0i) 1.57079632679490)+(num-test (angle 0.0-1.0i) -1.57079632679490)+(num-test (angle -0.0-1.0i) -1.57079632679490)+(num-test (angle 0.0+3.14159265358979i) 1.57079632679490)+(num-test (angle -0.0+3.14159265358979i) 1.57079632679490)+(num-test (angle 0.0-3.14159265358979i) -1.57079632679490)+(num-test (angle -0.0-3.14159265358979i) -1.57079632679490)+(num-test (angle 0.0+2.71828182845905i) 1.57079632679490)+(num-test (angle -0.0+2.71828182845905i) 1.57079632679490)+(num-test (angle 0.0-2.71828182845905i) -1.57079632679490)+(num-test (angle -0.0-2.71828182845905i) -1.57079632679490)+(num-test (angle 0.0+1234.0i) 1.57079632679490)+(num-test (angle -0.0+1234.0i) 1.57079632679490)+(num-test (angle 0.0-1234.0i) -1.57079632679490)+(num-test (angle -0.0-1234.0i) -1.57079632679490)+(num-test (angle 0.0+1234000000.0i) 1.57079632679490)+(num-test (angle -0.0+1234000000.0i) 1.57079632679490)+(num-test (angle 0.0-1234000000.0i) -1.57079632679490)+(num-test (angle -0.0-1234000000.0i) -1.57079632679490)+(num-test (angle 0.00000001) 0.0)+(num-test (angle -0.00000001) our-pi)+(num-test (angle 0.00000001+0.00000001i) 0.78539816339745)+(num-test (angle -0.00000001+0.00000001i) 2.35619449019234)+(num-test (angle 0.00000001-0.00000001i) -0.78539816339745)+(num-test (angle -0.00000001-0.00000001i) -2.35619449019234)+(num-test (angle 0.00000001+1.0i) 1.57079631679490)+(num-test (angle -0.00000001+1.0i) 1.57079633679490)+(num-test (angle 0.00000001-1.0i) -1.57079631679490)+(num-test (angle -0.00000001-1.0i) -1.57079633679490)+(num-test (angle 0.00000001+3.14159265358979i) 1.57079632361180)+(num-test (angle -0.00000001+3.14159265358979i) 1.57079632997800)+(num-test (angle 0.00000001-3.14159265358979i) -1.57079632361180)+(num-test (angle -0.00000001-3.14159265358979i) -1.57079632997800)+(num-test (angle 0.00000001+2.71828182845905i) 1.57079632311610)+(num-test (angle -0.00000001+2.71828182845905i) 1.57079633047369)+(num-test (angle 0.00000001-2.71828182845905i) -1.57079632311610)+(num-test (angle -0.00000001-2.71828182845905i) -1.57079633047369)+(num-test (angle 0.00000001+1234.0i) 1.57079632678679)+(num-test (angle -0.00000001+1234.0i) 1.57079632680300)+(num-test (angle 0.00000001-1234.0i) -1.57079632678679)+(num-test (angle -0.00000001-1234.0i) -1.57079632680300)+(num-test (angle 0.00000001+1234000000.0i) 1.57079632679490)+(num-test (angle -0.00000001+1234000000.0i) 1.57079632679490)+(num-test (angle 0.00000001-1234000000.0i) -1.57079632679490)+(num-test (angle -0.00000001-1234000000.0i) -1.57079632679490)+(num-test (angle 1.0) 0.0)+(num-test (angle -1.0) our-pi)+(num-test (angle 1.0+0.00000001i) 0.00000001)+(num-test (angle -1.0+0.00000001i) 3.14159264358979)+(num-test (angle 1.0-0.00000001i) -0.00000001)+(num-test (angle -1.0-0.00000001i) -3.14159264358979)+(num-test (angle 1.0+1.0i) 0.78539816339745)+(num-test (angle -1.0+1.0i) 2.35619449019234)+(num-test (angle 1.0-1.0i) -0.78539816339745)+(num-test (angle -1.0-1.0i) -2.35619449019234)+(num-test (angle 1.0+3.14159265358979i) 1.26262725567891)+(num-test (angle -1.0+3.14159265358979i) 1.87896539791088)+(num-test (angle 1.0-3.14159265358979i) -1.26262725567891)+(num-test (angle -1.0-3.14159265358979i) -1.87896539791088)+(num-test (angle 1.0+2.71828182845905i) 1.21828290501728)+(num-test (angle -1.0+2.71828182845905i) 1.92330974857252)+(num-test (angle 1.0-2.71828182845905i) -1.21828290501728)+(num-test (angle -1.0-2.71828182845905i) -1.92330974857252)+(num-test (angle 1.0+1234.0i) 1.56998595420081)+(num-test (angle -1.0+1234.0i) 1.57160669938898)+(num-test (angle 1.0-1234.0i) -1.56998595420081)+(num-test (angle -1.0-1234.0i) -1.57160669938898)+(num-test (angle 1.0+1234000000.0i) 1.57079632598452)+(num-test (angle -1.0+1234000000.0i) 1.57079632760527)+(num-test (angle 1.0-1234000000.0i) -1.57079632598452)+(num-test (angle -1.0-1234000000.0i) -1.57079632760527)+(num-test (angle our-pi) 0.0)+(num-test (angle -3.14159265358979) our-pi)+(num-test (angle 3.14159265358979+0.00000001i) 0.00000000318310)+(num-test (angle -3.14159265358979+0.00000001i) 3.14159265040669)+(num-test (angle 3.14159265358979-0.00000001i) -0.00000000318310)+(num-test (angle -3.14159265358979-0.00000001i) -3.14159265040669)+(num-test (angle 3.14159265358979+1.0i) 0.30816907111598)+(num-test (angle -3.14159265358979+1.0i) 2.83342358247381)+(num-test (angle 3.14159265358979-1.0i) -0.30816907111598)+(num-test (angle -3.14159265358979-1.0i) -2.83342358247381)+(num-test (angle 3.14159265358979+3.14159265358979i) 0.78539816339745)+(num-test (angle -3.14159265358979+3.14159265358979i) 2.35619449019234)+(num-test (angle 3.14159265358979-3.14159265358979i) -0.78539816339745)+(num-test (angle -3.14159265358979-3.14159265358979i) -2.35619449019234)+(num-test (angle 3.14159265358979+2.71828182845905i) 0.71328454043905)+(num-test (angle -3.14159265358979+2.71828182845905i) 2.42830811315074)+(num-test (angle 3.14159265358979-2.71828182845905i) -0.71328454043905)+(num-test (angle -3.14159265358979-2.71828182845905i) -2.42830811315074)+(num-test (angle 3.14159265358979+1234.0i) 1.56825047114960)+(num-test (angle -3.14159265358979+1234.0i) 1.57334218244020)+(num-test (angle 3.14159265358979-1234.0i) -1.56825047114960)+(num-test (angle -3.14159265358979-1234.0i) -1.57334218244020)+(num-test (angle 3.14159265358979+1234000000.0i) 1.57079632424904)+(num-test (angle -3.14159265358979+1234000000.0i) 1.57079632934076)+(num-test (angle 3.14159265358979-1234000000.0i) -1.57079632424904)+(num-test (angle -3.14159265358979-1234000000.0i) -1.57079632934076)+(num-test (angle 2.71828182845905) 0.0)+(num-test (angle -2.71828182845905) our-pi)+(num-test (angle 2.71828182845905+0.00000001i) 0.00000000367879)+(num-test (angle -2.71828182845905+0.00000001i) 3.14159264991100)+(num-test (angle 2.71828182845905-0.00000001i) -0.00000000367879)+(num-test (angle -2.71828182845905-0.00000001i) -3.14159264991100)+(num-test (angle 2.71828182845905+1.0i) 0.35251342177762)+(num-test (angle -2.71828182845905+1.0i) 2.78907923181217)+(num-test (angle 2.71828182845905-1.0i) -0.35251342177762)+(num-test (angle -2.71828182845905-1.0i) -2.78907923181217)+(num-test (angle 2.71828182845905+3.14159265358979i) 0.85751178635585)+(num-test (angle -2.71828182845905+3.14159265358979i) 2.28408086723395)+(num-test (angle 2.71828182845905-3.14159265358979i) -0.85751178635585)+(num-test (angle -2.71828182845905-3.14159265358979i) -2.28408086723395)+(num-test (angle 2.71828182845905+2.71828182845905i) 0.78539816339745)+(num-test (angle -2.71828182845905+2.71828182845905i) 2.35619449019234)+(num-test (angle 2.71828182845905-2.71828182845905i) -0.78539816339745)+(num-test (angle -2.71828182845905-2.71828182845905i) -2.35619449019234)+(num-test (angle 2.71828182845905+1234.0i) 1.56859350877892)+(num-test (angle -2.71828182845905+1234.0i) 1.57299914481088)+(num-test (angle 2.71828182845905-1234.0i) -1.56859350877892)+(num-test (angle -2.71828182845905-1234.0i) -1.57299914481088)+(num-test (angle 2.71828182845905+1234000000.0i) 1.57079632459208)+(num-test (angle -2.71828182845905+1234000000.0i) 1.57079632899772)+(num-test (angle 2.71828182845905-1234000000.0i) -1.57079632459208)+(num-test (angle -2.71828182845905-1234000000.0i) -1.57079632899772)+(num-test (angle 1234.0) 0.0)+(num-test (angle -1234.0) our-pi)+(num-test (angle 1234.0+0.00000001i) 0.00000000000810)+(num-test (angle -1234.0+0.00000001i) 3.14159265358169)+(num-test (angle 1234.0-0.00000001i) -0.00000000000810)+(num-test (angle -1234.0-0.00000001i) -3.14159265358169)+(num-test (angle 1234.0+1.0i) 0.00081037259408)+(num-test (angle -1234.0+1.0i) 3.14078228099571)+(num-test (angle 1234.0-1.0i) -0.00081037259408)+(num-test (angle -1234.0-1.0i) -3.14078228099571)+(num-test (angle 1234.0+3.14159265358979i) 0.00254585564530)+(num-test (angle -1234.0+3.14159265358979i) 3.13904679794449)+(num-test (angle 1234.0-3.14159265358979i) -0.00254585564530)+(num-test (angle -1234.0-3.14159265358979i) -3.13904679794449)+(num-test (angle 1234.0+2.71828182845905i) 0.00220281801598)+(num-test (angle -1234.0+2.71828182845905i) 3.13938983557381)+(num-test (angle 1234.0-2.71828182845905i) -0.00220281801598)+(num-test (angle -1234.0-2.71828182845905i) -3.13938983557381)+(num-test (angle 1234.0+1234.0i) 0.78539816339745)+(num-test (angle -1234.0+1234.0i) 2.35619449019234)+(num-test (angle 1234.0-1234.0i) -0.78539816339745)+(num-test (angle -1234.0-1234.0i) -2.35619449019234)+(num-test (angle 1234.0+1234000000.0i) 1.57079532679490)+(num-test (angle -1234.0+1234000000.0i) 1.57079732679490)+(num-test (angle 1234.0-1234000000.0i) -1.57079532679490)+(num-test (angle -1234.0-1234000000.0i) -1.57079732679490)+(num-test (angle 1234000000.0) 0.0)+(num-test (angle -1234000000.0) our-pi)+(num-test (angle 1234000000.0+0.00000001i) 0.0)+(num-test (angle -1234000000.0+0.00000001i) our-pi)+(num-test (angle 1234000000.0-0.00000001i) -0.0)+(num-test (angle -1234000000.0-0.00000001i) -3.14159265358979)+(num-test (angle 1234000000.0+1.0i) 0.00000000081037)+(num-test (angle -1234000000.0+1.0i) 3.14159265277942)+(num-test (angle 1234000000.0-1.0i) -0.00000000081037)+(num-test (angle -1234000000.0-1.0i) -3.14159265277942)+(num-test (angle 1234000000.0+3.14159265358979i) 0.00000000254586)+(num-test (angle -1234000000.0+3.14159265358979i) 3.14159265104393)+(num-test (angle 1234000000.0-3.14159265358979i) -0.00000000254586)+(num-test (angle -1234000000.0-3.14159265358979i) -3.14159265104393)+(num-test (angle 1234000000.0+2.71828182845905i) 0.00000000220282)+(num-test (angle -1234000000.0+2.71828182845905i) 3.14159265138697)+(num-test (angle 1234000000.0-2.71828182845905i) -0.00000000220282)+(num-test (angle -1234000000.0-2.71828182845905i) -3.14159265138697)+(num-test (angle 1234000000.0+1234.0i) 0.00000100000000)+(num-test (angle -1234000000.0+1234.0i) 3.14159165358979)+(num-test (angle 1234000000.0-1234.0i) -0.00000100000000)+(num-test (angle -1234000000.0-1234.0i) -3.14159165358979)+(num-test (angle 1234000000.0+1234000000.0i) 0.78539816339745)+(num-test (angle -1234000000.0+1234000000.0i) 2.35619449019234)+(num-test (angle 1234000000.0-1234000000.0i) -0.78539816339745)+(num-test (angle -1234000000.0-1234000000.0i) -2.35619449019234)+(num-test (angle 0.0e+00+0.0e+00i) 0e0+0.0i)+(num-test (angle 0.0e+00+1.19209289550781250e-07i) 1.5707963267948966192e0+0.0i)+(num-test (angle 0.0e+00-1.19209289550781250e-07i) -1.5707963267948966192e0+0.0i)+(num-test (angle 0.0e+00+5.0e-01i) 1.5707963267948966192e0+0.0i)+(num-test (angle 0.0e+00-5.0e-01i) -1.5707963267948966192e0+0.0i)+(num-test (angle 0.0e+00+1.0e+00i) 1.5707963267948966192e0+0.0i)+(num-test (angle 0.0e+00-1.0e+00i) -1.5707963267948966192e0+0.0i)+(num-test (angle 0.0e+00+2.0e+00i) 1.5707963267948966192e0+0.0i)+(num-test (angle 0.0e+00-2.0e+00i) -1.5707963267948966192e0+0.0i)+(num-test (angle 0.0e+00+8.3886080e+06i) 1.5707963267948966192e0+0.0i)+(num-test (angle 0.0e+00-8.3886080e+06i) -1.5707963267948966192e0+0.0i)+(num-test (angle 1.19209289550781250e-07+0.0e+00i) 0e0+0.0i)+(num-test (angle -1.19209289550781250e-07+0.0e+00i) 3.1415926535897932385e0+0.0i)+(num-test (angle 1.19209289550781250e-07+1.19209289550781250e-07i) 7.8539816339744830962e-1+0.0i)+(num-test (angle 1.19209289550781250e-07-1.19209289550781250e-07i) -7.8539816339744830962e-1+0.0i)+(num-test (angle -1.19209289550781250e-07+1.19209289550781250e-07i) 2.3561944901923449288e0+0.0i)+(num-test (angle -1.19209289550781250e-07-1.19209289550781250e-07i) -2.3561944901923449288e0+0.0i)+(num-test (angle 1.19209289550781250e-07+5.0e-01i) 1.5707960883763175177e0+0.0i)+(num-test (angle 1.19209289550781250e-07-5.0e-01i) -1.5707960883763175177e0+0.0i)+(num-test (angle -1.19209289550781250e-07+5.0e-01i) 1.5707965652134757208e0+0.0i)+(num-test (angle -1.19209289550781250e-07-5.0e-01i) -1.5707965652134757208e0+0.0i)+(num-test (angle 1.19209289550781250e-07+1.0e+00i) 1.5707962075856070685e0+0.0i)+(num-test (angle 1.19209289550781250e-07-1.0e+00i) -1.5707962075856070685e0+0.0i)+(num-test (angle -1.19209289550781250e-07+1.0e+00i) 1.570796446004186170e0+0.0i)+(num-test (angle -1.19209289550781250e-07-1.0e+00i) -1.570796446004186170e0+0.0i)+(num-test (angle 1.19209289550781250e-07+2.0e+00i) 1.5707962671902518438e0+0.0i)+(num-test (angle 1.19209289550781250e-07-2.0e+00i) -1.5707962671902518438e0+0.0i)+(num-test (angle -1.19209289550781250e-07+2.0e+00i) 1.5707963863995413946e0+0.0i)+(num-test (angle -1.19209289550781250e-07-2.0e+00i) -1.5707963863995413946e0+0.0i)+(num-test (angle 1.19209289550781250e-07+8.3886080e+06i) 1.5707963267948824084e0+0.0i)+(num-test (angle 1.19209289550781250e-07-8.3886080e+06i) -1.5707963267948824084e0+0.0i)+(num-test (angle -1.19209289550781250e-07+8.3886080e+06i) 1.5707963267949108301e0+0.0i)+(num-test (angle -1.19209289550781250e-07-8.3886080e+06i) -1.5707963267949108301e0+0.0i)+(num-test (angle 5.0e-01+0.0e+00i) 0e0+0.0i)+(num-test (angle -5.0e-01+0.0e+00i) 3.1415926535897932385e0+0.0i)+(num-test (angle 5.0e-01+1.19209289550781250e-07i) 2.3841857910155798249e-7+0.0i)+(num-test (angle 5.0e-01-1.19209289550781250e-07i) -2.3841857910155798249e-7+0.0i)+(num-test (angle -5.0e-01+1.19209289550781250e-07i) 3.1415924151712141369e0+0.0i)+(num-test (angle -5.0e-01-1.19209289550781250e-07i) -3.1415924151712141369e0+0.0i)+(num-test (angle 5.0e-01+5.0e-01i) 7.8539816339744830962e-1+0.0i)+(num-test (angle 5.0e-01-5.0e-01i) -7.8539816339744830962e-1+0.0i)+(num-test (angle -5.0e-01+5.0e-01i) 2.3561944901923449288e0+0.0i)+(num-test (angle -5.0e-01-5.0e-01i) -2.3561944901923449288e0+0.0i)+(num-test (angle 5.0e-01+1.0e+00i) 1.1071487177940905030e0+0.0i)+(num-test (angle 5.0e-01-1.0e+00i) -1.1071487177940905030e0+0.0i)+(num-test (angle -5.0e-01+1.0e+00i) 2.0344439357957027354e0+0.0i)+(num-test (angle -5.0e-01-1.0e+00i) -2.0344439357957027354e0+0.0i)+(num-test (angle 5.0e-01+2.0e+00i) 1.3258176636680324651e0+0.0i)+(num-test (angle 5.0e-01-2.0e+00i) -1.3258176636680324651e0+0.0i)+(num-test (angle -5.0e-01+2.0e+00i) 1.8157749899217607734e0+0.0i)+(num-test (angle -5.0e-01-2.0e+00i) -1.8157749899217607734e0+0.0i)+(num-test (angle 5.0e-01+8.3886080e+06i) 1.5707962671902518438e0+0.0i)+(num-test (angle 5.0e-01-8.3886080e+06i) -1.5707962671902518438e0+0.0i)+(num-test (angle -5.0e-01+8.3886080e+06i) 1.5707963863995413946e0+0.0i)+(num-test (angle -5.0e-01-8.3886080e+06i) -1.5707963863995413946e0+0.0i)+(num-test (angle 1.0e+00+0.0e+00i) 0e0+0.0i)+(num-test (angle -1.0e+00+0.0e+00i) 3.1415926535897932385e0+0.0i)+(num-test (angle 1.0e+00+1.19209289550781250e-07i) 1.1920928955078068531e-7+0.0i)+(num-test (angle 1.0e+00-1.19209289550781250e-07i) -1.1920928955078068531e-7+0.0i)+(num-test (angle -1.0e+00+1.19209289550781250e-07i) 3.1415925343805036877e0+0.0i)+(num-test (angle -1.0e+00-1.19209289550781250e-07i) -3.1415925343805036877e0+0.0i)+(num-test (angle 1.0e+00+5.0e-01i) 4.6364760900080611621e-1+0.0i)+(num-test (angle 1.0e+00-5.0e-01i) -4.6364760900080611621e-1+0.0i)+(num-test (angle -1.0e+00+5.0e-01i) 2.6779450445889871222e0+0.0i)+(num-test (angle -1.0e+00-5.0e-01i) -2.6779450445889871222e0+0.0i)+(num-test (angle 1.0e+00+1.0e+00i) 7.8539816339744830962e-1+0.0i)+(num-test (angle 1.0e+00-1.0e+00i) -7.8539816339744830962e-1+0.0i)+(num-test (angle -1.0e+00+1.0e+00i) 2.3561944901923449288e0+0.0i)+(num-test (angle -1.0e+00-1.0e+00i) -2.3561944901923449288e0+0.0i)+(num-test (angle 1.0e+00+2.0e+00i) 1.1071487177940905030e0+0.0i)+(num-test (angle 1.0e+00-2.0e+00i) -1.1071487177940905030e0+0.0i)+(num-test (angle -1.0e+00+2.0e+00i) 2.0344439357957027354e0+0.0i)+(num-test (angle -1.0e+00-2.0e+00i) -2.0344439357957027354e0+0.0i)+(num-test (angle 1.0e+00+8.3886080e+06i) 1.5707962075856070685e0+0.0i)+(num-test (angle 1.0e+00-8.3886080e+06i) -1.5707962075856070685e0+0.0i)+(num-test (angle -1.0e+00+8.3886080e+06i) 1.570796446004186170e0+0.0i)+(num-test (angle -1.0e+00-8.3886080e+06i) -1.570796446004186170e0+0.0i)+(num-test (angle 2.0e+00+0.0e+00i) 0e0+0.0i)+(num-test (angle -2.0e+00+0.0e+00i) 3.1415926535897932385e0+0.0i)+(num-test (angle 2.0e+00+1.19209289550781250e-07i) 5.9604644775390554414e-8+0.0i)+(num-test (angle 2.0e+00-1.19209289550781250e-07i) -5.9604644775390554414e-8+0.0i)+(num-test (angle -2.0e+00+1.19209289550781250e-07i) 3.1415925939851484631e0+0.0i)+(num-test (angle -2.0e+00-1.19209289550781250e-07i) -3.1415925939851484631e0+0.0i)+(num-test (angle 2.0e+00+5.0e-01i) 2.4497866312686415417e-1+0.0i)+(num-test (angle 2.0e+00-5.0e-01i) -2.4497866312686415417e-1+0.0i)+(num-test (angle -2.0e+00+5.0e-01i) 2.8966139904629290843e0+0.0i)+(num-test (angle -2.0e+00-5.0e-01i) -2.8966139904629290843e0+0.0i)+(num-test (angle 2.0e+00+1.0e+00i) 4.6364760900080611621e-1+0.0i)+(num-test (angle 2.0e+00-1.0e+00i) -4.6364760900080611621e-1+0.0i)+(num-test (angle -2.0e+00+1.0e+00i) 2.6779450445889871222e0+0.0i)+(num-test (angle -2.0e+00-1.0e+00i) -2.6779450445889871222e0+0.0i)+(num-test (angle 2.0e+00+2.0e+00i) 7.8539816339744830962e-1+0.0i)+(num-test (angle 2.0e+00-2.0e+00i) -7.8539816339744830962e-1+0.0i)+(num-test (angle -2.0e+00+2.0e+00i) 2.3561944901923449288e0+0.0i)+(num-test (angle -2.0e+00-2.0e+00i) -2.3561944901923449288e0+0.0i)+(num-test (angle 2.0e+00+8.3886080e+06i) 1.5707960883763175177e0+0.0i)+(num-test (angle 2.0e+00-8.3886080e+06i) -1.5707960883763175177e0+0.0i)+(num-test (angle -2.0e+00+8.3886080e+06i) 1.5707965652134757208e0+0.0i)+(num-test (angle -2.0e+00-8.3886080e+06i) -1.5707965652134757208e0+0.0i)+(num-test (angle 8.3886080e+06+0.0e+00i) 0e0+0.0i)+(num-test (angle -8.3886080e+06+0.0e+00i) 3.1415926535897932385e0+0.0i)+(num-test (angle 8.3886080e+06+1.19209289550781250e-07i) 1.4210854715202003717e-14+0.0i)+(num-test (angle 8.3886080e+06-1.19209289550781250e-07i) -1.4210854715202003717e-14+0.0i)+(num-test (angle -8.3886080e+06+1.19209289550781250e-07i) 3.1415926535897790276e0+0.0i)+(num-test (angle -8.3886080e+06-1.19209289550781250e-07i) -3.1415926535897790276e0+0.0i)+(num-test (angle 8.3886080e+06+5.0e-01i) 5.9604644775390554414e-8+0.0i)+(num-test (angle 8.3886080e+06-5.0e-01i) -5.9604644775390554414e-8+0.0i)+(num-test (angle -8.3886080e+06+5.0e-01i) 3.1415925939851484631e0+0.0i)+(num-test (angle -8.3886080e+06-5.0e-01i) -3.1415925939851484631e0+0.0i)+(num-test (angle 8.3886080e+06+1.0e+00i) 1.1920928955078068531e-7+0.0i)+(num-test (angle 8.3886080e+06-1.0e+00i) -1.1920928955078068531e-7+0.0i)+(num-test (angle -8.3886080e+06+1.0e+00i) 3.1415925343805036877e0+0.0i)+(num-test (angle -8.3886080e+06-1.0e+00i) -3.1415925343805036877e0+0.0i)+(num-test (angle 8.3886080e+06+2.0e+00i) 2.3841857910155798249e-7+0.0i)+(num-test (angle 8.3886080e+06-2.0e+00i) -2.3841857910155798249e-7+0.0i)+(num-test (angle -8.3886080e+06+2.0e+00i) 3.1415924151712141369e0+0.0i)+(num-test (angle -8.3886080e+06-2.0e+00i) -3.1415924151712141369e0+0.0i)+(num-test (angle 8.3886080e+06+8.3886080e+06i) 7.8539816339744830962e-1+0.0i)+(num-test (angle 8.3886080e+06-8.3886080e+06i) -7.8539816339744830962e-1+0.0i)+(num-test (angle -8.3886080e+06+8.3886080e+06i) 2.3561944901923449288e0+0.0i)+(num-test (angle -8.3886080e+06-8.3886080e+06i) -2.3561944901923449288e0+0.0i)+(num-test (angle -0) 0)+(num-test (angle 0) 0)+(num-test (angle 0.0) 0.0)+++;; -------- floor, ceiling, truncate, round++(num-test (truncate 19) 19)+(num-test (truncate 2/3) 0)+(num-test (truncate -2/3) 0)+(num-test (truncate 17.3) 17)+(num-test (truncate -17/2) -8)+(num-test (truncate -0.1) 0)+(num-test (truncate -0.9) 0)+(num-test (truncate -1.1) -1)+(num-test (truncate -1.9) -1)+(num-test (truncate -1/10) 0)+(num-test (truncate -9/10) 0)+(num-test (truncate -11/10) -1)+(num-test (truncate -19/10) -1)+(num-test (truncate -1/2) 0)+(num-test (truncate -3/2) -1)+(num-test (truncate 0.1) 0)+(num-test (truncate 0.9) 0)+(num-test (truncate 1.1) 1)+(num-test (truncate 1.9) 1)+(num-test (truncate 1/10) 0)+(num-test (truncate 9/10) 0)+(num-test (truncate 11/10) 1)+(num-test (truncate 19/10) 1)+(num-test (truncate 1/2) 0)+(num-test (truncate 3/2) 1)++(num-test (floor (+ 1 (expt 2 30))) 1073741825)+(num-test (floor 19) 19)+(num-test (floor 2/3) 0)+(num-test (floor -2/3) -1)+(num-test (floor 17.3) 17)+(num-test (floor -17/2) -9)+(num-test (floor -0.1) -1)+(num-test (floor -0.9) -1)+(num-test (floor -1.1) -2)+(num-test (floor -1.9) -2)+(num-test (floor -1/10) -1)+(num-test (floor -9/10) -1)+(num-test (floor -11/10) -2)+(num-test (floor -19/10) -2)+(num-test (floor -1/2) -1)+(num-test (floor -3/2) -2)+(num-test (floor 0.1) 0)+(num-test (floor 0.9) 0)+(num-test (floor 1.1) 1)+(num-test (floor 1.9) 1)+(num-test (floor 1/10) 0)+(num-test (floor 9/10) 0)+(num-test (floor 11/10) 1)+(num-test (floor 19/10) 1)+(num-test (floor 1/2) 0)+(num-test (floor 3/2) 1)++(num-test (ceiling 19) 19)+(num-test (ceiling 2/3) 1)+(num-test (ceiling -2/3) 0)+(num-test (ceiling 17.3) 18)+(num-test (ceiling -17/2) -8)+(num-test (ceiling -0.1) 0)+(num-test (ceiling -0.9) 0)+(num-test (ceiling -1.1) -1)+(num-test (ceiling -1.9) -1)+(num-test (ceiling -1/10) 0)+(num-test (ceiling -9/10) 0)+(num-test (ceiling -11/10) -1)+(num-test (ceiling -19/10) -1)+(num-test (ceiling -1/2) 0)+(num-test (ceiling -3/2) -1)+(num-test (ceiling 0.1) 1)+(num-test (ceiling 0.9) 1)+(num-test (ceiling 1.1) 2)+(num-test (ceiling 1.9) 2)+(num-test (ceiling 1/10) 1)+(num-test (ceiling 9/10) 1)+(num-test (ceiling 11/10) 2)+(num-test (ceiling 19/10) 2)+(num-test (ceiling 1/2) 1)+(num-test (ceiling 3/2) 2)++(num-test (round 19) 19)+(num-test (round 2/3) 1)+(num-test (round -2/3) -1)+(num-test (round 17.3) 17)+(num-test (round -17/2) -8)+(num-test (round 2.5) 2)+(num-test (round 3.5) 4)+(num-test (round -0.1) 0)+(num-test (round -0.9) -1)+(num-test (round -1.1) -1)+(num-test (round -1.9) -2)+(num-test (round -1/10) 0)+(num-test (round -9/10) -1)+(num-test (round -11/10) -1)+(num-test (round -19/10) -2)+(num-test (round -1/2) 0)+(num-test (round -3/2) -2)+(num-test (round 0.1) 0)+(num-test (round 0.9) 1)+(num-test (round 1.1) 1)+(num-test (round 1.9) 2)+(num-test (round 1/10) 0)+(num-test (round 9/10) 1)+(num-test (round 11/10) 1)+(num-test (round 19/10) 2)+(num-test (round 1/2) 0)+(num-test (round 3/2) 2)++(test (equal? (let ((vals '()))+		(do ((k 1/3 (+ k 1/3))) ((> k 2) (reverse vals))+		  (set! vals (cons (round k) vals))))+	      (list 0 1 1 1 2 2))+      #t)+(test (equal? (let ((vals '()))+		(do ((k 1/3 (+ k 1/3))) ((> k 2) (reverse vals))+		  (set! vals (cons (round (- k)) vals))))+	      (list 0 -1 -1 -1 -2 -2))+      #t)+(test (equal? (let ((vals '()))+		(do ((k 1/2 (+ k 1/2))) ((> k 3) (reverse vals))+		  (set! vals (cons (round k) vals))))+	      (list 0 1 2 2 2 3))+      #t)+(test (equal? (let ((vals '()))+		(do ((k 1/2 (+ k 1/2))) ((> k 3) (reverse vals))+		  (set! vals (cons (round (- k)) vals))))+	      (list 0 -1 -2 -2 -2 -3))+      #t)++(num-test (floor 0) 0)+(num-test (round 0) 0)+(num-test (ceiling 0) 0)+(num-test (truncate 0) 0)+(num-test (floor -0) 0)+(num-test (round -0) 0)+(num-test (ceiling -0) 0)+(num-test (truncate -0) 0)+(num-test (floor 0.0) 0)+(num-test (round 0.0) 0)+(num-test (ceiling 0.0) 0)+(num-test (truncate 0.0) 0)+(num-test (floor -0.0) 0)+(num-test (round -0.0) 0)+(num-test (ceiling -0.0) 0)+(num-test (truncate -0.0) 0)+(num-test (floor -1) -1)+(num-test (round -1) -1)+(num-test (ceiling -1) -1)+(num-test (truncate -1) -1)+(num-test (floor 1) 1)+(num-test (round 1) 1)+(num-test (ceiling 1) 1)+(num-test (truncate 1) 1)++(num-test (floor 1/123400000) 0)+(num-test (round 1/123400000) 0)+(num-test (ceiling 1/123400000) 1)+(num-test (truncate 1/123400000) 0)+(num-test (floor -1/123400000) -1)+(num-test (round -1/123400000) 0)+(num-test (ceiling -1/123400000) 0)+(num-test (truncate -1/123400000) 0)++(num-test (floor (- 1 1/123400000)) 0)+(num-test (round (- 1 1/123400000)) 1)+(num-test (ceiling (- 1 1/123400000)) 1)+(num-test (truncate (- 1 1/123400000)) 0)+(num-test (floor (- (+ 1 -1/123400000))) -1)+(num-test (round (- (+ 1 -1/123400000))) -1)+(num-test (ceiling (- (+ 1 -1/123400000))) 0)+(num-test (truncate (- (+ 1 -1/123400000))) 0)++(num-test (floor 2.6) 2)+(num-test (floor 2.5) 2)+(num-test (ceiling 2.6) 3)+(num-test (ceiling 2.5) 3)+(num-test (ceiling 2.4) 3)+(num-test (truncate 2.6) 2)+(num-test (truncate 2.5) 2)+(num-test (truncate 2.4) 2)+(num-test (round 2.6) 3)+(num-test (round 2.5) 2)+(num-test (round 2.4) 2)++(let ((top-exp 60))+  (if with-bignums+      (set! top-exp 150)+      (if (not with-64-bit-ints)+	  (set! top-exp 30)))++  (let ((happy #t))+    (do ((i 2 (+ i 1)))+	((or (not happy) (> i top-exp)))+      (let* ((val1 (/ (- (expt 2 i) 1) 2))+	     (val2 (expt 2 (- i 1)))+	     (fv (floor val1))+	     (rv (round val1))+	     (cv (ceiling val1))+	     (tv (truncate val1)))+	(if (not (= fv (- val2 1)))+	    (begin (set! happy #f) (display "(floor ") (display val1) (display ") = ") (display fv) (display "?") (newline)))+	(if (not (= cv val2))+	    (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = ") (display cv) (display "?") (newline)))+	(if (not (= tv (- val2 1)))+	    (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = ") (display tv) (display "?") (newline)))+	(if (not (= rv val2))+	    (begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline))))))++  (let ((happy #t))+    (do ((i 2 (+ i 1)))+	((or (not happy) (> i top-exp)))+      (let* ((val1 (/ (+ (expt 2 i) 1) 2))+	     (val2 (expt 2 (- i 1)))+	     (fv (floor val1))+	     (rv (round val1))+	     (cv (ceiling val1))+	     (tv (truncate val1)))+	(if (not (= fv val2))+	    (begin (set! happy #f) (display "(floor ") (display val1) (display ") = ") (display fv) (display "?") (newline)))+	(if (not (= cv (+ val2 1)))+	    (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = ") (display cv) (display "?") (newline)))+	(if (not (= tv val2))+	    (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = ") (display tv) (display "?") (newline)))+	(if (not (= rv val2))+	    (begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline))))))++  (let ((happy #t))+    (do ((i 2 (+ i 1)))+	((or (not happy) (> i top-exp)))+      (let* ((val1 (expt 2 i))+	     (val2 (- val1 1)))+	(if (= (floor val1) (floor val2))+	    (begin (set! happy #f) (display "(floor ") (display val1) (display ") = (floor ") (display val2) (display ")?") (newline)))+	(if (= (ceiling val1) (ceiling val2))+	    (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = (ceiling ") (display val2) (display ")?") (newline)))+	(if (= (truncate val1) (truncate val2))+	    (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = (truncate ") (display val2) (display ")?") (newline)))+	(if (= (round val1) (round val2))+	    (begin (set! happy #f) (display "(round ") (display val1) (display ") = (round ") (display val2) (display ")?") (newline))))))++  (let ((happy #t))+    (do ((i 2 (+ i 1)))+	((or (not happy) (> i top-exp)))+      (let* ((val1 (/ (- (expt 2 i) 1) 2))+	     (val2 (/ (- (expt 2 i) 3) 2)))+	(if (= (floor val1) (floor val2))+	    (begin (set! happy #f) (display "(floor ") (display val1) (display ") = (floor ") (display val2) (display ")?") (newline)))+	(if (= (ceiling val1) (ceiling val2))+	    (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = (ceiling ") (display val2) (display ")?") (newline)))+	(if (= (truncate val1) (truncate val2))+	    (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = (truncate ") (display val2) (display ")?") (newline)))+	(if (= (round val1) (round val2))+	    (begin (set! happy #f) (display "(round ") (display val1) (display ") = (round ") (display val2) (display ")?") (newline))))))++  (let ((happy #t)+	(off-by 1/3))+    (do ((i 2 (+ i 1)))+	((or (not happy) (>= i top-exp)))+      (let* ((val1 (/ (expt 2 i) 3))+	     (fv (floor val1))+	     (cv (ceiling val1))+	     (tv (truncate val1))+	     (rv (round val1)))+	(if (not (= fv (- val1 off-by)))+	    (begin (set! happy #f) (display "(floor ") (display val1) (display ") = ") (display fv) (display "?") (newline)))+	(if (not (= cv (+ val1 (- 1 off-by))))+	    (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = ") (display cv) (display "?") (newline)))+	(if (not (= tv (- val1 off-by)))+	    (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = ") (display tv) (display "?") (newline)))+	(if (= off-by 1/3)+	    (if (not (= rv (- val1 off-by)))+		(begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline)))+	    (if (not (= rv (+ val1 (- 1 off-by))))+		(begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline))))+	(if (= off-by 1/3)+	    (set! off-by 2/3)+	    (set! off-by 1/3)))))++  (let ((happy #t))+    (do ((i 2 (+ i 1)))+	((or (not happy) (> i top-exp)))+      (let* ((val1 (- (/ (- (expt 2 i) 1) 2)))+	     (val2 (- (expt 2 (- i 1))))+	     (fv (floor val1))+	     (rv (round val1))+	     (cv (ceiling val1))+	     (tv (truncate val1)))+	(if (not (= fv val2))+	    (begin (set! happy #f) (display "(floor ") (display val1) (display ") = ") (display fv) (display "?") (newline)))+	(if (not (= cv (+ val2 1)))+	    (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = ") (display cv) (display "?") (newline)))+	(if (not (= tv (+ val2 1)))+	    (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = ") (display tv) (display "?") (newline)))+	(if (not (= rv val2))+	    (begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline))))))++  (let ((happy #t))+    (do ((i 2 (+ i 1)))+	((or (not happy) (> i top-exp)))+      (let* ((val1 (- (/ (+ (expt 2 i) 1) 2)))+	     (val2 (- (expt 2 (- i 1))))+	     (fv (floor val1))+	     (rv (round val1))+	     (cv (ceiling val1))+	     (tv (truncate val1)))+	(if (not (= fv (- val2 1)))+	    (begin (set! happy #f) (display "(floor ") (display val1) (display ") = ") (display fv) (display "?") (newline)))+	(if (not (= cv val2))+	    (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = ") (display cv) (display "?") (newline)))+	(if (not (= tv val2))+	    (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = ") (display tv) (display "?") (newline)))+	(if (not (= rv val2))+	    (begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline))))))++  (let ((happy #t))+    (do ((i 2 (+ i 1)))+	((or (not happy) (> i top-exp)))+      (let* ((val1 (- (expt 2 i)))+	     (val2 (+ val1 1)))+	(if (= (floor val1) (floor val2))+	    (begin (set! happy #f) (display "(floor ") (display val1) (display ") = (floor ") (display val2) (display ")?") (newline)))+	(if (= (ceiling val1) (ceiling val2))+	    (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = (ceiling ") (display val2) (display ")?") (newline)))+	(if (= (truncate val1) (truncate val2))+	    (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = (truncate ") (display val2) (display ")?") (newline)))+	(if (= (round val1) (round val2))+	    (begin (set! happy #f) (display "(round ") (display val1) (display ") = (round ") (display val2) (display ")?") (newline))))))++  (let ((happy #t))+    (do ((i 2 (+ i 1)))+	((or (not happy) (> i top-exp)))+      (let* ((val1 (- (/ (- (expt 2 i) 1) 2)))+	     (val2 (- (/ (- (expt 2 i) 3) 2))))+	(if (= (floor val1) (floor val2))+	    (begin (set! happy #f) (display "(floor ") (display val1) (display ") = (floor ") (display val2) (display ")?") (newline)))+	(if (= (ceiling val1) (ceiling val2))+	    (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = (ceiling ") (display val2) (display ")?") (newline)))+	(if (= (truncate val1) (truncate val2))+	    (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = (truncate ") (display val2) (display ")?") (newline)))+	(if (= (round val1) (round val2))+	    (begin (set! happy #f) (display "(round ") (display val1) (display ") = (round ") (display val2) (display ")?") (newline))))))++  (let ((happy #t)+	(off-by 2/3))+    (do ((i 2 (+ i 1)))+	((or (not happy) (>= i top-exp)))+      (let* ((val1 (- (/ (expt 2 i) 3)))+	     (fv (floor val1))+	     (cv (ceiling val1))+	     (tv (truncate val1))+	     (rv (round val1)))+	(if (not (= fv (- val1 off-by)))+	    (begin (set! happy #f) (display "(floor ") (display val1) (display ") = ") (display fv) (display "?") (newline)))+	(if (not (= cv (+ val1 (- 1 off-by))))+	    (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = ") (display cv) (display "?") (newline)))+	(if (not (= tv (+ val1 (- 1 off-by))))+	    (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = ") (display tv) (display "?") (newline)))+	(if (= off-by 1/3)+	    (if (not (= rv (- val1 off-by)))+		(begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline)))+	    (if (not (= rv (+ val1 (- 1 off-by))))+		(begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline))))+	(if (= off-by 1/3)+	    (set! off-by 2/3)+	    (set! off-by 1/3)))))+  )+++;; -------- negative?, positive?, zero?++(test (zero? 0) #t )+(test (zero? -0) #t )+(test (zero? -0.0) #t )+(test (zero? 0.0) #t )+(test (zero? 1) #f )+(test (zero? -1) #f )+(test (zero? -100) #f )+(test (positive? 4) #t )+(test (positive? -4) #f )+(test (positive? 0) #f )+(test (negative? 4) #f )+(test (negative? -4) #t )+(test (negative? 0) #f )+(test (negative? -0) #f )+(test (negative? 0.0) #f )+(test (negative? -0.0) #f )++(for-each+ (lambda (n)+   (if (not (positive? n))+       (begin (display "(positive? ") (display n) (display ") returned #f?") (newline))))+ (list 1 123 123456123 1.4 0.001 1/2 124124124.2))++(for-each+ (lambda (n)+   (if (negative? n)+       (begin (display "(negative? ") (display n) (display ") returned #t?") (newline))))+ (list 1 123 123456123 1.4 0.001 1/2 12341243124.2))++(for-each+ (lambda (n)+   (if (positive? n)+       (begin (display "(positive? ") (display n) (display ") returned #t?") (newline))))+ (list -1 -123 -123456123 -3/2 -0.00001 -1.4 -123124124.1))++(for-each+ (lambda (n)+   (if (not (negative? n))+       (begin (display "(negative? ") (display n) (display ") returned #f?") (newline))))+ (list -1 -123 -123456123 -2/3 -0.00001 -1.4 -123124124.1))++(for-each+ (lambda (n)+   (if (not (zero? n))+       (begin (display "(zero? ") (display n) (display ") returned #f?") (newline))))+ (list 0 0.0 0+0i 0/1 0.0-0.0i))++(for-each+ (lambda (n)+   (if (zero? n)+       (begin (display "(zero? ") (display n) (display ") returned #t?") (newline))))+ (list 1 1/100 -0.001 0.0+1.0i))+++;; -------- even?, odd?++(test (odd? 3) #t )+(test (odd? 2) #f )+(test (odd? -4) #f )+(test (odd? -1) #t )+(test (even? 3) #f )+(test (even? 2) #t )+(test (even? -4) #t )+(test (even? -1) #f )++(for-each+ (lambda (n)+   (if (not (even? n))+       (begin (display "(even? ") (display n) (display ") returned #f?") (newline))))+ (list 0 2 1234 -4 -10000002 1000000006))++(for-each+ (lambda (n)+   (if (odd? n)+       (begin (display "(odd? ") (display n) (display ") returned #t?") (newline))))+ (list 0 2 1234 -4 -10000002 1000000006))++(for-each+ (lambda (n)+   (if (even? n)+       (begin (display "(even? ") (display n) (display ") returned #t?") (newline))))+ (list 1 -1 31 50001 543321))++(for-each+ (lambda (n)+   (if (not (odd? n))+       (begin (display "(odd? ") (display n) (display ") returned #f?") (newline))))+ (list 1 -1 31 50001 543321))++(let ((top-exp 60))+  (let ((happy #t))+    (do ((i 2 (+ i 1)))+	((or (not happy) (> i top-exp)))+      (let* ((val1 (+ 2 (inexact->exact (expt 2 i))))+	     (val2 (- val1 1))+	     (ev1 (even? val1))+	     (ov1 (odd? val1))+	     (ev2 (even? val2))+	     (ov2 (odd? val2)))+	(if (not ev1)+	    (begin (set! happy #f) (display "not (even? ") (display val1) (display ")?") (newline)))+	(if ev2+	    (begin (set! happy #f) (display "(even? ") (display val2) (display ")?") (newline)))+	(if ov1+	    (begin (set! happy #f) (display "(odd? ") (display val1) (display ")?") (newline)))+	(if (not ov2)+	    (begin (set! happy #f) (display "not (odd? ") (display val2) (display ")?") (newline)))))))+++;; -------- real?, complex?, number?, integer?, rational?++(test (number? -) #f)+(test (number? +) #f)+(test (number? 12) #t)+(test (number? (expt 2 130)) #t)+(test (number? 5/3+7.2i) #t)+(test (number? #f) #f)+(test (number? (cons 1 2)) #f)+(test (number? 2.5-.5i) #t)++(test (real? (+ 1+i 1-i)) #t)+(test (real? (- 1+i 1+i)) #t)+(test (real? (+ 1+i -1-i)) #t)+(test (real? (/ 1+i 1+i)) #t)+(test (real? (* 0+i 0+i)) #t)+(test (real? (magnitude 1+i)) #t)+(test (real? (string->number "1+0i")) #t)+(test (real? (make-rectangular 1 0)) #t)+(test (real? (make-rectangular 0 0)) #t)+(test (real? (make-polar 0 0)) #t)+(test (real? (make-polar 1 0)) #t)+(test (real? (angle 1+i)) #t)+(test (real? (real-part 1+i)) #t)+(test (real? (imag-part 1+i)) #t)+(test (real? (expt 0+i 0+i)) #t)++(test (number? 3) #t )+(test (complex? 3) #t )+(test (real? 3) #t )+(test (rational? 3) #t )+(test (integer? 3) #t )++(for-each+ (lambda (op opname)+   (for-each+    (lambda (arg)+      (if (op arg)+	  (begin (display "(") (display opname) (display " ") (display arg) (display ") returned #t?") (newline))))+    (list "hi" (integer->char 65) #f #t '(1 2) 'a-symbol (cons 1 2) (make-vector 3) abs)))+ (list number? complex? real? rational? integer?)+ (list 'number? 'complex? 'real? 'rational? 'integer?))++(for-each+ (lambda (arg)+   (if (not (complex? arg))+       (begin (display "(complex? ") (display arg) (display ") returned #f?") (newline))))+ (list 1 1.0 1.0+0.5i 1/2))++(if (not (integer? 1234)) (display ";1234 is not an integer?~%"))+(for-each+ (lambda (arg)+   (if (integer? arg)+       (begin (display "(integer? ") (display arg) (display ") returned #t?") (newline))))+ (list 1.5 1.0+0.5i 1/2))++(if (real? 1.0+1.0i) (display ";1.0+1.0i is real?~%"))+(for-each+ (lambda (arg)+   (if (not (real? arg))+       (begin (display "(real? ") (display arg) (display ") returned #f?") (newline))))+ (list 1 1.0 1/2))++(if (not (rational? 1/2))+    (begin (display "(rational? 1/2) is #f?") (newline)))++(if (not (rational? 2))+    (begin (display "(rational? 2) is #f?") (newline)))++++;; -------- exact?, inexact?, inexact->exact, exact->inexact++(test (exact? 3) #t )+(test (inexact? 3) #f)+(test (exact? 3.123) #f)+(test (inexact? 3.123) #t)+(test (exact? -0) #t)+(test (inexact? -1) #f)+(test (exact? 1/2) #t)+(test (inexact? 1/2) #f)+(test (exact? 1.5+0.123i) #f)+(test (inexact? 1.5+0.123i) #t)++(num-test (inexact->exact 1.5) 3/2)+(num-test (exact->inexact 3/2) 1.5)+(num-test (inexact->exact 1) 1)+(num-test (exact->inexact 1) 1.0)+(num-test (exact->inexact 1.0) 1.0)+++;; -------- min, max++(num-test (max 3/2 1/2) 3/2)+(num-test (max -3/2 1/2) 1/2)+(num-test (max 3/2 -1/2) 3/2)+(num-test (max -3/2 -1/2) -1/2)+(num-test (max 1 1/2) 1)+(num-test (max -1 1/2) 1/2)+(num-test (max 1 -1/2) 1)+(num-test (max -1 -1/2) -1/2)+(num-test (max 1/2 1) 1)+(num-test (max -1/2 1) 1)+(num-test (max 1/2 -1) 1/2)+(num-test (max -1/2 -1) -1/2)+(num-test (min 3/2 1/2) 1/2)+(num-test (min -3/2 1/2) -3/2)+(num-test (min 3/2 -1/2) -1/2)+(num-test (min -3/2 -1/2) -3/2)+(num-test (min 1 1/2) 1/2)+(num-test (min -1 1/2) -1)+(num-test (min 1 -1/2) -1/2)+(num-test (min -1 -1/2) -1)+(num-test (min 1/2 1) 1/2)+(num-test (min -1/2 1) -1/2)+(num-test (min 1/2 -1) -1)+(num-test (min -1/2 -1) -1)++(num-test (max 3/2 6/5) 3/2)+(num-test (max -3/2 6/5) 6/5)+(num-test (max 3/2 -6/5) 3/2)+(num-test (max -3/2 -6/5) -6/5)+(num-test (min 3/2 6/5) 6/5)+(num-test (min -3/2 6/5) -3/2)+(num-test (min 3/2 -6/5) -6/5)+(num-test (min -3/2 -6/5) -3/2)++(let ((top-exp 60))+  (let ((happy #t))+    (do ((i 2 (+ i 1)))+	((or (not happy) (> i top-exp)))+      (let* ((val1 (+ 2 (expt 2 i)))+	     (val2 (- val1 1)))+	(if (not (= val1 (max val1 val2)))+	    (begin (set! happy #f) (display "(max ") (display val1) (display " ") (display val2) (display ") -> ") (display (max val1 val2)) (display "?") (newline)))+	(if (not (= val2 (min val1 val2)))+	    (begin (set! happy #f) (display "(min ") (display val1) (display " ") (display val2) (display ") -> ") (display (min val1 val2)) (display "?") (newline))))))++  (let ((happy #t))+    (do ((i 2 (+ i 1)))+	((or (not happy) (> i top-exp)))+      (let* ((val1 (/ (expt 2 i) 3))+	     (val2 (/ (+ 1 (expt 2 i)) 3)))+	(if (not (= val2 (max val1 val2)))+	    (begin (set! happy #f) (display "(max ") (display val1) (display " ") (display val2) (display ") -> ") (display (max val1 val2)) (display "?") (newline)))+	(if (not (= val2 (max val2 val1)))+	    (begin (set! happy #f) (display "(max ") (display val1) (display " ") (display val2) (display ") -> ") (display (max val2 val1)) (display "?") (newline)))+	(if (not (= val1 (min val1 val2)))+	    (begin (set! happy #f) (display "(min ") (display val1) (display " ") (display val2) (display ") -> ") (display (min val1 val2)) (display "?") (newline)))+	(if (not (= val1 (min val2 val1)))+	    (begin (set! happy #f) (display "(min ") (display val1) (display " ") (display val2) (display ") -> ") (display (min val2 val1)) (display "?") (newline)))+	))))++(num-test (min 0) 0)+(num-test (min 2) 2)+(num-test (min -2) -2)+(num-test (min 10) 10)+(num-test (min -10) -10)+(num-test (min 1234000000) 1234000000)+(num-test (min -1234000000) -1234000000)+(num-test (min 362880) 362880)+(num-test (min -362880) -362880)+(num-test (min 0/1) 0/1)+(num-test (min 0/1) 0/1)+(num-test (min 2/2) 2/2)+(num-test (min -2/2) -2/2)+(num-test (min 10/3) 10/3)+(num-test (min -10/3) -10/3)+(num-test (min 1234000000/10) 1234000000/10)+(num-test (min -1234000000/10) -1234000000/10)+(num-test (min 362880/1234) 362880/1234)+(num-test (min -362880/1234) -362880/1234)+(num-test (min 0.0) 0.0)+(num-test (min -0.0) -0.0)+(num-test (min 1.0) 1.0)+(num-test (min -1.0) -1.0)+(num-test (min 2.71828182845905) 2.71828182845905)+(num-test (min -2.71828182845905) -2.71828182845905)+(num-test (min 1234000000.0) 1234000000.0)+(num-test (min -1234000000.0) -1234000000.0)+(num-test (min 1 1) 1)+(num-test (min 1 1.0) 1.0)+(num-test (min 1 1/1) 1)+(num-test (min 1 1234) 1)+(num-test (min 1 123.4) 1.0)+(num-test (min 1 1234/11) 1)+(num-test (min 1.0 1) 1.0)+(num-test (min 1.0 1.0) 1.0)+(num-test (min 1.0 1/1) 1.0)+(num-test (min 1.0 1234) 1.0)+(num-test (min 1.0 123.4) 1.0)+(num-test (min 1.0 1234/11) 1.0)+(num-test (min 1/1 1) 1)+(num-test (min 1/1 1.0) 1.0)+(num-test (min 1/1 1/1) 1)+(num-test (min 1/1 1234) 1)+(num-test (min 1/1 123.4) 1.0)+(num-test (min 1/1 1234/11) 1)+(num-test (min 0 1) 0)+(num-test (min 0 1.0) 0.0)+(num-test (min 0 1/1) 0)+(num-test (min 0 1234) 0)+(num-test (min 0 123.4) 0.0)+(num-test (min 0 1234/11) 0)+(num-test (min 0.0 1) 0.0)+(num-test (min 0.0 1.0) 0.0)+(num-test (min 0.0 1/1) 0.0)+(num-test (min 0.0 1234) 0.0)+(num-test (min 0.0 123.4) 0.0)+(num-test (min 0.0 1234/11) 0.0)+(num-test (min 1234 1) 1)+(num-test (min 1234 1.0) 1.0)+(num-test (min 1234 1/1) 1)+(num-test (min 1234 1234) 1234)+(num-test (min 1234 123.4) 123.4)+(num-test (min 1234 1234/11) 1234/11)+(num-test (min 123.4 1) 1.0)+(num-test (min 123.4 1.0) 1.0)+(num-test (min 123.4 1/1) 1.0)+(num-test (min 123.4 1234) 123.4)+(num-test (min 123.4 123.4) 123.4)+(num-test (min 123.4 1234/11) 112.18181818181819)+(num-test (min 1234/11 1) 1)+(num-test (min 1234/11 1.0) 1.0)+(num-test (min 1234/11 1/1) 1)+(num-test (min 1234/11 1234) 1234/11)+(num-test (min 1234/11 123.4) 112.18181818181819)+(num-test (min 1234/11 1234/11) 1234/11)+(num-test (min 1 1 1) 1)+(num-test (min 1 1 1.0) 1.0)+(num-test (min 1 1 1/1) 1)+(num-test (min 1 1 1234) 1)+(num-test (min 1 1 123.4) 1.0)+(num-test (min 1 1 1234/11) 1)+(num-test (min 1 1.0 1) 1.0)+(num-test (min 1 1.0 1.0) 1.0)+(num-test (min 1 1.0 1/1) 1.0)+(num-test (min 1 1.0 1234) 1.0)+(num-test (min 1 1.0 123.4) 1.0)+(num-test (min 1 1.0 1234/11) 1.0)+(num-test (min 1 1/1 1) 1)+(num-test (min 1 1/1 1.0) 1.0)+(num-test (min 1 1/1 1/1) 1)+(num-test (min 1 1/1 1234) 1)+(num-test (min 1 1/1 123.4) 1.0)+(num-test (min 1 1/1 1234/11) 1)+(num-test (min 1 1234 1) 1)+(num-test (min 1 1234 1.0) 1.0)+(num-test (min 1 1234 1/1) 1)+(num-test (min 1 1234 1234) 1)+(num-test (min 1 1234 123.4) 1.0)+(num-test (min 1 1234 1234/11) 1)+(num-test (min 1 123.4 1) 1.0)+(num-test (min 1 123.4 1.0) 1.0)+(num-test (min 1 123.4 1/1) 1.0)+(num-test (min 1 123.4 1234) 1.0)+(num-test (min 1 123.4 123.4) 1.0)+(num-test (min 1 123.4 1234/11) 1.0)+(num-test (min 1 1234/11 1) 1)+(num-test (min 1 1234/11 1.0) 1.0)+(num-test (min 1 1234/11 1/1) 1)+(num-test (min 1 1234/11 1234) 1)+(num-test (min 1 1234/11 123.4) 1.0)+(num-test (min 1 1234/11 1234/11) 1)+(num-test (min 1.0 1 1) 1.0)+(num-test (min 1.0 1 1.0) 1.0)+(num-test (min 1.0 1 1/1) 1.0)+(num-test (min 1.0 1 1234) 1.0)+(num-test (min 1.0 1 123.4) 1.0)+(num-test (min 1.0 1 1234/11) 1.0)+(num-test (min 1.0 1.0 1) 1.0)+(num-test (min 1.0 1.0 1.0) 1.0)+(num-test (min 1.0 1.0 1/1) 1.0)+(num-test (min 1.0 1.0 1234) 1.0)+(num-test (min 1.0 1.0 123.4) 1.0)+(num-test (min 1.0 1.0 1234/11) 1.0)+(num-test (min 1.0 1/1 1) 1.0)+(num-test (min 1.0 1/1 1.0) 1.0)+(num-test (min 1.0 1/1 1/1) 1.0)+(num-test (min 1.0 1/1 1234) 1.0)+(num-test (min 1.0 1/1 123.4) 1.0)+(num-test (min 1.0 1/1 1234/11) 1.0)+(num-test (min 1.0 1234 1) 1.0)+(num-test (min 1.0 1234 1.0) 1.0)+(num-test (min 1.0 1234 1/1) 1.0)+(num-test (min 1.0 1234 1234) 1.0)+(num-test (min 1.0 1234 123.4) 1.0)+(num-test (min 1.0 1234 1234/11) 1.0)+(num-test (min 1.0 123.4 1) 1.0)+(num-test (min 1.0 123.4 1.0) 1.0)+(num-test (min 1.0 123.4 1/1) 1.0)+(num-test (min 1.0 123.4 1234) 1.0)+(num-test (min 1.0 123.4 123.4) 1.0)+(num-test (min 1.0 123.4 1234/11) 1.0)+(num-test (min 1.0 1234/11 1) 1.0)+(num-test (min 1.0 1234/11 1.0) 1.0)+(num-test (min 1.0 1234/11 1/1) 1.0)+(num-test (min 1.0 1234/11 1234) 1.0)+(num-test (min 1.0 1234/11 123.4) 1.0)+(num-test (min 1.0 1234/11 1234/11) 1.0)+(num-test (min 1/1 1 1) 1)+(num-test (min 1/1 1 1.0) 1.0)+(num-test (min 1/1 1 1/1) 1)+(num-test (min 1/1 1 1234) 1)+(num-test (min 1/1 1 123.4) 1.0)+(num-test (min 1/1 1 1234/11) 1)+(num-test (min 1/1 1.0 1) 1.0)+(num-test (min 1/1 1.0 1.0) 1.0)+(num-test (min 1/1 1.0 1/1) 1.0)+(num-test (min 1/1 1.0 1234) 1.0)+(num-test (min 1/1 1.0 123.4) 1.0)+(num-test (min 1/1 1.0 1234/11) 1.0)+(num-test (min 1/1 1/1 1) 1)+(num-test (min 1/1 1/1 1.0) 1.0)+(num-test (min 1/1 1/1 1/1) 1)+(num-test (min 1/1 1/1 1234) 1)+(num-test (min 1/1 1/1 123.4) 1.0)+(num-test (min 1/1 1/1 1234/11) 1)+(num-test (min 1/1 1234 1) 1)+(num-test (min 1/1 1234 1.0) 1.0)+(num-test (min 1/1 1234 1/1) 1)+(num-test (min 1/1 1234 1234) 1)+(num-test (min 1/1 1234 123.4) 1.0)+(num-test (min 1/1 1234 1234/11) 1)+(num-test (min 1/1 123.4 1) 1.0)+(num-test (min 1/1 123.4 1.0) 1.0)+(num-test (min 1/1 123.4 1/1) 1.0)+(num-test (min 1/1 123.4 1234) 1.0)+(num-test (min 1/1 123.4 123.4) 1.0)+(num-test (min 1/1 123.4 1234/11) 1.0)+(num-test (min 1/1 1234/11 1) 1)+(num-test (min 1/1 1234/11 1.0) 1.0)+(num-test (min 1/1 1234/11 1/1) 1)+(num-test (min 1/1 1234/11 1234) 1)+(num-test (min 1/1 1234/11 123.4) 1.0)+(num-test (min 1/1 1234/11 1234/11) 1)+(num-test (min 0 1 1) 0)+(num-test (min 0 1 1.0) 0.0)+(num-test (min 0 1 1/1) 0)+(num-test (min 0 1 1234) 0)+(num-test (min 0 1 123.4) 0.0)+(num-test (min 0 1 1234/11) 0)+(num-test (min 0 1.0 1) 0.0)+(num-test (min 0 1.0 1.0) 0.0)+(num-test (min 0 1.0 1/1) 0.0)+(num-test (min 0 1.0 1234) 0.0)+(num-test (min 0 1.0 123.4) 0.0)+(num-test (min 0 1.0 1234/11) 0.0)+(num-test (min 0 1/1 1) 0)+(num-test (min 0 1/1 1.0) 0.0)+(num-test (min 0 1/1 1/1) 0)+(num-test (min 0 1/1 1234) 0)+(num-test (min 0 1/1 123.4) 0.0)+(num-test (min 0 1/1 1234/11) 0)+(num-test (min 0 1234 1) 0)+(num-test (min 0 1234 1.0) 0.0)+(num-test (min 0 1234 1/1) 0)+(num-test (min 0 1234 1234) 0)+(num-test (min 0 1234 123.4) 0.0)+(num-test (min 0 1234 1234/11) 0)+(num-test (min 0 123.4 1) 0.0)+(num-test (min 0 123.4 1.0) 0.0)+(num-test (min 0 123.4 1/1) 0.0)+(num-test (min 0 123.4 1234) 0.0)+(num-test (min 0 123.4 123.4) 0.0)+(num-test (min 0 123.4 1234/11) 0.0)+(num-test (min 0 1234/11 1) 0)+(num-test (min 0 1234/11 1.0) 0.0)+(num-test (min 0 1234/11 1/1) 0)+(num-test (min 0 1234/11 1234) 0)+(num-test (min 0 1234/11 123.4) 0.0)+(num-test (min 0 1234/11 1234/11) 0)+(num-test (min 0.0 1 1) 0.0)+(num-test (min 0.0 1 1.0) 0.0)+(num-test (min 0.0 1 1/1) 0.0)+(num-test (min 0.0 1 1234) 0.0)+(num-test (min 0.0 1 123.4) 0.0)+(num-test (min 0.0 1 1234/11) 0.0)+(num-test (min 0.0 1.0 1) 0.0)+(num-test (min 0.0 1.0 1.0) 0.0)+(num-test (min 0.0 1.0 1/1) 0.0)+(num-test (min 0.0 1.0 1234) 0.0)+(num-test (min 0.0 1.0 123.4) 0.0)+(num-test (min 0.0 1.0 1234/11) 0.0)+(num-test (min 0.0 1/1 1) 0.0)+(num-test (min 0.0 1/1 1.0) 0.0)+(num-test (min 0.0 1/1 1/1) 0.0)+(num-test (min 0.0 1/1 1234) 0.0)+(num-test (min 0.0 1/1 123.4) 0.0)+(num-test (min 0.0 1/1 1234/11) 0.0)+(num-test (min 0.0 1234 1) 0.0)+(num-test (min 0.0 1234 1.0) 0.0)+(num-test (min 0.0 1234 1/1) 0.0)+(num-test (min 0.0 1234 1234) 0.0)+(num-test (min 0.0 1234 123.4) 0.0)+(num-test (min 0.0 1234 1234/11) 0.0)+(num-test (min 0.0 123.4 1) 0.0)+(num-test (min 0.0 123.4 1.0) 0.0)+(num-test (min 0.0 123.4 1/1) 0.0)+(num-test (min 0.0 123.4 1234) 0.0)+(num-test (min 0.0 123.4 123.4) 0.0)+(num-test (min 0.0 123.4 1234/11) 0.0)+(num-test (min 0.0 1234/11 1) 0.0)+(num-test (min 0.0 1234/11 1.0) 0.0)+(num-test (min 0.0 1234/11 1/1) 0.0)+(num-test (min 0.0 1234/11 1234) 0.0)+(num-test (min 0.0 1234/11 123.4) 0.0)+(num-test (min 0.0 1234/11 1234/11) 0.0)+(num-test (min 1234 1 1) 1)+(num-test (min 1234 1 1.0) 1.0)+(num-test (min 1234 1 1/1) 1)+(num-test (min 1234 1 1234) 1)+(num-test (min 1234 1 123.4) 1.0)+(num-test (min 1234 1 1234/11) 1)+(num-test (min 1234 1.0 1) 1.0)+(num-test (min 1234 1.0 1.0) 1.0)+(num-test (min 1234 1.0 1/1) 1.0)+(num-test (min 1234 1.0 1234) 1.0)+(num-test (min 1234 1.0 123.4) 1.0)+(num-test (min 1234 1.0 1234/11) 1.0)+(num-test (min 1234 1/1 1) 1)+(num-test (min 1234 1/1 1.0) 1.0)+(num-test (min 1234 1/1 1/1) 1)+(num-test (min 1234 1/1 1234) 1)+(num-test (min 1234 1/1 123.4) 1.0)+(num-test (min 1234 1/1 1234/11) 1)+(num-test (min 1234 1234 1) 1)+(num-test (min 1234 1234 1.0) 1.0)+(num-test (min 1234 1234 1/1) 1)+(num-test (min 1234 1234 1234) 1234)+(num-test (min 1234 1234 123.4) 123.4)+(num-test (min 1234 1234 1234/11) 1234/11)+(num-test (min 1234 123.4 1) 1.0)+(num-test (min 1234 123.4 1.0) 1.0)+(num-test (min 1234 123.4 1/1) 1.0)+(num-test (min 1234 123.4 1234) 123.4)+(num-test (min 1234 123.4 123.4) 123.4)+(num-test (min 1234 123.4 1234/11) 112.18181818181819)+(num-test (min 1234 1234/11 1) 1)+(num-test (min 1234 1234/11 1.0) 1.0)+(num-test (min 1234 1234/11 1/1) 1)+(num-test (min 1234 1234/11 1234) 1234/11)+(num-test (min 1234 1234/11 123.4) 112.18181818181819)+(num-test (min 1234 1234/11 1234/11) 1234/11)+(num-test (min 123.4 1 1) 1.0)+(num-test (min 123.4 1 1.0) 1.0)+(num-test (min 123.4 1 1/1) 1.0)+(num-test (min 123.4 1 1234) 1.0)+(num-test (min 123.4 1 123.4) 1.0)+(num-test (min 123.4 1 1234/11) 1.0)+(num-test (min 123.4 1.0 1) 1.0)+(num-test (min 123.4 1.0 1.0) 1.0)+(num-test (min 123.4 1.0 1/1) 1.0)+(num-test (min 123.4 1.0 1234) 1.0)+(num-test (min 123.4 1.0 123.4) 1.0)+(num-test (min 123.4 1.0 1234/11) 1.0)+(num-test (min 123.4 1/1 1) 1.0)+(num-test (min 123.4 1/1 1.0) 1.0)+(num-test (min 123.4 1/1 1/1) 1.0)+(num-test (min 123.4 1/1 1234) 1.0)+(num-test (min 123.4 1/1 123.4) 1.0)+(num-test (min 123.4 1/1 1234/11) 1.0)+(num-test (min 123.4 1234 1) 1.0)+(num-test (min 123.4 1234 1.0) 1.0)+(num-test (min 123.4 1234 1/1) 1.0)+(num-test (min 123.4 1234 1234) 123.4)+(num-test (min 123.4 1234 123.4) 123.4)+(num-test (min 123.4 1234 1234/11) 112.18181818181819)+(num-test (min 123.4 123.4 1) 1.0)+(num-test (min 123.4 123.4 1.0) 1.0)+(num-test (min 123.4 123.4 1/1) 1.0)+(num-test (min 123.4 123.4 1234) 123.4)+(num-test (min 123.4 123.4 123.4) 123.4)+(num-test (min 123.4 123.4 1234/11) 112.18181818181819)+(num-test (min 123.4 1234/11 1) 1.0)+(num-test (min 123.4 1234/11 1.0) 1.0)+(num-test (min 123.4 1234/11 1/1) 1.0)+(num-test (min 123.4 1234/11 1234) 112.18181818181819)+(num-test (min 123.4 1234/11 123.4) 112.18181818181819)+(num-test (min 123.4 1234/11 1234/11) 112.18181818181819)+(num-test (min 1234/11 1 1) 1)+(num-test (min 1234/11 1 1.0) 1.0)+(num-test (min 1234/11 1 1/1) 1)+(num-test (min 1234/11 1 1234) 1)+(num-test (min 1234/11 1 123.4) 1.0)+(num-test (min 1234/11 1 1234/11) 1)+(num-test (min 1234/11 1.0 1) 1.0)+(num-test (min 1234/11 1.0 1.0) 1.0)+(num-test (min 1234/11 1.0 1/1) 1.0)+(num-test (min 1234/11 1.0 1234) 1.0)+(num-test (min 1234/11 1.0 123.4) 1.0)+(num-test (min 1234/11 1.0 1234/11) 1.0)+(num-test (min 1234/11 1/1 1) 1)+(num-test (min 1234/11 1/1 1.0) 1.0)+(num-test (min 1234/11 1/1 1/1) 1)+(num-test (min 1234/11 1/1 1234) 1)+(num-test (min 1234/11 1/1 123.4) 1.0)+(num-test (min 1234/11 1/1 1234/11) 1)+(num-test (min 1234/11 1234 1) 1)+(num-test (min 1234/11 1234 1.0) 1.0)+(num-test (min 1234/11 1234 1/1) 1)+(num-test (min 1234/11 1234 1234) 1234/11)+(num-test (min 1234/11 1234 123.4) 112.18181818181819)+(num-test (min 1234/11 1234 1234/11) 1234/11)+(num-test (min 1234/11 123.4 1) 1.0)+(num-test (min 1234/11 123.4 1.0) 1.0)+(num-test (min 1234/11 123.4 1/1) 1.0)+(num-test (min 1234/11 123.4 1234) 112.18181818181819)+(num-test (min 1234/11 123.4 123.4) 112.18181818181819)+(num-test (min 1234/11 123.4 1234/11) 112.18181818181819)+(num-test (min 1234/11 1234/11 1) 1)+(num-test (min 1234/11 1234/11 1.0) 1.0)+(num-test (min 1234/11 1234/11 1/1) 1)+(num-test (min 1234/11 1234/11 1234) 1234/11)+(num-test (min 1234/11 1234/11 123.4) 112.18181818181819)+(num-test (min 1234/11 1234/11 1234/11) 1234/11)+(num-test (min 3) 3)+(num-test (min 6 12) 6)+(num-test (min -6 -12) -12)+(num-test (min 1 3 2 -7) -7)+(num-test (min -2 3 0 7) -2)+(num-test (min 5.0 2) 2.0)  ; why not 2?+(num-test (min 3.0 7 1) 1.0)+(num-test (min 3  5 5 330 4 -24) -24 )++(num-test (max 0) 0)+(num-test (max 2) 2)+(num-test (max -2) -2)+(num-test (max 10) 10)+(num-test (max -10) -10)+(num-test (max 1234000000) 1234000000)+(num-test (max -1234000000) -1234000000)+(num-test (max 362880) 362880)+(num-test (max -362880) -362880)+(num-test (max 0/1) 0/1)+(num-test (max 0/1) 0/1)+(num-test (max 2/2) 2/2)+(num-test (max -2/2) -2/2)+(num-test (max 10/3) 10/3)+(num-test (max -10/3) -10/3)+(num-test (max 1234000000/10) 1234000000/10)+(num-test (max -1234000000/10) -1234000000/10)+(num-test (max 362880/1234) 362880/1234)+(num-test (max -362880/1234) -362880/1234)+(num-test (max 0.0) 0.0)+(num-test (max -0.0) -0.0)+(num-test (max 1.0) 1.0)+(num-test (max -1.0) -1.0)+(num-test (max 2.71828182845905) 2.71828182845905)+(num-test (max -2.71828182845905) -2.71828182845905)+(num-test (max 1234000000.0) 1234000000.0)+(num-test (max -1234000000.0) -1234000000.0)+(num-test (max 1 1) 1)+(num-test (max 1 1.0) 1.0)+(num-test (max 1 1/1) 1)+(num-test (max 1 1234) 1234)+(num-test (max 1 123.4) 123.4)+(num-test (max 1 1234/11) 1234/11)+(num-test (max 1.0 1) 1.0)+(num-test (max 1.0 1.0) 1.0)+(num-test (max 1.0 1/1) 1.0)+(num-test (max 1.0 1234) 1234.0)+(num-test (max 1.0 123.4) 123.4)+(num-test (max 1.0 1234/11) 112.18181818181819)+(num-test (max 1/1 1) 1)+(num-test (max 1/1 1.0) 1.0)+(num-test (max 1/1 1/1) 1)+(num-test (max 1/1 1234) 1234)+(num-test (max 1/1 123.4) 123.4)+(num-test (max 1/1 1234/11) 1234/11)+(num-test (max 0 1) 1)+(num-test (max 0 1.0) 1.0)+(num-test (max 0 1/1) 1)+(num-test (max 0 1234) 1234)+(num-test (max 0 123.4) 123.4)+(num-test (max 0 1234/11) 1234/11)+(num-test (max 0.0 1) 1.0)+(num-test (max 0.0 1.0) 1.0)+(num-test (max 0.0 1/1) 1.0)+(num-test (max 0.0 1234) 1234.0)+(num-test (max 0.0 123.4) 123.4)+(num-test (max 0.0 1234/11) 112.18181818181819)+(num-test (max 1234 1) 1234)+(num-test (max 1234 1.0) 1234.0)+(num-test (max 1234 1/1) 1234)+(num-test (max 1234 1234) 1234)+(num-test (max 1234 123.4) 1234.0)+(num-test (max 1234 1234/11) 1234)+(num-test (max 123.4 1) 123.4)+(num-test (max 123.4 1.0) 123.4)+(num-test (max 123.4 1/1) 123.4)+(num-test (max 123.4 1234) 1234.0)+(num-test (max 123.4 123.4) 123.4)+(num-test (max 123.4 1234/11) 123.4)+(num-test (max 1234/11 1) 1234/11)+(num-test (max 1234/11 1.0) 112.18181818181819)+(num-test (max 1234/11 1/1) 1234/11)+(num-test (max 1234/11 1234) 1234)+(num-test (max 1234/11 123.4) 123.4)+(num-test (max 1234/11 1234/11) 1234/11)+(num-test (max 1 1 1) 1)+(num-test (max 1 1 1.0) 1.0)+(num-test (max 1 1 1/1) 1)+(num-test (max 1 1 1234) 1234)+(num-test (max 1 1 123.4) 123.4)+(num-test (max 1 1 1234/11) 1234/11)+(num-test (max 1 1.0 1) 1.0)+(num-test (max 1 1.0 1.0) 1.0)+(num-test (max 1 1.0 1/1) 1.0)+(num-test (max 1 1.0 1234) 1234.0)+(num-test (max 1 1.0 123.4) 123.4)+(num-test (max 1 1.0 1234/11) 112.18181818181819)+(num-test (max 1 1/1 1) 1)+(num-test (max 1 1/1 1.0) 1.0)+(num-test (max 1 1/1 1/1) 1)+(num-test (max 1 1/1 1234) 1234)+(num-test (max 1 1/1 123.4) 123.4)+(num-test (max 1 1/1 1234/11) 1234/11)+(num-test (max 1 1234 1) 1234)+(num-test (max 1 1234 1.0) 1234.0)+(num-test (max 1 1234 1/1) 1234)+(num-test (max 1 1234 1234) 1234)+(num-test (max 1 1234 123.4) 1234.0)+(num-test (max 1 1234 1234/11) 1234)+(num-test (max 1 123.4 1) 123.4)+(num-test (max 1 123.4 1.0) 123.4)+(num-test (max 1 123.4 1/1) 123.4)+(num-test (max 1 123.4 1234) 1234.0)+(num-test (max 1 123.4 123.4) 123.4)+(num-test (max 1 123.4 1234/11) 123.4)+(num-test (max 1 1234/11 1) 1234/11)+(num-test (max 1 1234/11 1.0) 112.18181818181819)+(num-test (max 1 1234/11 1/1) 1234/11)+(num-test (max 1 1234/11 1234) 1234)+(num-test (max 1 1234/11 123.4) 123.4)+(num-test (max 1 1234/11 1234/11) 1234/11)+(num-test (max 1.0 1 1) 1.0)+(num-test (max 1.0 1 1.0) 1.0)+(num-test (max 1.0 1 1/1) 1.0)+(num-test (max 1.0 1 1234) 1234.0)+(num-test (max 1.0 1 123.4) 123.4)+(num-test (max 1.0 1 1234/11) 112.18181818181819)+(num-test (max 1.0 1.0 1) 1.0)+(num-test (max 1.0 1.0 1.0) 1.0)+(num-test (max 1.0 1.0 1/1) 1.0)+(num-test (max 1.0 1.0 1234) 1234.0)+(num-test (max 1.0 1.0 123.4) 123.4)+(num-test (max 1.0 1.0 1234/11) 112.18181818181819)+(num-test (max 1.0 1/1 1) 1.0)+(num-test (max 1.0 1/1 1.0) 1.0)+(num-test (max 1.0 1/1 1/1) 1.0)+(num-test (max 1.0 1/1 1234) 1234.0)+(num-test (max 1.0 1/1 123.4) 123.4)+(num-test (max 1.0 1/1 1234/11) 112.18181818181819)+(num-test (max 1.0 1234 1) 1234.0)+(num-test (max 1.0 1234 1.0) 1234.0)+(num-test (max 1.0 1234 1/1) 1234.0)+(num-test (max 1.0 1234 1234) 1234.0)+(num-test (max 1.0 1234 123.4) 1234.0)+(num-test (max 1.0 1234 1234/11) 1234.0)+(num-test (max 1.0 123.4 1) 123.4)+(num-test (max 1.0 123.4 1.0) 123.4)+(num-test (max 1.0 123.4 1/1) 123.4)+(num-test (max 1.0 123.4 1234) 1234.0)+(num-test (max 1.0 123.4 123.4) 123.4)+(num-test (max 1.0 123.4 1234/11) 123.4)+(num-test (max 1.0 1234/11 1) 112.18181818181819)+(num-test (max 1.0 1234/11 1.0) 112.18181818181819)+(num-test (max 1.0 1234/11 1/1) 112.18181818181819)+(num-test (max 1.0 1234/11 1234) 1234.0)+(num-test (max 1.0 1234/11 123.4) 123.4)+(num-test (max 1.0 1234/11 1234/11) 112.18181818181819)+(num-test (max 1/1 1 1) 1)+(num-test (max 1/1 1 1.0) 1.0)+(num-test (max 1/1 1 1/1) 1)+(num-test (max 1/1 1 1234) 1234)+(num-test (max 1/1 1 123.4) 123.4)+(num-test (max 1/1 1 1234/11) 1234/11)+(num-test (max 1/1 1.0 1) 1.0)+(num-test (max 1/1 1.0 1.0) 1.0)+(num-test (max 1/1 1.0 1/1) 1.0)+(num-test (max 1/1 1.0 1234) 1234.0)+(num-test (max 1/1 1.0 123.4) 123.4)+(num-test (max 1/1 1.0 1234/11) 112.18181818181819)+(num-test (max 1/1 1/1 1) 1)+(num-test (max 1/1 1/1 1.0) 1.0)+(num-test (max 1/1 1/1 1/1) 1)+(num-test (max 1/1 1/1 1234) 1234)+(num-test (max 1/1 1/1 123.4) 123.4)+(num-test (max 1/1 1/1 1234/11) 1234/11)+(num-test (max 1/1 1234 1) 1234)+(num-test (max 1/1 1234 1.0) 1234.0)+(num-test (max 1/1 1234 1/1) 1234)+(num-test (max 1/1 1234 1234) 1234)+(num-test (max 1/1 1234 123.4) 1234.0)+(num-test (max 1/1 1234 1234/11) 1234)+(num-test (max 1/1 123.4 1) 123.4)+(num-test (max 1/1 123.4 1.0) 123.4)+(num-test (max 1/1 123.4 1/1) 123.4)+(num-test (max 1/1 123.4 1234) 1234.0)+(num-test (max 1/1 123.4 123.4) 123.4)+(num-test (max 1/1 123.4 1234/11) 123.4)+(num-test (max 1/1 1234/11 1) 1234/11)+(num-test (max 1/1 1234/11 1.0) 112.18181818181819)+(num-test (max 1/1 1234/11 1/1) 1234/11)+(num-test (max 1/1 1234/11 1234) 1234)+(num-test (max 1/1 1234/11 123.4) 123.4)+(num-test (max 1/1 1234/11 1234/11) 1234/11)+(num-test (max 0 1 1) 1)+(num-test (max 0 1 1.0) 1.0)+(num-test (max 0 1 1/1) 1)+(num-test (max 0 1 1234) 1234)+(num-test (max 0 1 123.4) 123.4)+(num-test (max 0 1 1234/11) 1234/11)+(num-test (max 0 1.0 1) 1.0)+(num-test (max 0 1.0 1.0) 1.0)+(num-test (max 0 1.0 1/1) 1.0)+(num-test (max 0 1.0 1234) 1234.0)+(num-test (max 0 1.0 123.4) 123.4)+(num-test (max 0 1.0 1234/11) 112.18181818181819)+(num-test (max 0 1/1 1) 1)+(num-test (max 0 1/1 1.0) 1.0)+(num-test (max 0 1/1 1/1) 1)+(num-test (max 0 1/1 1234) 1234)+(num-test (max 0 1/1 123.4) 123.4)+(num-test (max 0 1/1 1234/11) 1234/11)+(num-test (max 0 1234 1) 1234)+(num-test (max 0 1234 1.0) 1234.0)+(num-test (max 0 1234 1/1) 1234)+(num-test (max 0 1234 1234) 1234)+(num-test (max 0 1234 123.4) 1234.0)+(num-test (max 0 1234 1234/11) 1234)+(num-test (max 0 123.4 1) 123.4)+(num-test (max 0 123.4 1.0) 123.4)+(num-test (max 0 123.4 1/1) 123.4)+(num-test (max 0 123.4 1234) 1234.0)+(num-test (max 0 123.4 123.4) 123.4)+(num-test (max 0 123.4 1234/11) 123.4)+(num-test (max 0 1234/11 1) 1234/11)+(num-test (max 0 1234/11 1.0) 112.18181818181819)+(num-test (max 0 1234/11 1/1) 1234/11)+(num-test (max 0 1234/11 1234) 1234)+(num-test (max 0 1234/11 123.4) 123.4)+(num-test (max 0 1234/11 1234/11) 1234/11)+(num-test (max 0.0 1 1) 1.0)+(num-test (max 0.0 1 1.0) 1.0)+(num-test (max 0.0 1 1/1) 1.0)+(num-test (max 0.0 1 1234) 1234.0)+(num-test (max 0.0 1 123.4) 123.4)+(num-test (max 0.0 1 1234/11) 112.18181818181819)+(num-test (max 0.0 1.0 1) 1.0)+(num-test (max 0.0 1.0 1.0) 1.0)+(num-test (max 0.0 1.0 1/1) 1.0)+(num-test (max 0.0 1.0 1234) 1234.0)+(num-test (max 0.0 1.0 123.4) 123.4)+(num-test (max 0.0 1.0 1234/11) 112.18181818181819)+(num-test (max 0.0 1/1 1) 1.0)+(num-test (max 0.0 1/1 1.0) 1.0)+(num-test (max 0.0 1/1 1/1) 1.0)+(num-test (max 0.0 1/1 1234) 1234.0)+(num-test (max 0.0 1/1 123.4) 123.4)+(num-test (max 0.0 1/1 1234/11) 112.18181818181819)+(num-test (max 0.0 1234 1) 1234.0)+(num-test (max 0.0 1234 1.0) 1234.0)+(num-test (max 0.0 1234 1/1) 1234.0)+(num-test (max 0.0 1234 1234) 1234.0)+(num-test (max 0.0 1234 123.4) 1234.0)+(num-test (max 0.0 1234 1234/11) 1234.0)+(num-test (max 0.0 123.4 1) 123.4)+(num-test (max 0.0 123.4 1.0) 123.4)+(num-test (max 0.0 123.4 1/1) 123.4)+(num-test (max 0.0 123.4 1234) 1234.0)+(num-test (max 0.0 123.4 123.4) 123.4)+(num-test (max 0.0 123.4 1234/11) 123.4)+(num-test (max 0.0 1234/11 1) 112.18181818181819)+(num-test (max 0.0 1234/11 1.0) 112.18181818181819)+(num-test (max 0.0 1234/11 1/1) 112.18181818181819)+(num-test (max 0.0 1234/11 1234) 1234.0)+(num-test (max 0.0 1234/11 123.4) 123.4)+(num-test (max 0.0 1234/11 1234/11) 112.18181818181819)+(num-test (max 1234 1 1) 1234)+(num-test (max 1234 1 1.0) 1234.0)+(num-test (max 1234 1 1/1) 1234)+(num-test (max 1234 1 1234) 1234)+(num-test (max 1234 1 123.4) 1234.0)+(num-test (max 1234 1 1234/11) 1234)+(num-test (max 1234 1.0 1) 1234.0)+(num-test (max 1234 1.0 1.0) 1234.0)+(num-test (max 1234 1.0 1/1) 1234.0)+(num-test (max 1234 1.0 1234) 1234.0)+(num-test (max 1234 1.0 123.4) 1234.0)+(num-test (max 1234 1.0 1234/11) 1234.0)+(num-test (max 1234 1/1 1) 1234)+(num-test (max 1234 1/1 1.0) 1234.0)+(num-test (max 1234 1/1 1/1) 1234)+(num-test (max 1234 1/1 1234) 1234)+(num-test (max 1234 1/1 123.4) 1234.0)+(num-test (max 1234 1/1 1234/11) 1234)+(num-test (max 1234 1234 1) 1234)+(num-test (max 1234 1234 1.0) 1234.0)+(num-test (max 1234 1234 1/1) 1234)+(num-test (max 1234 1234 1234) 1234)+(num-test (max 1234 1234 123.4) 1234.0)+(num-test (max 1234 1234 1234/11) 1234)+(num-test (max 1234 123.4 1) 1234.0)+(num-test (max 1234 123.4 1.0) 1234.0)+(num-test (max 1234 123.4 1/1) 1234.0)+(num-test (max 1234 123.4 1234) 1234.0)+(num-test (max 1234 123.4 123.4) 1234.0)+(num-test (max 1234 123.4 1234/11) 1234.0)+(num-test (max 1234 1234/11 1) 1234)+(num-test (max 1234 1234/11 1.0) 1234.0)+(num-test (max 1234 1234/11 1/1) 1234)+(num-test (max 1234 1234/11 1234) 1234)+(num-test (max 1234 1234/11 123.4) 1234.0)+(num-test (max 1234 1234/11 1234/11) 1234)+(num-test (max 123.4 1 1) 123.4)+(num-test (max 123.4 1 1.0) 123.4)+(num-test (max 123.4 1 1/1) 123.4)+(num-test (max 123.4 1 1234) 1234.0)+(num-test (max 123.4 1 123.4) 123.4)+(num-test (max 123.4 1 1234/11) 123.4)+(num-test (max 123.4 1.0 1) 123.4)+(num-test (max 123.4 1.0 1.0) 123.4)+(num-test (max 123.4 1.0 1/1) 123.4)+(num-test (max 123.4 1.0 1234) 1234.0)+(num-test (max 123.4 1.0 123.4) 123.4)+(num-test (max 123.4 1.0 1234/11) 123.4)+(num-test (max 123.4 1/1 1) 123.4)+(num-test (max 123.4 1/1 1.0) 123.4)+(num-test (max 123.4 1/1 1/1) 123.4)+(num-test (max 123.4 1/1 1234) 1234.0)+(num-test (max 123.4 1/1 123.4) 123.4)+(num-test (max 123.4 1/1 1234/11) 123.4)+(num-test (max 123.4 1234 1) 1234.0)+(num-test (max 123.4 1234 1.0) 1234.0)+(num-test (max 123.4 1234 1/1) 1234.0)+(num-test (max 123.4 1234 1234) 1234.0)+(num-test (max 123.4 1234 123.4) 1234.0)+(num-test (max 123.4 1234 1234/11) 1234.0)+(num-test (max 123.4 123.4 1) 123.4)+(num-test (max 123.4 123.4 1.0) 123.4)+(num-test (max 123.4 123.4 1/1) 123.4)+(num-test (max 123.4 123.4 1234) 1234.0)+(num-test (max 123.4 123.4 123.4) 123.4)+(num-test (max 123.4 123.4 1234/11) 123.4)+(num-test (max 123.4 1234/11 1) 123.4)+(num-test (max 123.4 1234/11 1.0) 123.4)+(num-test (max 123.4 1234/11 1/1) 123.4)+(num-test (max 123.4 1234/11 1234) 1234.0)+(num-test (max 123.4 1234/11 123.4) 123.4)+(num-test (max 123.4 1234/11 1234/11) 123.4)+(num-test (max 1234/11 1 1) 1234/11)+(num-test (max 1234/11 1 1.0) 112.18181818181819)+(num-test (max 1234/11 1 1/1) 1234/11)+(num-test (max 1234/11 1 1234) 1234)+(num-test (max 1234/11 1 123.4) 123.4)+(num-test (max 1234/11 1 1234/11) 1234/11)+(num-test (max 1234/11 1.0 1) 112.18181818181819)+(num-test (max 1234/11 1.0 1.0) 112.18181818181819)+(num-test (max 1234/11 1.0 1/1) 112.18181818181819)+(num-test (max 1234/11 1.0 1234) 1234.0)+(num-test (max 1234/11 1.0 123.4) 123.4)+(num-test (max 1234/11 1.0 1234/11) 112.18181818181819)+(num-test (max 1234/11 1/1 1) 1234/11)+(num-test (max 1234/11 1/1 1.0) 112.18181818181819)+(num-test (max 1234/11 1/1 1/1) 1234/11)+(num-test (max 1234/11 1/1 1234) 1234)+(num-test (max 1234/11 1/1 123.4) 123.4)+(num-test (max 1234/11 1/1 1234/11) 1234/11)+(num-test (max 1234/11 1234 1) 1234)+(num-test (max 1234/11 1234 1.0) 1234.0)+(num-test (max 1234/11 1234 1/1) 1234)+(num-test (max 1234/11 1234 1234) 1234)+(num-test (max 1234/11 1234 123.4) 1234.0)+(num-test (max 1234/11 1234 1234/11) 1234)+(num-test (max 1234/11 123.4 1) 123.4)+(num-test (max 1234/11 123.4 1.0) 123.4)+(num-test (max 1234/11 123.4 1/1) 123.4)+(num-test (max 1234/11 123.4 1234) 1234.0)+(num-test (max 1234/11 123.4 123.4) 123.4)+(num-test (max 1234/11 123.4 1234/11) 123.4)+(num-test (max 1234/11 1234/11 1) 1234/11)+(num-test (max 1234/11 1234/11 1.0) 112.18181818181819)+(num-test (max 1234/11 1234/11 1/1) 1234/11)+(num-test (max 1234/11 1234/11 1234) 1234)+(num-test (max 1234/11 1234/11 123.4) 123.4)+(num-test (max 1234/11 1234/11 1234/11) 1234/11)+(num-test (max 3) 3)+(num-test (max 6 12) 12)+(num-test (max -6 -12) -6)+(num-test (max 1 3 2 -7) 3)+(num-test (max -2 3 0 7) 7)+(num-test (max 5.0 2) 5.0)+(num-test (max 3.0 7 1) 7.0)+(num-test (max 1 3 2 -7) 3)+(num-test (max 34 5 7 38 6) 38 )+++;; -------- = < > <= >= + - / *++(test (= 22 22 22) #t )+(test (= 22 22) #t )+(test (= 34 34 35) #f )+(test (= 34 35) #f )+(test (> 3 -6246) #t )+(test (> 9 9 -2424) #f )+(test (>= 3 -4 -6246) #t )+(test (>= 9 9) #t )+(test (>= 8 9) #f )+(test (< -1 2 3 4 5 6 7 8) #t )+(test (< -1 2 3 4 4 5 6 7) #f )+(test (<= -1 2 3 4 5 6 7 8) #t )+(test (<= -1 2 3 4 4 5 6 7) #t )+(test (< 1 3 2) #f )+(test (>= 1 3 2) #f )+(test (< 0 -0) #f)+(test (< -0 0) #f)+(test (= -0 0) #t)+(test (< 0.0 -0.0) #f)+(test (< -0.0 0.0) #f)+(test (= -0.0 0.0) #t)+(test (= 1+0i 1-0i) #t)+(test (< 1 1 2) #f)+(test (>= 1 1 2) #f)+(test (> 2 2 1) #f)+(test (<= 2 2 1) #f)++(num-test (+ 0) 0)+(num-test (- 0) 0)+(num-test (* 0) 0)+(num-test (- 0) 0)+(num-test (* 0) 0)+(num-test (+ 2) 2)+(num-test (- 2) -2)+(num-test (* 2) 2)+(num-test (/ 2) 1/2)+(num-test (+ -2) -2)+(num-test (- -2) 2)+(num-test (* -2) -2)+(num-test (/ -2) -1/2)+(num-test (+ 10) 10)+(num-test (- 10) -10)+(num-test (* 10) 10)+(num-test (/ 10) 1/10)+(num-test (+ -10) -10)+(num-test (- -10) 10)+(num-test (* -10) -10)+(num-test (/ -10) -1/10)+(num-test (+ 1234000000) 1234000000)+(num-test (- 1234000000) -1234000000)+(num-test (* 1234000000) 1234000000)+(num-test (/ 1234000000) 1/1234000000)+(num-test (+ -1234000000) -1234000000)+(num-test (- -1234000000) 1234000000)+(num-test (* -1234000000) -1234000000)+(num-test (/ -1234000000) -1/1234000000)+(num-test (+ 362880) 362880)+(num-test (- 362880) -362880)+(num-test (* 362880) 362880)+(num-test (/ 362880) 1/362880)+(num-test (+ -362880) -362880)+(num-test (- -362880) 362880)+(num-test (* -362880) -362880)+(num-test (/ -362880) -1/362880)+(num-test (+ 0/1) 0/1)+(num-test (- 0/1) 0/1)+(num-test (* 0/1) 0/1)+(num-test (+ 0/1) 0/1)+(num-test (- 0/1) 0/1)+(num-test (* 0/1) 0/1)+(num-test (+ 2/2) 2/2)+(num-test (- 2/2) -2/2)+(num-test (* 2/2) 2/2)+(num-test (/ 2/2) 2/2)+(num-test (+ -2/2) -2/2)+(num-test (- -2/2) 2/2)+(num-test (* -2/2) -2/2)+(num-test (/ -2/2) -2/2)+(num-test (+ 10/3) 10/3)+(num-test (- 10/3) -10/3)+(num-test (* 10/3) 10/3)+(num-test (/ 10/3) 3/10)+(num-test (+ -10/3) -10/3)+(num-test (- -10/3) 10/3)+(num-test (* -10/3) -10/3)+(num-test (/ -10/3) -3/10)+(num-test (+ 1234000000/10) 1234000000/10)+(num-test (- 1234000000/10) -1234000000/10)+(num-test (* 1234000000/10) 1234000000/10)+(num-test (/ 1234000000/10) 10/1234000000)+(num-test (+ -1234000000/10) -1234000000/10)+(num-test (- -1234000000/10) 1234000000/10)+(num-test (* -1234000000/10) -1234000000/10)+(num-test (/ -1234000000/10) -10/1234000000)+(num-test (+ 362880/1234) 362880/1234)+(num-test (- 362880/1234) -362880/1234)+(num-test (* 362880/1234) 362880/1234)+(num-test (/ 362880/1234) 1234/362880)+(num-test (+ -362880/1234) -362880/1234)+(num-test (- -362880/1234) 362880/1234)+(num-test (* -362880/1234) -362880/1234)+(num-test (/ -362880/1234) -1234/362880)+(num-test (+ 0.0) 0.0)+(num-test (- 0.0) -0.0)+(num-test (* 0.0) 0.0)+(num-test (+ -0.0) -0.0)+(num-test (- -0.0) 0.0)+(num-test (* -0.0) -0.0)+(num-test (+ 1.0) 1.0)+(num-test (- 1.0) -1.0)+(num-test (* 1.0) 1.0)+(num-test (/ 1.0) 1.0)+(num-test (+ -1.0) -1.0)+(num-test (- -1.0) 1.0)+(num-test (* -1.0) -1.0)+(num-test (/ -1.0) -1.0)+(num-test (+ 2.71828182845905) 2.71828182845905)+(num-test (- 2.71828182845905) -2.71828182845905)+(num-test (* 2.71828182845905) 2.71828182845905)+(num-test (/ 2.71828182845905) 0.36787944117144)+(num-test (+ -2.71828182845905) -2.71828182845905)+(num-test (- -2.71828182845905) 2.71828182845905)+(num-test (* -2.71828182845905) -2.71828182845905)+(num-test (/ -2.71828182845905) -0.36787944117144)+(num-test (+ 1234000000.0) 1234000000.0)+(num-test (- 1234000000.0) -1234000000.0)+(num-test (* 1234000000.0) 1234000000.0)+(num-test (/ 1234000000.0) 0.00000000081037)+(num-test (+ -1234000000.0) -1234000000.0)+(num-test (- -1234000000.0) 1234000000.0)+(num-test (* -1234000000.0) -1234000000.0)+(num-test (/ -1234000000.0) -0.00000000081037)+(num-test (+ 0.0+0.00000001i) 0.0+0.00000001i)+(num-test (- 0.0+0.00000001i) -0.0-0.00000001i)+(num-test (- 0.0-0.00000001i) -0.0+0.00000001i)+(num-test (* 0.0+0.00000001i) 0.0+0.00000001i)+(num-test (/ 0.0+0.00000001i) 0.0-100000000.0i)+(num-test (+ -0.0+0.00000001i) -0.0+0.00000001i)+(num-test (- -0.0+0.00000001i) 0.0-0.00000001i)+(num-test (* -0.0+0.00000001i) -0.0+0.00000001i)+(num-test (/ -0.0+0.00000001i) 0.0-100000000.0i)+(num-test (+ 1.0+1.0i) 1.0+1.0i)+(num-test (- 1.0+1.0i) -1.0-1.0i)+(num-test (* 1.0+1.0i) 1.0+1.0i)+(num-test (/ 1.0+1.0i) 0.5-0.5i)+(num-test (+ -1.0+1.0i) -1.0+1.0i)+(num-test (- -1.0+1.0i) 1.0-1.0i)+(num-test (* -1.0+1.0i) -1.0+1.0i)+(num-test (/ -1.0+1.0i) -0.5-0.5i)+(num-test (+ 2.71828182845905+3.14159265358979i) 2.71828182845905+3.14159265358979i)+(num-test (+ 2.71828182845905-3.14159265358979i) 2.71828182845905-3.14159265358979i)+(num-test (- 2.71828182845905+3.14159265358979i) -2.71828182845905-3.14159265358979i)+(num-test (- 2.71828182845905-3.14159265358979i) -2.71828182845905+3.14159265358979i)+(num-test (* 2.71828182845905+3.14159265358979i) 2.71828182845905+3.14159265358979i)+(num-test (/ 2.71828182845905+3.14159265358979i) 0.15750247989732-0.18202992367723i)+(num-test (+ -2.71828182845905+3.14159265358979i) -2.71828182845905+3.14159265358979i)+(num-test (- -2.71828182845905+3.14159265358979i) 2.71828182845905-3.14159265358979i)+(num-test (- -2.71828182845905-3.14159265358979i) 2.71828182845905+3.14159265358979i)+(num-test (* -2.71828182845905+3.14159265358979i) -2.71828182845905+3.14159265358979i)+(num-test (/ -2.71828182845905+3.14159265358979i) -0.15750247989732-0.18202992367723i)+(num-test (+ 1234000000.0+2.71828182845905i) 1234000000.0+2.71828182845905i)+(num-test (+ 1234000000.0-2.71828182845905i) 1234000000.0-2.71828182845905i)+(num-test (- 1234000000.0+2.71828182845905i) -1234000000.0-2.71828182845905i)+(num-test (- 1234000000.0-2.71828182845905i) -1234000000.0+2.71828182845905i)+(num-test (* 1234000000.0+2.71828182845905i) 1234000000.0+2.71828182845905i)+(num-test (/ 1234000000.0+2.71828182845905i) 0.00000000081037-0.0i)+(num-test (+ -1234000000.0+2.71828182845905i) -1234000000.0+2.71828182845905i)+(num-test (- -1234000000.0+2.71828182845905i) 1234000000.0-2.71828182845905i)+(num-test (* -1234000000.0+2.71828182845905i) -1234000000.0+2.71828182845905i)+(num-test (/ -1234000000.0+2.71828182845905i) -0.00000000081037-0.0i)++(num-test (+ 1 1) 2)+(num-test (- 1 1) 0)+(num-test (* 1 1) 1)+(num-test (/ 1 1) 1)+(num-test (= 1 1) #t)+(num-test (< 1 1) #f)+(num-test (<= 1 1) #t)+(num-test (> 1 1) #f)+(num-test (>= 1 1) #t)+(num-test (+ 1 1.0) 2.0)+(num-test (- 1 1.0) 0.0)+(num-test (* 1 1.0) 1.0)+(num-test (/ 1 1.0) 1.0)+(num-test (= 1 1.0) #t)+(num-test (< 1 1.0) #f)+(num-test (<= 1 1.0) #t)+(num-test (> 1 1.0) #f)+(num-test (>= 1 1.0) #t)+(num-test (+ 1 1/1) 2)+(num-test (- 1 1/1) 0)+(num-test (* 1 1/1) 1)+(num-test (/ 1 1/1) 1)+(num-test (= 1 1/1) #t)+(num-test (< 1 1/1) #f)+(num-test (<= 1 1/1) #t)+(num-test (> 1 1/1) #f)+(num-test (>= 1 1/1) #t)+(num-test (+ 1 1.0+1.0i) 2.0+1.0i)+(num-test (- 1 1.0+1.0i) 0.0-1.0i)+(num-test (* 1 1.0+1.0i) 1.0+1.0i)+(num-test (/ 1 1.0+1.0i) 0.5-0.5i)+(num-test (= 1 1.0+1.0i) #f)+(num-test (+ 1 0) 1)+(num-test (- 1 0) 1)+(num-test (* 1 0) 0)+(num-test (+ 1 0.0) 1.0)+(num-test (- 1 0.0) 1.0)+(num-test (* 1 0.0) 0.0)+(num-test (+ 1 1234) 1235)+(num-test (- 1 1234) -1233)+(num-test (* 1 1234) 1234)+(num-test (/ 1 1234) 1/1234)+(num-test (= 1 1234) #f)+(num-test (< 1 1234) #t)+(num-test (<= 1 1234) #t)+(num-test (> 1 1234) #f)+(num-test (>= 1 1234) #f)+(num-test (+ 1 123.4) 124.4)+(num-test (- 1 123.4) -122.4)+(num-test (* 1 123.4) 123.4)+(num-test (/ 1 123.4) 0.00810372771475)+(num-test (= 1 123.4) #f)+(num-test (< 1 123.4) #t)+(num-test (<= 1 123.4) #t)+(num-test (> 1 123.4) #f)+(num-test (>= 1 123.4) #f)+(num-test (+ 1 1234/11) 1245/11)+(num-test (- 1 1234/11) -1223/11)+(num-test (* 1 1234/11) 1234/11)+(num-test (/ 1 1234/11) 11/1234)+(num-test (= 1 1234/11) #f)+(num-test (< 1 1234/11) #t)+(num-test (<= 1 1234/11) #t)+(num-test (> 1 1234/11) #f)+(num-test (>= 1 1234/11) #f)+(num-test (+ 1 1.234+1.234i) 2.234+1.234i)+(num-test (- 1 1.234+1.234i) -0.234-1.234i)+(num-test (* 1 1.234+1.234i) 1.234+1.234i)+(num-test (/ 1 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1 1.234+1.234i) #f)+(num-test (+ 1 -1.0+1.0i) 0.0+1.0i)+(num-test (- 1 -1.0+1.0i) 2.0-1.0i)+(num-test (* 1 -1.0+1.0i) -1.0+1.0i)+(num-test (/ 1 -1.0+1.0i) -0.5-0.5i)+(num-test (= 1 -1.0+1.0i) #f)+(num-test (+ 1 0.0+1.0i) 1.0+1.0i)+(num-test (- 1 0.0+1.0i) 1.0-1.0i)+(num-test (* 1 0.0+1.0i) 0.0+1.0i)+(num-test (/ 1 0.0+1.0i) 0.0-1.0i)+(num-test (= 1 0.0+1.0i) #f)+(num-test (+ 1.0 1) 2.0)+(num-test (- 1.0 1) 0.0)+(num-test (* 1.0 1) 1.0)+(num-test (/ 1.0 1) 1.0)+(num-test (= 1.0 1) #t)+(num-test (< 1.0 1) #f)+(num-test (<= 1.0 1) #t)+(num-test (> 1.0 1) #f)+(num-test (>= 1.0 1) #t)+(num-test (+ 1.0 1.0) 2.0)+(num-test (- 1.0 1.0) 0.0)+(num-test (* 1.0 1.0) 1.0)+(num-test (/ 1.0 1.0) 1.0)+(num-test (= 1.0 1.0) #t)+(num-test (< 1.0 1.0) #f)+(num-test (<= 1.0 1.0) #t)+(num-test (> 1.0 1.0) #f)+(num-test (>= 1.0 1.0) #t)+(num-test (+ 1.0 1/1) 2.0)+(num-test (- 1.0 1/1) 0.0)+(num-test (* 1.0 1/1) 1.0)+(num-test (/ 1.0 1/1) 1.0)+(num-test (= 1.0 1/1) #t)+(num-test (< 1.0 1/1) #f)+(num-test (<= 1.0 1/1) #t)+(num-test (> 1.0 1/1) #f)+(num-test (>= 1.0 1/1) #t)+(num-test (+ 1.0 1.0+1.0i) 2.0+1.0i)+(num-test (- 1.0 1.0+1.0i) 0.0-1.0i)+(num-test (* 1.0 1.0+1.0i) 1.0+1.0i)+(num-test (/ 1.0 1.0+1.0i) 0.5-0.5i)+(num-test (= 1.0 1.0+1.0i) #f)+(num-test (+ 1.0 0) 1.0)+(num-test (- 1.0 0) 1.0)+(num-test (* 1.0 0) 0.0)+(num-test (+ 1.0 0.0) 1.0)+(num-test (- 1.0 0.0) 1.0)+(num-test (* 1.0 0.0) 0.0)+(num-test (+ 1.0 1234) 1235.0)+(num-test (- 1.0 1234) -1233.0)+(num-test (* 1.0 1234) 1234.0)+(num-test (/ 1.0 1234) 0.00081037277147)+(num-test (= 1.0 1234) #f)+(num-test (< 1.0 1234) #t)+(num-test (<= 1.0 1234) #t)+(num-test (> 1.0 1234) #f)+(num-test (>= 1.0 1234) #f)+(num-test (+ 1.0 123.4) 124.4)+(num-test (- 1.0 123.4) -122.4)+(num-test (* 1.0 123.4) 123.4)+(num-test (/ 1.0 123.4) 0.00810372771475)+(num-test (= 1.0 123.4) #f)+(num-test (< 1.0 123.4) #t)+(num-test (<= 1.0 123.4) #t)+(num-test (> 1.0 123.4) #f)+(num-test (>= 1.0 123.4) #f)+(num-test (+ 1.0 1234/11) 113.18181818181819)+(num-test (- 1.0 1234/11) -111.18181818181819)+(num-test (* 1.0 1234/11) 112.18181818181819)+(num-test (/ 1.0 1234/11) 0.00891410048622)+(num-test (= 1.0 1234/11) #f)+(num-test (< 1.0 1234/11) #t)+(num-test (<= 1.0 1234/11) #t)+(num-test (> 1.0 1234/11) #f)+(num-test (>= 1.0 1234/11) #f)+(num-test (+ 1.0 1.234+1.234i) 2.234+1.234i)+(num-test (- 1.0 1.234+1.234i) -0.234-1.234i)+(num-test (* 1.0 1.234+1.234i) 1.234+1.234i)+(num-test (/ 1.0 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1.0 1.234+1.234i) #f)+(num-test (+ 1.0 -1.0+1.0i) 0.0+1.0i)+(num-test (- 1.0 -1.0+1.0i) 2.0-1.0i)+(num-test (* 1.0 -1.0+1.0i) -1.0+1.0i)+(num-test (/ 1.0 -1.0+1.0i) -0.5-0.5i)+(num-test (= 1.0 -1.0+1.0i) #f)+(num-test (+ 1.0 0.0+1.0i) 1.0+1.0i)+(num-test (- 1.0 0.0+1.0i) 1.0-1.0i)+(num-test (* 1.0 0.0+1.0i) 0.0+1.0i)+(num-test (/ 1.0 0.0+1.0i) 0.0-1.0i)+(num-test (= 1.0 0.0+1.0i) #f)+(num-test (+ 1/1 1) 2)+(num-test (- 1/1 1) 0)+(num-test (* 1/1 1) 1)+(num-test (/ 1/1 1) 1)+(num-test (= 1/1 1) #t)+(num-test (< 1/1 1) #f)+(num-test (<= 1/1 1) #t)+(num-test (> 1/1 1) #f)+(num-test (>= 1/1 1) #t)+(num-test (+ 1/1 1.0) 2.0)+(num-test (- 1/1 1.0) 0.0)+(num-test (* 1/1 1.0) 1.0)+(num-test (/ 1/1 1.0) 1.0)+(num-test (= 1/1 1.0) #t)+(num-test (< 1/1 1.0) #f)+(num-test (<= 1/1 1.0) #t)+(num-test (> 1/1 1.0) #f)+(num-test (>= 1/1 1.0) #t)+(num-test (+ 1/1 1/1) 2)+(num-test (- 1/1 1/1) 0)+(num-test (* 1/1 1/1) 1)+(num-test (/ 1/1 1/1) 1)+(num-test (= 1/1 1/1) #t)+(num-test (< 1/1 1/1) #f)+(num-test (<= 1/1 1/1) #t)+(num-test (> 1/1 1/1) #f)+(num-test (>= 1/1 1/1) #t)+(num-test (+ 1/1 1.0+1.0i) 2.0+1.0i)+(num-test (- 1/1 1.0+1.0i) 0.0-1.0i)+(num-test (* 1/1 1.0+1.0i) 1.0+1.0i)+(num-test (/ 1/1 1.0+1.0i) 0.5-0.5i)+(num-test (= 1/1 1.0+1.0i) #f)+(num-test (+ 1/1 0) 1)+(num-test (- 1/1 0) 1)+(num-test (* 1/1 0) 0)+(num-test (+ 1/1 0.0) 1.0)+(num-test (- 1/1 0.0) 1.0)+(num-test (* 1/1 0.0) 0.0)+(num-test (+ 1/1 1234) 1235)+(num-test (- 1/1 1234) -1233)+(num-test (* 1/1 1234) 1234)+(num-test (/ 1/1 1234) 1/1234)+(num-test (= 1/1 1234) #f)+(num-test (< 1/1 1234) #t)+(num-test (<= 1/1 1234) #t)+(num-test (> 1/1 1234) #f)+(num-test (>= 1/1 1234) #f)+(num-test (+ 1/1 123.4) 124.4)+(num-test (- 1/1 123.4) -122.4)+(num-test (* 1/1 123.4) 123.4)+(num-test (/ 1/1 123.4) 0.00810372771475)+(num-test (= 1/1 123.4) #f)+(num-test (< 1/1 123.4) #t)+(num-test (<= 1/1 123.4) #t)+(num-test (> 1/1 123.4) #f)+(num-test (>= 1/1 123.4) #f)+(num-test (+ 1/1 1234/11) 1245/11)+(num-test (- 1/1 1234/11) -1223/11)+(num-test (* 1/1 1234/11) 1234/11)+(num-test (/ 1/1 1234/11) 11/1234)+(num-test (= 1/1 1234/11) #f)+(num-test (< 1/1 1234/11) #t)+(num-test (<= 1/1 1234/11) #t)+(num-test (> 1/1 1234/11) #f)+(num-test (>= 1/1 1234/11) #f)+(num-test (+ 1/1 1.234+1.234i) 2.234+1.234i)+(num-test (- 1/1 1.234+1.234i) -0.234-1.234i)+(num-test (* 1/1 1.234+1.234i) 1.234+1.234i)+(num-test (/ 1/1 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1/1 1.234+1.234i) #f)+(num-test (+ 1/1 -1.0+1.0i) 0.0+1.0i)+(num-test (- 1/1 -1.0+1.0i) 2.0-1.0i)+(num-test (* 1/1 -1.0+1.0i) -1.0+1.0i)+(num-test (/ 1/1 -1.0+1.0i) -0.5-0.5i)+(num-test (= 1/1 -1.0+1.0i) #f)+(num-test (+ 1/1 0.0+1.0i) 1.0+1.0i)+(num-test (- 1/1 0.0+1.0i) 1.0-1.0i)+(num-test (* 1/1 0.0+1.0i) 0.0+1.0i)+(num-test (/ 1/1 0.0+1.0i) 0.0-1.0i)+(num-test (= 1/1 0.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1) 2.0+1.0i)+(num-test (- 1.0+1.0i 1) 0.0+1.0i)+(num-test (* 1.0+1.0i 1) 1.0+1.0i)+(num-test (/ 1.0+1.0i 1) 1.0+1.0i)+(num-test (= 1.0+1.0i 1) #f)+(num-test (+ 1.0+1.0i 1.0) 2.0+1.0i)+(num-test (- 1.0+1.0i 1.0) 0.0+1.0i)+(num-test (* 1.0+1.0i 1.0) 1.0+1.0i)+(num-test (/ 1.0+1.0i 1.0) 1.0+1.0i)+(num-test (= 1.0+1.0i 1.0) #f)+(num-test (+ 1.0+1.0i 1/1) 2.0+1.0i)+(num-test (- 1.0+1.0i 1/1) 0.0+1.0i)+(num-test (* 1.0+1.0i 1/1) 1.0+1.0i)+(num-test (/ 1.0+1.0i 1/1) 1.0+1.0i)+(num-test (= 1.0+1.0i 1/1) #f)+(num-test (+ 1.0+1.0i 1.0+1.0i) 2.0+2.0i)+(num-test (- 1.0+1.0i 1.0+1.0i) 0.0)+(num-test (* 1.0+1.0i 1.0+1.0i) 0.0+2.0i)+(num-test (/ 1.0+1.0i 1.0+1.0i) 1.0)+(num-test (= 1.0+1.0i 1.0+1.0i) #t)+(num-test (+ 1.0+1.0i 0) 1.0+1.0i)+(num-test (- 1.0+1.0i 0) 1.0+1.0i)+(num-test (* 1.0+1.0i 0) 0.0)+(num-test (+ 1.0+1.0i 0.0) 1.0+1.0i)+(num-test (- 1.0+1.0i 0.0) 1.0+1.0i)+(num-test (* 1.0+1.0i 0.0) 0.0)+(num-test (+ 1.0+1.0i 1234) 1235.0+1.0i)+(num-test (- 1.0+1.0i 1234) -1233.0+1.0i)+(num-test (* 1.0+1.0i 1234) 1234.0+1234.0i)+(num-test (/ 1.0+1.0i 1234) 0.00081037277147+0.00081037277147i)+(num-test (= 1.0+1.0i 1234) #f)+(num-test (+ 1.0+1.0i 123.4) 124.4+1.0i)+(num-test (- 1.0+1.0i 123.4) -122.4+1.0i)+(num-test (* 1.0+1.0i 123.4) 123.4+123.4i)+(num-test (/ 1.0+1.0i 123.4) 0.00810372771475+0.00810372771475i)+(num-test (= 1.0+1.0i 123.4) #f)+(num-test (+ 1.0+1.0i 1234/11) 113.18181818181819+1.0i)+(num-test (- 1.0+1.0i 1234/11) -111.18181818181819+1.0i)+(num-test (* 1.0+1.0i 1234/11) 112.18181818181819+112.18181818181819i)+(num-test (/ 1.0+1.0i 1234/11) 0.00891410048622+0.00891410048622i)+(num-test (= 1.0+1.0i 1234/11) #f)+(num-test (+ 1.0+1.0i 1.234+1.234i) 2.234+2.234i)+(num-test (- 1.0+1.0i 1.234+1.234i) -0.234-0.234i)+(num-test (* 1.0+1.0i 1.234+1.234i) 0.0+2.468i)+(num-test (/ 1.0+1.0i 1.234+1.234i) 0.81037277147488)+(num-test (= 1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1.0+1.0i -1.0+1.0i) 0.0+2.0i)+(num-test (- 1.0+1.0i -1.0+1.0i) 2.0)+(num-test (* 1.0+1.0i -1.0+1.0i) -2.0)+(num-test (/ 1.0+1.0i -1.0+1.0i) -0.0-1.0i)+(num-test (= 1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 0.0+1.0i) 1.0+2.0i)+(num-test (- 1.0+1.0i 0.0+1.0i) 1.0)+(num-test (* 1.0+1.0i 0.0+1.0i) -1.0+1.0i)+(num-test (/ 1.0+1.0i 0.0+1.0i) 1.0-1.0i)+(num-test (= 1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 0 1) 1)+(num-test (- 0 1) -1)+(num-test (* 0 1) 0)+(num-test (/ 0 1) 0)+(num-test (= 0 1) #f)+(num-test (< 0 1) #t)+(num-test (<= 0 1) #t)+(num-test (> 0 1) #f)+(num-test (>= 0 1) #f)+(num-test (+ 0 1.0) 1.0)+(num-test (- 0 1.0) -1.0)+(num-test (* 0 1.0) 0.0)+(num-test (/ 0 1.0) 0.0)+(num-test (= 0 1.0) #f)+(num-test (< 0 1.0) #t)+(num-test (<= 0 1.0) #t)+(num-test (> 0 1.0) #f)+(num-test (>= 0 1.0) #f)+(num-test (+ 0 1/1) 1)+(num-test (- 0 1/1) -1)+(num-test (* 0 1/1) 0)+(num-test (/ 0 1/1) 0)+(num-test (= 0 1/1) #f)+(num-test (< 0 1/1) #t)+(num-test (<= 0 1/1) #t)+(num-test (> 0 1/1) #f)+(num-test (>= 0 1/1) #f)+(num-test (+ 0 1.0+1.0i) 1.0+1.0i)+(num-test (- 0 1.0+1.0i) -1.0-1.0i)+(num-test (* 0 1.0+1.0i) 0.0)+(num-test (/ 0 1.0+1.0i) 0.0)+(num-test (= 0 1.0+1.0i) #f)+(num-test (+ 0 0) 0)+(num-test (- 0 0) 0)+(num-test (* 0 0) 0)+(num-test (+ 0 0.0) 0.0)+(num-test (- 0 0.0) 0.0)+(num-test (* 0 0.0) 0.0)+(num-test (+ 0 1234) 1234)+(num-test (- 0 1234) -1234)+(num-test (* 0 1234) 0)+(num-test (/ 0 1234) 0)+(num-test (= 0 1234) #f)+(num-test (< 0 1234) #t)+(num-test (<= 0 1234) #t)+(num-test (> 0 1234) #f)+(num-test (>= 0 1234) #f)+(num-test (+ 0 123.4) 123.4)+(num-test (- 0 123.4) -123.4)+(num-test (* 0 123.4) 0.0)+(num-test (/ 0 123.4) 0.0)+(num-test (= 0 123.4) #f)+(num-test (< 0 123.4) #t)+(num-test (<= 0 123.4) #t)+(num-test (> 0 123.4) #f)+(num-test (>= 0 123.4) #f)+(num-test (+ 0 1234/11) 1234/11)+(num-test (- 0 1234/11) -1234/11)+(num-test (* 0 1234/11) 0)+(num-test (/ 0 1234/11) 0)+(num-test (= 0 1234/11) #f)+(num-test (< 0 1234/11) #t)+(num-test (<= 0 1234/11) #t)+(num-test (> 0 1234/11) #f)+(num-test (>= 0 1234/11) #f)+(num-test (+ 0 1.234+1.234i) 1.234+1.234i)+(num-test (- 0 1.234+1.234i) -1.234-1.234i)+(num-test (* 0 1.234+1.234i) 0.0)+(num-test (/ 0 1.234+1.234i) 0.0)+(num-test (= 0 1.234+1.234i) #f)+(num-test (+ 0 -1.0+1.0i) -1.0+1.0i)+(num-test (- 0 -1.0+1.0i) 1.0-1.0i)+(num-test (* 0 -1.0+1.0i) -0.0)+(num-test (/ 0 -1.0+1.0i) -0.0)+(num-test (= 0 -1.0+1.0i) #f)+(num-test (+ 0 0.0+1.0i) 0.0+1.0i)+(num-test (- 0 0.0+1.0i) 0.0-1.0i)+(num-test (* 0 0.0+1.0i) 0.0)+(num-test (/ 0 0.0+1.0i) 0.0)+(num-test (= 0 0.0+1.0i) #f)+(num-test (+ 0.0 1) 1.0)+(num-test (- 0.0 1) -1.0)+(num-test (* 0.0 1) 0.0)+(num-test (/ 0.0 1) 0.0)+(num-test (= 0.0 1) #f)+(num-test (< 0.0 1) #t)+(num-test (<= 0.0 1) #t)+(num-test (> 0.0 1) #f)+(num-test (>= 0.0 1) #f)+(num-test (+ 0.0 1.0) 1.0)+(num-test (- 0.0 1.0) -1.0)+(num-test (* 0.0 1.0) 0.0)+(num-test (/ 0.0 1.0) 0.0)+(num-test (= 0.0 1.0) #f)+(num-test (< 0.0 1.0) #t)+(num-test (<= 0.0 1.0) #t)+(num-test (> 0.0 1.0) #f)+(num-test (>= 0.0 1.0) #f)+(num-test (+ 0.0 1/1) 1.0)+(num-test (- 0.0 1/1) -1.0)+(num-test (* 0.0 1/1) 0.0)+(num-test (/ 0.0 1/1) 0.0)+(num-test (= 0.0 1/1) #f)+(num-test (< 0.0 1/1) #t)+(num-test (<= 0.0 1/1) #t)+(num-test (> 0.0 1/1) #f)+(num-test (>= 0.0 1/1) #f)+(num-test (+ 0.0 1.0+1.0i) 1.0+1.0i)+(num-test (- 0.0 1.0+1.0i) -1.0-1.0i)+(num-test (* 0.0 1.0+1.0i) 0.0)+(num-test (/ 0.0 1.0+1.0i) 0.0)+(num-test (= 0.0 1.0+1.0i) #f)+(num-test (+ 0.0 0) 0.0)+(num-test (- 0.0 0) 0.0)+(num-test (* 0.0 0) 0.0)+(num-test (+ 0.0 0.0) 0.0)+(num-test (- 0.0 0.0) 0.0)+(num-test (* 0.0 0.0) 0.0)+(num-test (+ 0.0 1234) 1234.0)+(num-test (- 0.0 1234) -1234.0)+(num-test (* 0.0 1234) 0.0)+(num-test (/ 0.0 1234) 0.0)+(num-test (= 0.0 1234) #f)+(num-test (< 0.0 1234) #t)+(num-test (<= 0.0 1234) #t)+(num-test (> 0.0 1234) #f)+(num-test (>= 0.0 1234) #f)+(num-test (+ 0.0 123.4) 123.4)+(num-test (- 0.0 123.4) -123.4)+(num-test (* 0.0 123.4) 0.0)+(num-test (/ 0.0 123.4) 0.0)+(num-test (= 0.0 123.4) #f)+(num-test (< 0.0 123.4) #t)+(num-test (<= 0.0 123.4) #t)+(num-test (> 0.0 123.4) #f)+(num-test (>= 0.0 123.4) #f)+(num-test (+ 0.0 1234/11) 112.18181818181819)+(num-test (- 0.0 1234/11) -112.18181818181819)+(num-test (* 0.0 1234/11) 0.0)+(num-test (/ 0.0 1234/11) 0.0)+(num-test (= 0.0 1234/11) #f)+(num-test (< 0.0 1234/11) #t)+(num-test (<= 0.0 1234/11) #t)+(num-test (> 0.0 1234/11) #f)+(num-test (>= 0.0 1234/11) #f)+(num-test (+ 0.0 1.234+1.234i) 1.234+1.234i)+(num-test (- 0.0 1.234+1.234i) -1.234-1.234i)+(num-test (* 0.0 1.234+1.234i) 0.0)+(num-test (/ 0.0 1.234+1.234i) 0.0)+(num-test (= 0.0 1.234+1.234i) #f)+(num-test (+ 0.0 -1.0+1.0i) -1.0+1.0i)+(num-test (- 0.0 -1.0+1.0i) 1.0-1.0i)+(num-test (* 0.0 -1.0+1.0i) -0.0)+(num-test (/ 0.0 -1.0+1.0i) -0.0)+(num-test (= 0.0 -1.0+1.0i) #f)+(num-test (+ 0.0 0.0+1.0i) 0.0+1.0i)+(num-test (- 0.0 0.0+1.0i) 0.0-1.0i)+(num-test (* 0.0 0.0+1.0i) 0.0)+(num-test (/ 0.0 0.0+1.0i) 0.0)+(num-test (= 0.0 0.0+1.0i) #f)+(num-test (+ 1234 1) 1235)+(num-test (- 1234 1) 1233)+(num-test (* 1234 1) 1234)+(num-test (/ 1234 1) 1234)+(num-test (= 1234 1) #f)+(num-test (< 1234 1) #f)+(num-test (<= 1234 1) #f)+(num-test (> 1234 1) #t)+(num-test (>= 1234 1) #t)+(num-test (+ 1234 1.0) 1235.0)+(num-test (- 1234 1.0) 1233.0)+(num-test (* 1234 1.0) 1234.0)+(num-test (/ 1234 1.0) 1234.0)+(num-test (= 1234 1.0) #f)+(num-test (< 1234 1.0) #f)+(num-test (<= 1234 1.0) #f)+(num-test (> 1234 1.0) #t)+(num-test (>= 1234 1.0) #t)+(num-test (+ 1234 1/1) 1235)+(num-test (- 1234 1/1) 1233)+(num-test (* 1234 1/1) 1234)+(num-test (/ 1234 1/1) 1234)+(num-test (= 1234 1/1) #f)+(num-test (< 1234 1/1) #f)+(num-test (<= 1234 1/1) #f)+(num-test (> 1234 1/1) #t)+(num-test (>= 1234 1/1) #t)+(num-test (+ 1234 1.0+1.0i) 1235.0+1.0i)+(num-test (- 1234 1.0+1.0i) 1233.0-1.0i)+(num-test (* 1234 1.0+1.0i) 1234.0+1234.0i)+(num-test (/ 1234 1.0+1.0i) 617.0-617.0i)+(num-test (= 1234 1.0+1.0i) #f)+(num-test (+ 1234 0) 1234)+(num-test (- 1234 0) 1234)+(num-test (* 1234 0) 0)+(num-test (+ 1234 0.0) 1234.0)+(num-test (- 1234 0.0) 1234.0)+(num-test (* 1234 0.0) 0.0)+(num-test (+ 1234 1234) 2468)+(num-test (- 1234 1234) 0)+(num-test (* 1234 1234) 1522756)+(num-test (/ 1234 1234) 1)+(num-test (= 1234 1234) #t)+(num-test (< 1234 1234) #f)+(num-test (<= 1234 1234) #t)+(num-test (> 1234 1234) #f)+(num-test (>= 1234 1234) #t)+(num-test (+ 1234 123.4) 1357.4)+(num-test (- 1234 123.4) 1110.59999999999991)+(num-test (* 1234 123.4) 152275.60000000000582)+(num-test (/ 1234 123.4) 10.0)+(num-test (= 1234 123.4) #f)+(num-test (< 1234 123.4) #f)+(num-test (<= 1234 123.4) #f)+(num-test (> 1234 123.4) #t)+(num-test (>= 1234 123.4) #t)+(num-test (+ 1234 1234/11) 14808/11)+(num-test (- 1234 1234/11) 12340/11)+(num-test (* 1234 1234/11) 1522756/11)+(num-test (/ 1234 1234/11) 11)+(num-test (= 1234 1234/11) #f)+(num-test (< 1234 1234/11) #f)+(num-test (<= 1234 1234/11) #f)+(num-test (> 1234 1234/11) #t)+(num-test (>= 1234 1234/11) #t)+(num-test (+ 1234 1.234+1.234i) 1235.23399999999992+1.234i)+(num-test (- 1234 1.234+1.234i) 1232.766-1.234i)+(num-test (* 1234 1.234+1.234i) 1522.756+1522.756i)+(num-test (/ 1234 1.234+1.234i) 500.0-500.0i)+(num-test (= 1234 1.234+1.234i) #f)+(num-test (+ 1234 -1.0+1.0i) 1233.0+1.0i)+(num-test (- 1234 -1.0+1.0i) 1235.0-1.0i)+(num-test (* 1234 -1.0+1.0i) -1234.0+1234.0i)+(num-test (/ 1234 -1.0+1.0i) -617.0-617.0i)+(num-test (= 1234 -1.0+1.0i) #f)+(num-test (+ 1234 0.0+1.0i) 1234.0+1.0i)+(num-test (- 1234 0.0+1.0i) 1234.0-1.0i)+(num-test (* 1234 0.0+1.0i) 0.0+1234.0i)+(num-test (/ 1234 0.0+1.0i) 0.0-1234.0i)+(num-test (= 1234 0.0+1.0i) #f)+(num-test (+ 123.4 1) 124.4)+(num-test (- 123.4 1) 122.4)+(num-test (* 123.4 1) 123.4)+(num-test (/ 123.4 1) 123.4)+(num-test (= 123.4 1) #f)+(num-test (< 123.4 1) #f)+(num-test (<= 123.4 1) #f)+(num-test (> 123.4 1) #t)+(num-test (>= 123.4 1) #t)+(num-test (+ 123.4 1.0) 124.4)+(num-test (- 123.4 1.0) 122.4)+(num-test (* 123.4 1.0) 123.4)+(num-test (/ 123.4 1.0) 123.4)+(num-test (= 123.4 1.0) #f)+(num-test (< 123.4 1.0) #f)+(num-test (<= 123.4 1.0) #f)+(num-test (> 123.4 1.0) #t)+(num-test (>= 123.4 1.0) #t)+(num-test (+ 123.4 1/1) 124.4)+(num-test (- 123.4 1/1) 122.4)+(num-test (* 123.4 1/1) 123.4)+(num-test (/ 123.4 1/1) 123.4)+(num-test (= 123.4 1/1) #f)+(num-test (< 123.4 1/1) #f)+(num-test (<= 123.4 1/1) #f)+(num-test (> 123.4 1/1) #t)+(num-test (>= 123.4 1/1) #t)+(num-test (+ 123.4 1.0+1.0i) 124.4+1.0i)+(num-test (- 123.4 1.0+1.0i) 122.4-1.0i)+(num-test (* 123.4 1.0+1.0i) 123.4+123.4i)+(num-test (/ 123.4 1.0+1.0i) 61.7-61.7i)+(num-test (= 123.4 1.0+1.0i) #f)+(num-test (+ 123.4 0) 123.4)+(num-test (- 123.4 0) 123.4)+(num-test (* 123.4 0) 0.0)+(num-test (+ 123.4 0.0) 123.4)+(num-test (- 123.4 0.0) 123.4)+(num-test (* 123.4 0.0) 0.0)+(num-test (+ 123.4 1234) 1357.4)+(num-test (- 123.4 1234) -1110.59999999999991)+(num-test (* 123.4 1234) 152275.60000000000582)+(num-test (/ 123.4 1234) 0.1)+(num-test (= 123.4 1234) #f)+(num-test (< 123.4 1234) #t)+(num-test (<= 123.4 1234) #t)+(num-test (> 123.4 1234) #f)+(num-test (>= 123.4 1234) #f)+(num-test (+ 123.4 123.4) 246.8)+(num-test (- 123.4 123.4) 0.0)+(num-test (* 123.4 123.4) 15227.56000000000131)+(num-test (/ 123.4 123.4) 1.0)+(num-test (= 123.4 123.4) #t)+(num-test (< 123.4 123.4) #f)+(num-test (<= 123.4 123.4) #t)+(num-test (> 123.4 123.4) #f)+(num-test (>= 123.4 123.4) #t)+(num-test (+ 123.4 1234/11) 235.58181818181819)+(num-test (- 123.4 1234/11) 11.21818181818182)+(num-test (* 123.4 1234/11) 13843.23636363636433)+(num-test (/ 123.4 1234/11) 1.10000000000000)+(num-test (= 123.4 1234/11) #f)+(num-test (< 123.4 1234/11) #f)+(num-test (<= 123.4 1234/11) #f)+(num-test (> 123.4 1234/11) #t)+(num-test (>= 123.4 1234/11) #t)+(num-test (+ 123.4 1.234+1.234i) 124.634+1.234i)+(num-test (- 123.4 1.234+1.234i) 122.16600000000001-1.234i)+(num-test (* 123.4 1.234+1.234i) 152.2756+152.2756i)+(num-test (/ 123.4 1.234+1.234i) 50.0-50.0i)+(num-test (= 123.4 1.234+1.234i) #f)+(num-test (+ 123.4 -1.0+1.0i) 122.4+1.0i)+(num-test (- 123.4 -1.0+1.0i) 124.4-1.0i)+(num-test (* 123.4 -1.0+1.0i) -123.4+123.4i)+(num-test (/ 123.4 -1.0+1.0i) -61.7-61.7i)+(num-test (= 123.4 -1.0+1.0i) #f)+(num-test (+ 123.4 0.0+1.0i) 123.4+1.0i)+(num-test (- 123.4 0.0+1.0i) 123.4-1.0i)+(num-test (* 123.4 0.0+1.0i) 0.0+123.4i)+(num-test (/ 123.4 0.0+1.0i) 0.0-123.4i)+(num-test (= 123.4 0.0+1.0i) #f)+(num-test (+ 1234/11 1) 1245/11)+(num-test (- 1234/11 1) 1223/11)+(num-test (* 1234/11 1) 1234/11)+(num-test (/ 1234/11 1) 1234/11)+(num-test (= 1234/11 1) #f)+(num-test (< 1234/11 1) #f)+(num-test (<= 1234/11 1) #f)+(num-test (> 1234/11 1) #t)+(num-test (>= 1234/11 1) #t)+(num-test (+ 1234/11 1.0) 113.18181818181819)+(num-test (- 1234/11 1.0) 111.18181818181819)+(num-test (* 1234/11 1.0) 112.18181818181819)+(num-test (/ 1234/11 1.0) 112.18181818181819)+(num-test (= 1234/11 1.0) #f)+(num-test (< 1234/11 1.0) #f)+(num-test (<= 1234/11 1.0) #f)+(num-test (> 1234/11 1.0) #t)+(num-test (>= 1234/11 1.0) #t)+(num-test (+ 1234/11 1/1) 1245/11)+(num-test (- 1234/11 1/1) 1223/11)+(num-test (* 1234/11 1/1) 1234/11)+(num-test (/ 1234/11 1/1) 1234/11)+(num-test (= 1234/11 1/1) #f)+(num-test (< 1234/11 1/1) #f)+(num-test (<= 1234/11 1/1) #f)+(num-test (> 1234/11 1/1) #t)+(num-test (>= 1234/11 1/1) #t)+(num-test (+ 1234/11 1.0+1.0i) 113.18181818181819+1.0i)+(num-test (- 1234/11 1.0+1.0i) 111.18181818181819-1.0i)+(num-test (* 1234/11 1.0+1.0i) 112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 1.0+1.0i) 56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 1.0+1.0i) #f)+(num-test (+ 1234/11 0) 1234/11)+(num-test (- 1234/11 0) 1234/11)+(num-test (* 1234/11 0) 0)+(num-test (+ 1234/11 0.0) 112.18181818181819)+(num-test (- 1234/11 0.0) 112.18181818181819)+(num-test (* 1234/11 0.0) 0.0)+(num-test (+ 1234/11 1234) 14808/11)+(num-test (- 1234/11 1234) -12340/11)+(num-test (* 1234/11 1234) 1522756/11)+(num-test (/ 1234/11 1234) 1/11)+(num-test (= 1234/11 1234) #f)+(num-test (< 1234/11 1234) #t)+(num-test (<= 1234/11 1234) #t)+(num-test (> 1234/11 1234) #f)+(num-test (>= 1234/11 1234) #f)+(num-test (+ 1234/11 123.4) 235.58181818181819)+(num-test (- 1234/11 123.4) -11.21818181818182)+(num-test (* 1234/11 123.4) 13843.23636363636433)+(num-test (/ 1234/11 123.4) 0.90909090909091)+(num-test (= 1234/11 123.4) #f)+(num-test (< 1234/11 123.4) #t)+(num-test (<= 1234/11 123.4) #t)+(num-test (> 1234/11 123.4) #f)+(num-test (>= 1234/11 123.4) #f)+(num-test (+ 1234/11 1234/11) 2468/11)+(num-test (- 1234/11 1234/11) 0)+(num-test (* 1234/11 1234/11) 1522756/121)+(num-test (/ 1234/11 1234/11) 1)+(num-test (= 1234/11 1234/11) #t)+(num-test (< 1234/11 1234/11) #f)+(num-test (<= 1234/11 1234/11) #t)+(num-test (> 1234/11 1234/11) #f)+(num-test (>= 1234/11 1234/11) #t)+(num-test (+ 1234/11 1.234+1.234i) 113.41581818181818+1.234i)+(num-test (- 1234/11 1.234+1.234i) 110.94781818181819-1.234i)+(num-test (* 1234/11 1.234+1.234i) 138.43236363636365+138.43236363636365i)+(num-test (/ 1234/11 1.234+1.234i) 45.45454545454546-45.45454545454546i)+(num-test (= 1234/11 1.234+1.234i) #f)+(num-test (+ 1234/11 -1.0+1.0i) 111.18181818181819+1.0i)+(num-test (- 1234/11 -1.0+1.0i) 113.18181818181819-1.0i)+(num-test (* 1234/11 -1.0+1.0i) -112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 -1.0+1.0i) -56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 -1.0+1.0i) #f)+(num-test (+ 1234/11 0.0+1.0i) 112.18181818181819+1.0i)+(num-test (- 1234/11 0.0+1.0i) 112.18181818181819-1.0i)+(num-test (* 1234/11 0.0+1.0i) 0.0+112.18181818181819i)+(num-test (/ 1234/11 0.0+1.0i) 0.0-112.18181818181819i)+(num-test (= 1234/11 0.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1) 2.234+1.234i)+(num-test (- 1.234+1.234i 1) 0.234+1.234i)+(num-test (* 1.234+1.234i 1) 1.234+1.234i)+(num-test (/ 1.234+1.234i 1) 1.234+1.234i)+(num-test (= 1.234+1.234i 1) #f)+(num-test (+ 1.234+1.234i 1.0) 2.234+1.234i)+(num-test (- 1.234+1.234i 1.0) 0.234+1.234i)+(num-test (* 1.234+1.234i 1.0) 1.234+1.234i)+(num-test (/ 1.234+1.234i 1.0) 1.234+1.234i)+(num-test (= 1.234+1.234i 1.0) #f)+(num-test (+ 1.234+1.234i 1/1) 2.234+1.234i)+(num-test (- 1.234+1.234i 1/1) 0.234+1.234i)+(num-test (* 1.234+1.234i 1/1) 1.234+1.234i)+(num-test (/ 1.234+1.234i 1/1) 1.234+1.234i)+(num-test (= 1.234+1.234i 1/1) #f)+(num-test (+ 1.234+1.234i 1.0+1.0i) 2.234+2.234i)+(num-test (- 1.234+1.234i 1.0+1.0i) 0.234+0.234i)+(num-test (* 1.234+1.234i 1.0+1.0i) 0.0+2.468i)+(num-test (/ 1.234+1.234i 1.0+1.0i) 1.234)+(num-test (= 1.234+1.234i 1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 0) 1.234+1.234i)+(num-test (- 1.234+1.234i 0) 1.234+1.234i)+(num-test (* 1.234+1.234i 0) 0.0)+(num-test (+ 1.234+1.234i 0.0) 1.234+1.234i)+(num-test (- 1.234+1.234i 0.0) 1.234+1.234i)+(num-test (* 1.234+1.234i 0.0) 0.0)+(num-test (+ 1.234+1.234i 1234) 1235.23399999999992+1.234i)+(num-test (- 1.234+1.234i 1234) -1232.766+1.234i)+(num-test (* 1.234+1.234i 1234) 1522.756+1522.756i)+(num-test (/ 1.234+1.234i 1234) 0.001+0.001i)+(num-test (= 1.234+1.234i 1234) #f)+(num-test (+ 1.234+1.234i 123.4) 124.634+1.234i)+(num-test (- 1.234+1.234i 123.4) -122.16600000000001+1.234i)+(num-test (* 1.234+1.234i 123.4) 152.2756+152.2756i)+(num-test (/ 1.234+1.234i 123.4) 0.01+0.01i)+(num-test (= 1.234+1.234i 123.4) #f)+(num-test (+ 1.234+1.234i 1234/11) 113.41581818181818+1.234i)+(num-test (- 1.234+1.234i 1234/11) -110.94781818181818+1.234i)+(num-test (* 1.234+1.234i 1234/11) 138.43236363636365+138.43236363636365i)+(num-test (/ 1.234+1.234i 1234/11) 0.011+0.011i)+(num-test (= 1.234+1.234i 1234/11) #f)+(num-test (+ 1.234+1.234i 1.234+1.234i) 2.468+2.468i)+(num-test (- 1.234+1.234i 1.234+1.234i) 0.0)+(num-test (* 1.234+1.234i 1.234+1.234i) 0.0+3.04551200000000i)+(num-test (/ 1.234+1.234i 1.234+1.234i) 1.0)+(num-test (= 1.234+1.234i 1.234+1.234i) #t)+(num-test (+ 1.234+1.234i -1.0+1.0i) 0.234+2.234i)+(num-test (- 1.234+1.234i -1.0+1.0i) 2.234+0.234i)+(num-test (* 1.234+1.234i -1.0+1.0i) -2.468)+(num-test (/ 1.234+1.234i -1.0+1.0i) -0.0-1.234i)+(num-test (= 1.234+1.234i -1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 0.0+1.0i) 1.234+2.234i)+(num-test (- 1.234+1.234i 0.0+1.0i) 1.234+0.234i)+(num-test (* 1.234+1.234i 0.0+1.0i) -1.234+1.234i)+(num-test (/ 1.234+1.234i 0.0+1.0i) 1.234-1.234i)+(num-test (= 1.234+1.234i 0.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1) 0.0+1.0i)+(num-test (- -1.0+1.0i 1) -2.0+1.0i)+(num-test (* -1.0+1.0i 1) -1.0+1.0i)+(num-test (/ -1.0+1.0i 1) -1.0+1.0i)+(num-test (= -1.0+1.0i 1) #f)+(num-test (+ -1.0+1.0i 1.0) 0.0+1.0i)+(num-test (- -1.0+1.0i 1.0) -2.0+1.0i)+(num-test (* -1.0+1.0i 1.0) -1.0+1.0i)+(num-test (/ -1.0+1.0i 1.0) -1.0+1.0i)+(num-test (= -1.0+1.0i 1.0) #f)+(num-test (+ -1.0+1.0i 1/1) 0.0+1.0i)+(num-test (- -1.0+1.0i 1/1) -2.0+1.0i)+(num-test (* -1.0+1.0i 1/1) -1.0+1.0i)+(num-test (/ -1.0+1.0i 1/1) -1.0+1.0i)+(num-test (= -1.0+1.0i 1/1) #f)+(num-test (+ -1.0+1.0i 1.0+1.0i) 0.0+2.0i)+(num-test (- -1.0+1.0i 1.0+1.0i) -2.0)+(num-test (* -1.0+1.0i 1.0+1.0i) -2.0)+(num-test (/ -1.0+1.0i 1.0+1.0i) 0.0+1.0i)+(num-test (= -1.0+1.0i 1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 0) -1.0+1.0i)+(num-test (- -1.0+1.0i 0) -1.0+1.0i)+(num-test (* -1.0+1.0i 0) -0.0)+(num-test (+ -1.0+1.0i 0.0) -1.0+1.0i)+(num-test (- -1.0+1.0i 0.0) -1.0+1.0i)+(num-test (* -1.0+1.0i 0.0) -0.0)+(num-test (+ -1.0+1.0i 1234) 1233.0+1.0i)+(num-test (- -1.0+1.0i 1234) -1235.0+1.0i)+(num-test (* -1.0+1.0i 1234) -1234.0+1234.0i)+(num-test (/ -1.0+1.0i 1234) -0.00081037277147+0.00081037277147i)+(num-test (= -1.0+1.0i 1234) #f)+(num-test (+ -1.0+1.0i 123.4) 122.4+1.0i)+(num-test (- -1.0+1.0i 123.4) -124.4+1.0i)+(num-test (* -1.0+1.0i 123.4) -123.4+123.4i)+(num-test (/ -1.0+1.0i 123.4) -0.00810372771475+0.00810372771475i)+(num-test (= -1.0+1.0i 123.4) #f)+(num-test (+ -1.0+1.0i 1234/11) 111.18181818181819+1.0i)+(num-test (- -1.0+1.0i 1234/11) -113.18181818181819+1.0i)+(num-test (* -1.0+1.0i 1234/11) -112.18181818181819+112.18181818181819i)+(num-test (/ -1.0+1.0i 1234/11) -0.00891410048622+0.00891410048622i)+(num-test (= -1.0+1.0i 1234/11) #f)+(num-test (+ -1.0+1.0i 1.234+1.234i) 0.234+2.234i)+(num-test (- -1.0+1.0i 1.234+1.234i) -2.234-0.234i)+(num-test (* -1.0+1.0i 1.234+1.234i) -2.468)+(num-test (/ -1.0+1.0i 1.234+1.234i) 0.0+0.81037277147488i)+(num-test (= -1.0+1.0i 1.234+1.234i) #f)+(num-test (+ -1.0+1.0i -1.0+1.0i) -2.0+2.0i)+(num-test (- -1.0+1.0i -1.0+1.0i) 0.0)+(num-test (* -1.0+1.0i -1.0+1.0i) 0.0-2.0i)+(num-test (/ -1.0+1.0i -1.0+1.0i) 1.0)+(num-test (= -1.0+1.0i -1.0+1.0i) #t)+(num-test (+ -1.0+1.0i 0.0+1.0i) -1.0+2.0i)+(num-test (- -1.0+1.0i 0.0+1.0i) -1.0)+(num-test (* -1.0+1.0i 0.0+1.0i) -1.0-1.0i)+(num-test (/ -1.0+1.0i 0.0+1.0i) 1.0+1.0i)+(num-test (= -1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1) 1.0+1.0i)+(num-test (- 0.0+1.0i 1) -1.0+1.0i)+(num-test (* 0.0+1.0i 1) 0.0+1.0i)+(num-test (/ 0.0+1.0i 1) 0.0+1.0i)+(num-test (= 0.0+1.0i 1) #f)+(num-test (+ 0.0+1.0i 1.0) 1.0+1.0i)+(num-test (- 0.0+1.0i 1.0) -1.0+1.0i)+(num-test (* 0.0+1.0i 1.0) 0.0+1.0i)+(num-test (/ 0.0+1.0i 1.0) 0.0+1.0i)+(num-test (= 0.0+1.0i 1.0) #f)+(num-test (+ 0.0+1.0i 1/1) 1.0+1.0i)+(num-test (- 0.0+1.0i 1/1) -1.0+1.0i)+(num-test (* 0.0+1.0i 1/1) 0.0+1.0i)+(num-test (/ 0.0+1.0i 1/1) 0.0+1.0i)+(num-test (= 0.0+1.0i 1/1) #f)+(num-test (+ 0.0+1.0i 1.0+1.0i) 1.0+2.0i)+(num-test (- 0.0+1.0i 1.0+1.0i) -1.0)+(num-test (* 0.0+1.0i 1.0+1.0i) -1.0+1.0i)+(num-test (/ 0.0+1.0i 1.0+1.0i) 0.5+0.5i)+(num-test (= 0.0+1.0i 1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 0) 0.0+1.0i)+(num-test (- 0.0+1.0i 0) 0.0+1.0i)+(num-test (* 0.0+1.0i 0) 0.0)+(num-test (+ 0.0+1.0i 0.0) 0.0+1.0i)+(num-test (- 0.0+1.0i 0.0) 0.0+1.0i)+(num-test (* 0.0+1.0i 0.0) 0.0)+(num-test (+ 0.0+1.0i 1234) 1234.0+1.0i)+(num-test (- 0.0+1.0i 1234) -1234.0+1.0i)+(num-test (* 0.0+1.0i 1234) 0.0+1234.0i)+(num-test (/ 0.0+1.0i 1234) 0.0+0.00081037277147i)+(num-test (= 0.0+1.0i 1234) #f)+(num-test (+ 0.0+1.0i 123.4) 123.4+1.0i)+(num-test (- 0.0+1.0i 123.4) -123.4+1.0i)+(num-test (* 0.0+1.0i 123.4) 0.0+123.4i)+(num-test (/ 0.0+1.0i 123.4) 0.0+0.00810372771475i)+(num-test (= 0.0+1.0i 123.4) #f)+(num-test (+ 0.0+1.0i 1234/11) 112.18181818181819+1.0i)+(num-test (- 0.0+1.0i 1234/11) -112.18181818181819+1.0i)+(num-test (* 0.0+1.0i 1234/11) 0.0+112.18181818181819i)+(num-test (/ 0.0+1.0i 1234/11) 0.0+0.00891410048622i)+(num-test (= 0.0+1.0i 1234/11) #f)+(num-test (+ 0.0+1.0i 1.234+1.234i) 1.234+2.234i)+(num-test (- 0.0+1.0i 1.234+1.234i) -1.234-0.234i)+(num-test (* 0.0+1.0i 1.234+1.234i) -1.234+1.234i)+(num-test (/ 0.0+1.0i 1.234+1.234i) 0.40518638573744+0.40518638573744i)+(num-test (= 0.0+1.0i 1.234+1.234i) #f)+(num-test (+ 0.0+1.0i -1.0+1.0i) -1.0+2.0i)+(num-test (- 0.0+1.0i -1.0+1.0i) 1.0)+(num-test (* 0.0+1.0i -1.0+1.0i) -1.0-1.0i)+(num-test (/ 0.0+1.0i -1.0+1.0i) 0.5-0.5i)+(num-test (= 0.0+1.0i -1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 0.0+1.0i) 0.0+2.0i)+(num-test (- 0.0+1.0i 0.0+1.0i) 0.0)+(num-test (* 0.0+1.0i 0.0+1.0i) -1.0)+(num-test (/ 0.0+1.0i 0.0+1.0i) 1.0)+(num-test (= 0.0+1.0i 0.0+1.0i) #t)+(num-test (+ 1 1 1) 3)+(num-test (- 1 1 1) -1)+(num-test (* 1 1 1) 1)+(num-test (/ 1 1 1) 1)+(num-test (= 1 1 1) #t)+(num-test (< 1 1 1) #f)+(num-test (<= 1 1 1) #t)+(num-test (> 1 1 1) #f)+(num-test (>= 1 1 1) #t)+(num-test (+ 1 1 1.0) 3.0)+(num-test (- 1 1 1.0) -1.0)+(num-test (* 1 1 1.0) 1.0)+(num-test (/ 1 1 1.0) 1.0)+(num-test (= 1 1 1.0) #t)+(num-test (< 1 1 1.0) #f)+(num-test (<= 1 1 1.0) #t)+(num-test (> 1 1 1.0) #f)+(num-test (>= 1 1 1.0) #t)+(num-test (+ 1 1 1/1) 3)+(num-test (- 1 1 1/1) -1)+(num-test (* 1 1 1/1) 1)+(num-test (/ 1 1 1/1) 1)+(num-test (= 1 1 1/1) #t)+(num-test (< 1 1 1/1) #f)+(num-test (<= 1 1 1/1) #t)+(num-test (> 1 1 1/1) #f)+(num-test (>= 1 1 1/1) #t)+(num-test (+ 1 1 1.0+1.0i) 3.0+1.0i)+(num-test (- 1 1 1.0+1.0i) -1.0-1.0i)+(num-test (* 1 1 1.0+1.0i) 1.0+1.0i)+(num-test (/ 1 1 1.0+1.0i) 0.5-0.5i)+(num-test (= 1 1 1.0+1.0i) #f)+(num-test (+ 1 1 0) 2)+(num-test (- 1 1 0) 0)+(num-test (* 1 1 0) 0)+(num-test (+ 1 1 0.0) 2.0)+(num-test (- 1 1 0.0) 0.0)+(num-test (* 1 1 0.0) 0.0)+(num-test (+ 1 1 1234) 1236)+(num-test (- 1 1 1234) -1234)+(num-test (* 1 1 1234) 1234)+(num-test (/ 1 1 1234) 1/1234)+(num-test (= 1 1 1234) #f)+(num-test (< 1 1 1234) #f)+(num-test (<= 1 1 1234) #t)+(num-test (> 1 1 1234) #f)+(num-test (>= 1 1 1234) #f)+(num-test (+ 1 1 123.4) 125.4)+(num-test (- 1 1 123.4) -123.4)+(num-test (* 1 1 123.4) 123.4)+(num-test (/ 1 1 123.4) 0.00810372771475)+(num-test (= 1 1 123.4) #f)+(num-test (< 1 1 123.4) #f)+(num-test (<= 1 1 123.4) #t)+(num-test (> 1 1 123.4) #f)+(num-test (>= 1 1 123.4) #f)+(num-test (+ 1 1 1234/11) 1256/11)+(num-test (- 1 1 1234/11) -1234/11)+(num-test (* 1 1 1234/11) 1234/11)+(num-test (/ 1 1 1234/11) 11/1234)+(num-test (= 1 1 1234/11) #f)+(num-test (< 1 1 1234/11) #f)+(num-test (<= 1 1 1234/11) #t)+(num-test (> 1 1 1234/11) #f)+(num-test (>= 1 1 1234/11) #f)+(num-test (+ 1 1 1.234+1.234i) 3.234+1.234i)+(num-test (- 1 1 1.234+1.234i) -1.234-1.234i)+(num-test (* 1 1 1.234+1.234i) 1.234+1.234i)+(num-test (/ 1 1 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1 1 1.234+1.234i) #f)+(num-test (+ 1 1 -1.0+1.0i) 1.0+1.0i)+(num-test (- 1 1 -1.0+1.0i) 1.0-1.0i)+(num-test (* 1 1 -1.0+1.0i) -1.0+1.0i)+(num-test (/ 1 1 -1.0+1.0i) -0.5-0.5i)+(num-test (= 1 1 -1.0+1.0i) #f)+(num-test (+ 1 1 0.0+1.0i) 2.0+1.0i)+(num-test (- 1 1 0.0+1.0i) 0.0-1.0i)+(num-test (* 1 1 0.0+1.0i) 0.0+1.0i)+(num-test (/ 1 1 0.0+1.0i) 0.0-1.0i)+(num-test (= 1 1 0.0+1.0i) #f)+(num-test (+ 1 1.0 1) 3.0)+(num-test (- 1 1.0 1) -1.0)+(num-test (* 1 1.0 1) 1.0)+(num-test (/ 1 1.0 1) 1.0)+(num-test (= 1 1.0 1) #t)+(num-test (< 1 1.0 1) #f)+(num-test (<= 1 1.0 1) #t)+(num-test (> 1 1.0 1) #f)+(num-test (>= 1 1.0 1) #t)+(num-test (+ 1 1.0 1.0) 3.0)+(num-test (- 1 1.0 1.0) -1.0)+(num-test (* 1 1.0 1.0) 1.0)+(num-test (/ 1 1.0 1.0) 1.0)+(num-test (= 1 1.0 1.0) #t)+(num-test (< 1 1.0 1.0) #f)+(num-test (<= 1 1.0 1.0) #t)+(num-test (> 1 1.0 1.0) #f)+(num-test (>= 1 1.0 1.0) #t)+(num-test (+ 1 1.0 1/1) 3.0)+(num-test (- 1 1.0 1/1) -1.0)+(num-test (* 1 1.0 1/1) 1.0)+(num-test (/ 1 1.0 1/1) 1.0)+(num-test (= 1 1.0 1/1) #t)+(num-test (< 1 1.0 1/1) #f)+(num-test (<= 1 1.0 1/1) #t)+(num-test (> 1 1.0 1/1) #f)+(num-test (>= 1 1.0 1/1) #t)+(num-test (+ 1 1.0 1.0+1.0i) 3.0+1.0i)+(num-test (- 1 1.0 1.0+1.0i) -1.0-1.0i)+(num-test (* 1 1.0 1.0+1.0i) 1.0+1.0i)+(num-test (/ 1 1.0 1.0+1.0i) 0.5-0.5i)+(num-test (= 1 1.0 1.0+1.0i) #f)+(num-test (+ 1 1.0 0) 2.0)+(num-test (- 1 1.0 0) 0.0)+(num-test (* 1 1.0 0) 0.0)+(num-test (+ 1 1.0 0.0) 2.0)+(num-test (- 1 1.0 0.0) 0.0)+(num-test (* 1 1.0 0.0) 0.0)+(num-test (+ 1 1.0 1234) 1236.0)+(num-test (- 1 1.0 1234) -1234.0)+(num-test (* 1 1.0 1234) 1234.0)+(num-test (/ 1 1.0 1234) 0.00081037277147)+(num-test (= 1 1.0 1234) #f)+(num-test (< 1 1.0 1234) #f)+(num-test (<= 1 1.0 1234) #t)+(num-test (> 1 1.0 1234) #f)+(num-test (>= 1 1.0 1234) #f)+(num-test (+ 1 1.0 123.4) 125.4)+(num-test (- 1 1.0 123.4) -123.4)+(num-test (* 1 1.0 123.4) 123.4)+(num-test (/ 1 1.0 123.4) 0.00810372771475)+(num-test (= 1 1.0 123.4) #f)+(num-test (< 1 1.0 123.4) #f)+(num-test (<= 1 1.0 123.4) #t)+(num-test (> 1 1.0 123.4) #f)+(num-test (>= 1 1.0 123.4) #f)+(num-test (+ 1 1.0 1234/11) 114.18181818181819)+(num-test (- 1 1.0 1234/11) -112.18181818181819)+(num-test (* 1 1.0 1234/11) 112.18181818181819)+(num-test (/ 1 1.0 1234/11) 0.00891410048622)+(num-test (= 1 1.0 1234/11) #f)+(num-test (< 1 1.0 1234/11) #f)+(num-test (<= 1 1.0 1234/11) #t)+(num-test (> 1 1.0 1234/11) #f)+(num-test (>= 1 1.0 1234/11) #f)+(num-test (+ 1 1.0 1.234+1.234i) 3.234+1.234i)+(num-test (- 1 1.0 1.234+1.234i) -1.234-1.234i)+(num-test (* 1 1.0 1.234+1.234i) 1.234+1.234i)+(num-test (/ 1 1.0 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1 1.0 1.234+1.234i) #f)+(num-test (+ 1 1.0 -1.0+1.0i) 1.0+1.0i)+(num-test (- 1 1.0 -1.0+1.0i) 1.0-1.0i)+(num-test (* 1 1.0 -1.0+1.0i) -1.0+1.0i)+(num-test (/ 1 1.0 -1.0+1.0i) -0.5-0.5i)+(num-test (= 1 1.0 -1.0+1.0i) #f)+(num-test (+ 1 1.0 0.0+1.0i) 2.0+1.0i)+(num-test (- 1 1.0 0.0+1.0i) 0.0-1.0i)+(num-test (* 1 1.0 0.0+1.0i) 0.0+1.0i)+(num-test (/ 1 1.0 0.0+1.0i) 0.0-1.0i)+(num-test (= 1 1.0 0.0+1.0i) #f)+(num-test (+ 1 1/1 1) 3)+(num-test (- 1 1/1 1) -1)+(num-test (* 1 1/1 1) 1)+(num-test (/ 1 1/1 1) 1)+(num-test (= 1 1/1 1) #t)+(num-test (< 1 1/1 1) #f)+(num-test (<= 1 1/1 1) #t)+(num-test (> 1 1/1 1) #f)+(num-test (>= 1 1/1 1) #t)+(num-test (+ 1 1/1 1.0) 3.0)+(num-test (- 1 1/1 1.0) -1.0)+(num-test (* 1 1/1 1.0) 1.0)+(num-test (/ 1 1/1 1.0) 1.0)+(num-test (= 1 1/1 1.0) #t)+(num-test (< 1 1/1 1.0) #f)+(num-test (<= 1 1/1 1.0) #t)+(num-test (> 1 1/1 1.0) #f)+(num-test (>= 1 1/1 1.0) #t)+(num-test (+ 1 1/1 1/1) 3)+(num-test (- 1 1/1 1/1) -1)+(num-test (* 1 1/1 1/1) 1)+(num-test (/ 1 1/1 1/1) 1)+(num-test (= 1 1/1 1/1) #t)+(num-test (< 1 1/1 1/1) #f)+(num-test (<= 1 1/1 1/1) #t)+(num-test (> 1 1/1 1/1) #f)+(num-test (>= 1 1/1 1/1) #t)+(num-test (+ 1 1/1 1.0+1.0i) 3.0+1.0i)+(num-test (- 1 1/1 1.0+1.0i) -1.0-1.0i)+(num-test (* 1 1/1 1.0+1.0i) 1.0+1.0i)+(num-test (/ 1 1/1 1.0+1.0i) 0.5-0.5i)+(num-test (= 1 1/1 1.0+1.0i) #f)+(num-test (+ 1 1/1 0) 2)+(num-test (- 1 1/1 0) 0)+(num-test (* 1 1/1 0) 0)+(num-test (+ 1 1/1 0.0) 2.0)+(num-test (- 1 1/1 0.0) 0.0)+(num-test (* 1 1/1 0.0) 0.0)+(num-test (+ 1 1/1 1234) 1236)+(num-test (- 1 1/1 1234) -1234)+(num-test (* 1 1/1 1234) 1234)+(num-test (/ 1 1/1 1234) 1/1234)+(num-test (= 1 1/1 1234) #f)+(num-test (< 1 1/1 1234) #f)+(num-test (<= 1 1/1 1234) #t)+(num-test (> 1 1/1 1234) #f)+(num-test (>= 1 1/1 1234) #f)+(num-test (+ 1 1/1 123.4) 125.4)+(num-test (- 1 1/1 123.4) -123.4)+(num-test (* 1 1/1 123.4) 123.4)+(num-test (/ 1 1/1 123.4) 0.00810372771475)+(num-test (= 1 1/1 123.4) #f)+(num-test (< 1 1/1 123.4) #f)+(num-test (<= 1 1/1 123.4) #t)+(num-test (> 1 1/1 123.4) #f)+(num-test (>= 1 1/1 123.4) #f)+(num-test (+ 1 1/1 1234/11) 1256/11)+(num-test (- 1 1/1 1234/11) -1234/11)+(num-test (* 1 1/1 1234/11) 1234/11)+(num-test (/ 1 1/1 1234/11) 11/1234)+(num-test (= 1 1/1 1234/11) #f)+(num-test (< 1 1/1 1234/11) #f)+(num-test (<= 1 1/1 1234/11) #t)+(num-test (> 1 1/1 1234/11) #f)+(num-test (>= 1 1/1 1234/11) #f)+(num-test (+ 1 1/1 1.234+1.234i) 3.234+1.234i)+(num-test (- 1 1/1 1.234+1.234i) -1.234-1.234i)+(num-test (* 1 1/1 1.234+1.234i) 1.234+1.234i)+(num-test (/ 1 1/1 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1 1/1 1.234+1.234i) #f)+(num-test (+ 1 1/1 -1.0+1.0i) 1.0+1.0i)+(num-test (- 1 1/1 -1.0+1.0i) 1.0-1.0i)+(num-test (* 1 1/1 -1.0+1.0i) -1.0+1.0i)+(num-test (/ 1 1/1 -1.0+1.0i) -0.5-0.5i)+(num-test (= 1 1/1 -1.0+1.0i) #f)+(num-test (+ 1 1/1 0.0+1.0i) 2.0+1.0i)+(num-test (- 1 1/1 0.0+1.0i) 0.0-1.0i)+(num-test (* 1 1/1 0.0+1.0i) 0.0+1.0i)+(num-test (/ 1 1/1 0.0+1.0i) 0.0-1.0i)+(num-test (= 1 1/1 0.0+1.0i) #f)+(num-test (+ 1 1.0+1.0i 1) 3.0+1.0i)+(num-test (- 1 1.0+1.0i 1) -1.0-1.0i)+(num-test (* 1 1.0+1.0i 1) 1.0+1.0i)+(num-test (/ 1 1.0+1.0i 1) 0.5-0.5i)+(num-test (= 1 1.0+1.0i 1) #f)+(num-test (+ 1 1.0+1.0i 1.0) 3.0+1.0i)+(num-test (- 1 1.0+1.0i 1.0) -1.0-1.0i)+(num-test (* 1 1.0+1.0i 1.0) 1.0+1.0i)+(num-test (/ 1 1.0+1.0i 1.0) 0.5-0.5i)+(num-test (= 1 1.0+1.0i 1.0) #f)+(num-test (+ 1 1.0+1.0i 1/1) 3.0+1.0i)+(num-test (- 1 1.0+1.0i 1/1) -1.0-1.0i)+(num-test (* 1 1.0+1.0i 1/1) 1.0+1.0i)+(num-test (/ 1 1.0+1.0i 1/1) 0.5-0.5i)+(num-test (= 1 1.0+1.0i 1/1) #f)+(num-test (+ 1 1.0+1.0i 1.0+1.0i) 3.0+2.0i)+(num-test (- 1 1.0+1.0i 1.0+1.0i) -1.0-2.0i)+(num-test (* 1 1.0+1.0i 1.0+1.0i) 0.0+2.0i)+(num-test (/ 1 1.0+1.0i 1.0+1.0i) 0.0-0.5i)+(num-test (= 1 1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1 1.0+1.0i 0) 2.0+1.0i)+(num-test (- 1 1.0+1.0i 0) 0.0-1.0i)+(num-test (* 1 1.0+1.0i 0) 0.0)+(num-test (+ 1 1.0+1.0i 0.0) 2.0+1.0i)+(num-test (- 1 1.0+1.0i 0.0) 0.0-1.0i)+(num-test (* 1 1.0+1.0i 0.0) 0.0)+(num-test (+ 1 1.0+1.0i 1234) 1236.0+1.0i)+(num-test (- 1 1.0+1.0i 1234) -1234.0-1.0i)+(num-test (* 1 1.0+1.0i 1234) 1234.0+1234.0i)+(num-test (/ 1 1.0+1.0i 1234) 0.00040518638574-0.00040518638574i)+(num-test (= 1 1.0+1.0i 1234) #f)+(num-test (+ 1 1.0+1.0i 123.4) 125.4+1.0i)+(num-test (- 1 1.0+1.0i 123.4) -123.4-1.0i)+(num-test (* 1 1.0+1.0i 123.4) 123.4+123.4i)+(num-test (/ 1 1.0+1.0i 123.4) 0.00405186385737-0.00405186385737i)+(num-test (= 1 1.0+1.0i 123.4) #f)+(num-test (+ 1 1.0+1.0i 1234/11) 114.18181818181819+1.0i)+(num-test (- 1 1.0+1.0i 1234/11) -112.18181818181819-1.0i)+(num-test (* 1 1.0+1.0i 1234/11) 112.18181818181819+112.18181818181819i)+(num-test (/ 1 1.0+1.0i 1234/11) 0.00445705024311-0.00445705024311i)+(num-test (= 1 1.0+1.0i 1234/11) #f)+(num-test (+ 1 1.0+1.0i 1.234+1.234i) 3.234+2.234i)+(num-test (- 1 1.0+1.0i 1.234+1.234i) -1.234-2.234i)+(num-test (* 1 1.0+1.0i 1.234+1.234i) 0.0+2.468i)+(num-test (/ 1 1.0+1.0i 1.234+1.234i) 0.0-0.40518638573744i)+(num-test (= 1 1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1 1.0+1.0i -1.0+1.0i) 1.0+2.0i)+(num-test (- 1 1.0+1.0i -1.0+1.0i) 1.0-2.0i)+(num-test (* 1 1.0+1.0i -1.0+1.0i) -2.0)+(num-test (/ 1 1.0+1.0i -1.0+1.0i) -0.5)+(num-test (= 1 1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1 1.0+1.0i 0.0+1.0i) 2.0+2.0i)+(num-test (- 1 1.0+1.0i 0.0+1.0i) 0.0-2.0i)+(num-test (* 1 1.0+1.0i 0.0+1.0i) -1.0+1.0i)+(num-test (/ 1 1.0+1.0i 0.0+1.0i) -0.5-0.5i)+(num-test (= 1 1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1 0 1) 2)+(num-test (- 1 0 1) 0)+(num-test (* 1 0 1) 0)+(num-test (+ 1 0 1.0) 2.0)+(num-test (- 1 0 1.0) 0.0)+(num-test (* 1 0 1.0) 0.0)+(num-test (+ 1 0 1/1) 2)+(num-test (- 1 0 1/1) 0)+(num-test (* 1 0 1/1) 0)+(num-test (+ 1 0 1.0+1.0i) 2.0+1.0i)+(num-test (- 1 0 1.0+1.0i) 0.0-1.0i)+(num-test (* 1 0 1.0+1.0i) 0.0)+(num-test (+ 1 0 0) 1)+(num-test (- 1 0 0) 1)+(num-test (* 1 0 0) 0)+(num-test (+ 1 0 0.0) 1.0)+(num-test (- 1 0 0.0) 1.0)+(num-test (* 1 0 0.0) 0.0)+(num-test (+ 1 0 1234) 1235)+(num-test (- 1 0 1234) -1233)+(num-test (* 1 0 1234) 0)+(num-test (+ 1 0 123.4) 124.4)+(num-test (- 1 0 123.4) -122.4)+(num-test (* 1 0 123.4) 0.0)+(num-test (+ 1 0 1234/11) 1245/11)+(num-test (- 1 0 1234/11) -1223/11)+(num-test (* 1 0 1234/11) 0)+(num-test (+ 1 0 1.234+1.234i) 2.234+1.234i)+(num-test (- 1 0 1.234+1.234i) -0.234-1.234i)+(num-test (* 1 0 1.234+1.234i) 0.0)+(num-test (+ 1 0 -1.0+1.0i) 0.0+1.0i)+(num-test (- 1 0 -1.0+1.0i) 2.0-1.0i)+(num-test (* 1 0 -1.0+1.0i) -0.0)+(num-test (+ 1 0 0.0+1.0i) 1.0+1.0i)+(num-test (- 1 0 0.0+1.0i) 1.0-1.0i)+(num-test (* 1 0 0.0+1.0i) 0.0)+(num-test (+ 1 0.0 1) 2.0)+(num-test (- 1 0.0 1) 0.0)+(num-test (* 1 0.0 1) 0.0)+(num-test (+ 1 0.0 1.0) 2.0)+(num-test (- 1 0.0 1.0) 0.0)+(num-test (* 1 0.0 1.0) 0.0)+(num-test (+ 1 0.0 1/1) 2.0)+(num-test (- 1 0.0 1/1) 0.0)+(num-test (* 1 0.0 1/1) 0.0)+(num-test (+ 1 0.0 1.0+1.0i) 2.0+1.0i)+(num-test (- 1 0.0 1.0+1.0i) 0.0-1.0i)+(num-test (* 1 0.0 1.0+1.0i) 0.0)+(num-test (+ 1 0.0 0) 1.0)+(num-test (- 1 0.0 0) 1.0)+(num-test (* 1 0.0 0) 0.0)+(num-test (+ 1 0.0 0.0) 1.0)+(num-test (- 1 0.0 0.0) 1.0)+(num-test (* 1 0.0 0.0) 0.0)+(num-test (+ 1 0.0 1234) 1235.0)+(num-test (- 1 0.0 1234) -1233.0)+(num-test (* 1 0.0 1234) 0.0)+(num-test (+ 1 0.0 123.4) 124.4)+(num-test (- 1 0.0 123.4) -122.4)+(num-test (* 1 0.0 123.4) 0.0)+(num-test (+ 1 0.0 1234/11) 113.18181818181819)+(num-test (- 1 0.0 1234/11) -111.18181818181819)+(num-test (* 1 0.0 1234/11) 0.0)+(num-test (+ 1 0.0 1.234+1.234i) 2.234+1.234i)+(num-test (- 1 0.0 1.234+1.234i) -0.234-1.234i)+(num-test (* 1 0.0 1.234+1.234i) 0.0)+(num-test (+ 1 0.0 -1.0+1.0i) 0.0+1.0i)+(num-test (- 1 0.0 -1.0+1.0i) 2.0-1.0i)+(num-test (* 1 0.0 -1.0+1.0i) -0.0)+(num-test (+ 1 0.0 0.0+1.0i) 1.0+1.0i)+(num-test (- 1 0.0 0.0+1.0i) 1.0-1.0i)+(num-test (* 1 0.0 0.0+1.0i) 0.0)+(num-test (+ 1 1234 1) 1236)+(num-test (- 1 1234 1) -1234)+(num-test (* 1 1234 1) 1234)+(num-test (/ 1 1234 1) 1/1234)+(num-test (= 1 1234 1) #f)+(num-test (< 1 1234 1) #f)+(num-test (<= 1 1234 1) #f)+(num-test (> 1 1234 1) #f)+(num-test (>= 1 1234 1) #f)+(num-test (+ 1 1234 1.0) 1236.0)+(num-test (- 1 1234 1.0) -1234.0)+(num-test (* 1 1234 1.0) 1234.0)+(num-test (/ 1 1234 1.0) 0.00081037277147)+(num-test (= 1 1234 1.0) #f)+(num-test (< 1 1234 1.0) #f)+(num-test (<= 1 1234 1.0) #f)+(num-test (> 1 1234 1.0) #f)+(num-test (>= 1 1234 1.0) #f)+(num-test (+ 1 1234 1/1) 1236)+(num-test (- 1 1234 1/1) -1234)+(num-test (* 1 1234 1/1) 1234)+(num-test (/ 1 1234 1/1) 1/1234)+(num-test (= 1 1234 1/1) #f)+(num-test (< 1 1234 1/1) #f)+(num-test (<= 1 1234 1/1) #f)+(num-test (> 1 1234 1/1) #f)+(num-test (>= 1 1234 1/1) #f)+(num-test (+ 1 1234 1.0+1.0i) 1236.0+1.0i)+(num-test (- 1 1234 1.0+1.0i) -1234.0-1.0i)+(num-test (* 1 1234 1.0+1.0i) 1234.0+1234.0i)+(num-test (/ 1 1234 1.0+1.0i) 0.00040518638574-0.00040518638574i)+(num-test (= 1 1234 1.0+1.0i) #f)+(num-test (+ 1 1234 0) 1235)+(num-test (- 1 1234 0) -1233)+(num-test (* 1 1234 0) 0)+(num-test (+ 1 1234 0.0) 1235.0)+(num-test (- 1 1234 0.0) -1233.0)+(num-test (* 1 1234 0.0) 0.0)+(num-test (+ 1 1234 1234) 2469)+(num-test (- 1 1234 1234) -2467)+(num-test (* 1 1234 1234) 1522756)+(num-test (/ 1 1234 1234) 1/1522756)+(num-test (= 1 1234 1234) #f)+(num-test (< 1 1234 1234) #f)+(num-test (<= 1 1234 1234) #t)+(num-test (> 1 1234 1234) #f)+(num-test (>= 1 1234 1234) #f)+(num-test (+ 1 1234 123.4) 1358.4)+(num-test (- 1 1234 123.4) -1356.4)+(num-test (* 1 1234 123.4) 152275.60000000000582)+(num-test (/ 1 1234 123.4) 0.00000656704029)+(num-test (= 1 1234 123.4) #f)+(num-test (< 1 1234 123.4) #f)+(num-test (<= 1 1234 123.4) #f)+(num-test (> 1 1234 123.4) #f)+(num-test (>= 1 1234 123.4) #f)+(num-test (+ 1 1234 1234/11) 14819/11)+(num-test (- 1 1234 1234/11) -14797/11)+(num-test (* 1 1234 1234/11) 1522756/11)+(num-test (/ 1 1234 1234/11) 11/1522756)+(num-test (= 1 1234 1234/11) #f)+(num-test (< 1 1234 1234/11) #f)+(num-test (<= 1 1234 1234/11) #f)+(num-test (> 1 1234 1234/11) #f)+(num-test (>= 1 1234 1234/11) #f)+(num-test (+ 1 1234 1.234+1.234i) 1236.23399999999992+1.234i)+(num-test (- 1 1234 1.234+1.234i) -1234.23399999999992-1.234i)+(num-test (* 1 1234 1.234+1.234i) 1522.756+1522.756i)+(num-test (/ 1 1234 1.234+1.234i) 0.00032835201437-0.00032835201437i)+(num-test (= 1 1234 1.234+1.234i) #f)+(num-test (+ 1 1234 -1.0+1.0i) 1234.0+1.0i)+(num-test (- 1 1234 -1.0+1.0i) -1232.0-1.0i)+(num-test (* 1 1234 -1.0+1.0i) -1234.0+1234.0i)+(num-test (/ 1 1234 -1.0+1.0i) -0.00040518638574-0.00040518638574i)+(num-test (= 1 1234 -1.0+1.0i) #f)+(num-test (+ 1 1234 0.0+1.0i) 1235.0+1.0i)+(num-test (- 1 1234 0.0+1.0i) -1233.0-1.0i)+(num-test (* 1 1234 0.0+1.0i) 0.0+1234.0i)+(num-test (/ 1 1234 0.0+1.0i) 0.0-0.00081037277147i)+(num-test (= 1 1234 0.0+1.0i) #f)+(num-test (+ 1 123.4 1) 125.4)+(num-test (- 1 123.4 1) -123.4)+(num-test (* 1 123.4 1) 123.4)+(num-test (/ 1 123.4 1) 0.00810372771475)+(num-test (= 1 123.4 1) #f)+(num-test (< 1 123.4 1) #f)+(num-test (<= 1 123.4 1) #f)+(num-test (> 1 123.4 1) #f)+(num-test (>= 1 123.4 1) #f)+(num-test (+ 1 123.4 1.0) 125.4)+(num-test (- 1 123.4 1.0) -123.4)+(num-test (* 1 123.4 1.0) 123.4)+(num-test (/ 1 123.4 1.0) 0.00810372771475)+(num-test (= 1 123.4 1.0) #f)+(num-test (< 1 123.4 1.0) #f)+(num-test (<= 1 123.4 1.0) #f)+(num-test (> 1 123.4 1.0) #f)+(num-test (>= 1 123.4 1.0) #f)+(num-test (+ 1 123.4 1/1) 125.4)+(num-test (- 1 123.4 1/1) -123.4)+(num-test (* 1 123.4 1/1) 123.4)+(num-test (/ 1 123.4 1/1) 0.00810372771475)+(num-test (= 1 123.4 1/1) #f)+(num-test (< 1 123.4 1/1) #f)+(num-test (<= 1 123.4 1/1) #f)+(num-test (> 1 123.4 1/1) #f)+(num-test (>= 1 123.4 1/1) #f)+(num-test (+ 1 123.4 1.0+1.0i) 125.4+1.0i)+(num-test (- 1 123.4 1.0+1.0i) -123.4-1.0i)+(num-test (* 1 123.4 1.0+1.0i) 123.4+123.4i)+(num-test (/ 1 123.4 1.0+1.0i) 0.00405186385737-0.00405186385737i)+(num-test (= 1 123.4 1.0+1.0i) #f)+(num-test (+ 1 123.4 0) 124.4)+(num-test (- 1 123.4 0) -122.4)+(num-test (* 1 123.4 0) 0.0)+(num-test (+ 1 123.4 0.0) 124.4)+(num-test (- 1 123.4 0.0) -122.4)+(num-test (* 1 123.4 0.0) 0.0)+(num-test (+ 1 123.4 1234) 1358.4)+(num-test (- 1 123.4 1234) -1356.4)+(num-test (* 1 123.4 1234) 152275.60000000000582)+(num-test (/ 1 123.4 1234) 0.00000656704029)+(num-test (= 1 123.4 1234) #f)+(num-test (< 1 123.4 1234) #t)+(num-test (<= 1 123.4 1234) #t)+(num-test (> 1 123.4 1234) #f)+(num-test (>= 1 123.4 1234) #f)+(num-test (+ 1 123.4 123.4) 247.8)+(num-test (- 1 123.4 123.4) -245.8)+(num-test (* 1 123.4 123.4) 15227.56000000000131)+(num-test (/ 1 123.4 123.4) 0.00006567040287)+(num-test (= 1 123.4 123.4) #f)+(num-test (< 1 123.4 123.4) #f)+(num-test (<= 1 123.4 123.4) #t)+(num-test (> 1 123.4 123.4) #f)+(num-test (>= 1 123.4 123.4) #f)+(num-test (+ 1 123.4 1234/11) 236.58181818181819)+(num-test (- 1 123.4 1234/11) -234.58181818181819)+(num-test (* 1 123.4 1234/11) 13843.23636363636433)+(num-test (/ 1 123.4 1234/11) 0.00007223744316)+(num-test (= 1 123.4 1234/11) #f)+(num-test (< 1 123.4 1234/11) #f)+(num-test (<= 1 123.4 1234/11) #f)+(num-test (> 1 123.4 1234/11) #f)+(num-test (>= 1 123.4 1234/11) #f)+(num-test (+ 1 123.4 1.234+1.234i) 125.634+1.234i)+(num-test (- 1 123.4 1.234+1.234i) -123.634-1.234i)+(num-test (* 1 123.4 1.234+1.234i) 152.2756+152.2756i)+(num-test (/ 1 123.4 1.234+1.234i) 0.00328352014374-0.00328352014374i)+(num-test (= 1 123.4 1.234+1.234i) #f)+(num-test (+ 1 123.4 -1.0+1.0i) 123.4+1.0i)+(num-test (- 1 123.4 -1.0+1.0i) -121.4-1.0i)+(num-test (* 1 123.4 -1.0+1.0i) -123.4+123.4i)+(num-test (/ 1 123.4 -1.0+1.0i) -0.00405186385737-0.00405186385737i)+(num-test (= 1 123.4 -1.0+1.0i) #f)+(num-test (+ 1 123.4 0.0+1.0i) 124.4+1.0i)+(num-test (- 1 123.4 0.0+1.0i) -122.4-1.0i)+(num-test (* 1 123.4 0.0+1.0i) 0.0+123.4i)+(num-test (/ 1 123.4 0.0+1.0i) 0.0-0.00810372771475i)+(num-test (= 1 123.4 0.0+1.0i) #f)+(num-test (+ 1 1234/11 1) 1256/11)+(num-test (- 1 1234/11 1) -1234/11)+(num-test (* 1 1234/11 1) 1234/11)+(num-test (/ 1 1234/11 1) 11/1234)+(num-test (= 1 1234/11 1) #f)+(num-test (< 1 1234/11 1) #f)+(num-test (<= 1 1234/11 1) #f)+(num-test (> 1 1234/11 1) #f)+(num-test (>= 1 1234/11 1) #f)+(num-test (+ 1 1234/11 1.0) 114.18181818181819)+(num-test (- 1 1234/11 1.0) -112.18181818181819)+(num-test (* 1 1234/11 1.0) 112.18181818181819)+(num-test (/ 1 1234/11 1.0) 0.00891410048622)+(num-test (= 1 1234/11 1.0) #f)+(num-test (< 1 1234/11 1.0) #f)+(num-test (<= 1 1234/11 1.0) #f)+(num-test (> 1 1234/11 1.0) #f)+(num-test (>= 1 1234/11 1.0) #f)+(num-test (+ 1 1234/11 1/1) 1256/11)+(num-test (- 1 1234/11 1/1) -1234/11)+(num-test (* 1 1234/11 1/1) 1234/11)+(num-test (/ 1 1234/11 1/1) 11/1234)+(num-test (= 1 1234/11 1/1) #f)+(num-test (< 1 1234/11 1/1) #f)+(num-test (<= 1 1234/11 1/1) #f)+(num-test (> 1 1234/11 1/1) #f)+(num-test (>= 1 1234/11 1/1) #f)+(num-test (+ 1 1234/11 1.0+1.0i) 114.18181818181819+1.0i)+(num-test (- 1 1234/11 1.0+1.0i) -112.18181818181819-1.0i)+(num-test (* 1 1234/11 1.0+1.0i) 112.18181818181819+112.18181818181819i)+(num-test (/ 1 1234/11 1.0+1.0i) 0.00445705024311-0.00445705024311i)+(num-test (= 1 1234/11 1.0+1.0i) #f)+(num-test (+ 1 1234/11 0) 1245/11)+(num-test (- 1 1234/11 0) -1223/11)+(num-test (* 1 1234/11 0) 0)+(num-test (+ 1 1234/11 0.0) 113.18181818181819)+(num-test (- 1 1234/11 0.0) -111.18181818181819)+(num-test (* 1 1234/11 0.0) 0.0)+(num-test (+ 1 1234/11 1234) 14819/11)+(num-test (- 1 1234/11 1234) -14797/11)+(num-test (* 1 1234/11 1234) 1522756/11)+(num-test (/ 1 1234/11 1234) 11/1522756)+(num-test (= 1 1234/11 1234) #f)+(num-test (< 1 1234/11 1234) #t)+(num-test (<= 1 1234/11 1234) #t)+(num-test (> 1 1234/11 1234) #f)+(num-test (>= 1 1234/11 1234) #f)+(num-test (+ 1 1234/11 123.4) 236.58181818181819)+(num-test (- 1 1234/11 123.4) -234.58181818181819)+(num-test (* 1 1234/11 123.4) 13843.23636363636433)+(num-test (/ 1 1234/11 123.4) 0.00007223744316)+(num-test (= 1 1234/11 123.4) #f)+(num-test (< 1 1234/11 123.4) #t)+(num-test (<= 1 1234/11 123.4) #t)+(num-test (> 1 1234/11 123.4) #f)+(num-test (>= 1 1234/11 123.4) #f)+(num-test (+ 1 1234/11 1234/11) 2479/11)+(num-test (- 1 1234/11 1234/11) -2457/11)+(num-test (* 1 1234/11 1234/11) 1522756/121)+(num-test (/ 1 1234/11 1234/11) 121/1522756)+(num-test (= 1 1234/11 1234/11) #f)+(num-test (< 1 1234/11 1234/11) #f)+(num-test (<= 1 1234/11 1234/11) #t)+(num-test (> 1 1234/11 1234/11) #f)+(num-test (>= 1 1234/11 1234/11) #f)+(num-test (+ 1 1234/11 1.234+1.234i) 114.41581818181818+1.234i)+(num-test (- 1 1234/11 1.234+1.234i) -112.41581818181818-1.234i)+(num-test (* 1 1234/11 1.234+1.234i) 138.43236363636365+138.43236363636365i)+(num-test (/ 1 1234/11 1.234+1.234i) 0.00361187215811-0.00361187215811i)+(num-test (= 1 1234/11 1.234+1.234i) #f)+(num-test (+ 1 1234/11 -1.0+1.0i) 112.18181818181819+1.0i)+(num-test (- 1 1234/11 -1.0+1.0i) -110.18181818181819-1.0i)+(num-test (* 1 1234/11 -1.0+1.0i) -112.18181818181819+112.18181818181819i)+(num-test (/ 1 1234/11 -1.0+1.0i) -0.00445705024311-0.00445705024311i)+(num-test (= 1 1234/11 -1.0+1.0i) #f)+(num-test (+ 1 1234/11 0.0+1.0i) 113.18181818181819+1.0i)+(num-test (- 1 1234/11 0.0+1.0i) -111.18181818181819-1.0i)+(num-test (* 1 1234/11 0.0+1.0i) 0.0+112.18181818181819i)+(num-test (/ 1 1234/11 0.0+1.0i) 0.0-0.00891410048622i)+(num-test (= 1 1234/11 0.0+1.0i) #f)+(num-test (+ 1 1.234+1.234i 1) 3.234+1.234i)+(num-test (- 1 1.234+1.234i 1) -1.234-1.234i)+(num-test (* 1 1.234+1.234i 1) 1.234+1.234i)+(num-test (/ 1 1.234+1.234i 1) 0.40518638573744-0.40518638573744i)+(num-test (= 1 1.234+1.234i 1) #f)+(num-test (+ 1 1.234+1.234i 1.0) 3.234+1.234i)+(num-test (- 1 1.234+1.234i 1.0) -1.234-1.234i)+(num-test (* 1 1.234+1.234i 1.0) 1.234+1.234i)+(num-test (/ 1 1.234+1.234i 1.0) 0.40518638573744-0.40518638573744i)+(num-test (= 1 1.234+1.234i 1.0) #f)+(num-test (+ 1 1.234+1.234i 1/1) 3.234+1.234i)+(num-test (- 1 1.234+1.234i 1/1) -1.234-1.234i)+(num-test (* 1 1.234+1.234i 1/1) 1.234+1.234i)+(num-test (/ 1 1.234+1.234i 1/1) 0.40518638573744-0.40518638573744i)+(num-test (= 1 1.234+1.234i 1/1) #f)+(num-test (+ 1 1.234+1.234i 1.0+1.0i) 3.234+2.234i)+(num-test (- 1 1.234+1.234i 1.0+1.0i) -1.234-2.234i)+(num-test (* 1 1.234+1.234i 1.0+1.0i) 0.0+2.468i)+(num-test (/ 1 1.234+1.234i 1.0+1.0i) 0.0-0.40518638573744i)+(num-test (= 1 1.234+1.234i 1.0+1.0i) #f)+(num-test (+ 1 1.234+1.234i 0) 2.234+1.234i)+(num-test (- 1 1.234+1.234i 0) -0.234-1.234i)+(num-test (* 1 1.234+1.234i 0) 0.0)+(num-test (+ 1 1.234+1.234i 0.0) 2.234+1.234i)+(num-test (- 1 1.234+1.234i 0.0) -0.234-1.234i)+(num-test (* 1 1.234+1.234i 0.0) 0.0)+(num-test (+ 1 1.234+1.234i 1234) 1236.23399999999992+1.234i)+(num-test (- 1 1.234+1.234i 1234) -1234.23399999999992-1.234i)+(num-test (* 1 1.234+1.234i 1234) 1522.756+1522.756i)+(num-test (/ 1 1.234+1.234i 1234) 0.00032835201437-0.00032835201437i)+(num-test (= 1 1.234+1.234i 1234) #f)+(num-test (+ 1 1.234+1.234i 123.4) 125.634+1.234i)+(num-test (- 1 1.234+1.234i 123.4) -123.634-1.234i)+(num-test (* 1 1.234+1.234i 123.4) 152.2756+152.2756i)+(num-test (/ 1 1.234+1.234i 123.4) 0.00328352014374-0.00328352014374i)+(num-test (= 1 1.234+1.234i 123.4) #f)+(num-test (+ 1 1.234+1.234i 1234/11) 114.41581818181818+1.234i)+(num-test (- 1 1.234+1.234i 1234/11) -112.41581818181818-1.234i)+(num-test (* 1 1.234+1.234i 1234/11) 138.43236363636365+138.43236363636365i)+(num-test (/ 1 1.234+1.234i 1234/11) 0.00361187215811-0.00361187215811i)+(num-test (= 1 1.234+1.234i 1234/11) #f)+(num-test (+ 1 1.234+1.234i 1.234+1.234i) 3.468+2.468i)+(num-test (- 1 1.234+1.234i 1.234+1.234i) -1.468-2.468i)+(num-test (* 1 1.234+1.234i 1.234+1.234i) 0.0+3.04551200000000i)+(num-test (/ 1 1.234+1.234i 1.234+1.234i) 0.0-0.32835201437394i)+(num-test (= 1 1.234+1.234i 1.234+1.234i) #f)+(num-test (+ 1 1.234+1.234i -1.0+1.0i) 1.234+2.234i)+(num-test (- 1 1.234+1.234i -1.0+1.0i) 0.766-2.234i)+(num-test (* 1 1.234+1.234i -1.0+1.0i) -2.468)+(num-test (/ 1 1.234+1.234i -1.0+1.0i) -0.40518638573744)+(num-test (= 1 1.234+1.234i -1.0+1.0i) #f)+(num-test (+ 1 1.234+1.234i 0.0+1.0i) 2.234+2.234i)+(num-test (- 1 1.234+1.234i 0.0+1.0i) -0.234-2.234i)+(num-test (* 1 1.234+1.234i 0.0+1.0i) -1.234+1.234i)+(num-test (/ 1 1.234+1.234i 0.0+1.0i) -0.40518638573744-0.40518638573744i)+(num-test (= 1 1.234+1.234i 0.0+1.0i) #f)+(num-test (+ 1 -1.0+1.0i 1) 1.0+1.0i)+(num-test (- 1 -1.0+1.0i 1) 1.0-1.0i)+(num-test (* 1 -1.0+1.0i 1) -1.0+1.0i)+(num-test (/ 1 -1.0+1.0i 1) -0.5-0.5i)+(num-test (= 1 -1.0+1.0i 1) #f)+(num-test (+ 1 -1.0+1.0i 1.0) 1.0+1.0i)+(num-test (- 1 -1.0+1.0i 1.0) 1.0-1.0i)+(num-test (* 1 -1.0+1.0i 1.0) -1.0+1.0i)+(num-test (/ 1 -1.0+1.0i 1.0) -0.5-0.5i)+(num-test (= 1 -1.0+1.0i 1.0) #f)+(num-test (+ 1 -1.0+1.0i 1/1) 1.0+1.0i)+(num-test (- 1 -1.0+1.0i 1/1) 1.0-1.0i)+(num-test (* 1 -1.0+1.0i 1/1) -1.0+1.0i)+(num-test (/ 1 -1.0+1.0i 1/1) -0.5-0.5i)+(num-test (= 1 -1.0+1.0i 1/1) #f)+(num-test (+ 1 -1.0+1.0i 1.0+1.0i) 1.0+2.0i)+(num-test (- 1 -1.0+1.0i 1.0+1.0i) 1.0-2.0i)+(num-test (* 1 -1.0+1.0i 1.0+1.0i) -2.0)+(num-test (/ 1 -1.0+1.0i 1.0+1.0i) -0.5)+(num-test (= 1 -1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1 -1.0+1.0i 0) 0.0+1.0i)+(num-test (- 1 -1.0+1.0i 0) 2.0-1.0i)+(num-test (* 1 -1.0+1.0i 0) -0.0)+(num-test (+ 1 -1.0+1.0i 0.0) 0.0+1.0i)+(num-test (- 1 -1.0+1.0i 0.0) 2.0-1.0i)+(num-test (* 1 -1.0+1.0i 0.0) -0.0)+(num-test (+ 1 -1.0+1.0i 1234) 1234.0+1.0i)+(num-test (- 1 -1.0+1.0i 1234) -1232.0-1.0i)+(num-test (* 1 -1.0+1.0i 1234) -1234.0+1234.0i)+(num-test (/ 1 -1.0+1.0i 1234) -0.00040518638574-0.00040518638574i)+(num-test (= 1 -1.0+1.0i 1234) #f)+(num-test (+ 1 -1.0+1.0i 123.4) 123.4+1.0i)+(num-test (- 1 -1.0+1.0i 123.4) -121.4-1.0i)+(num-test (* 1 -1.0+1.0i 123.4) -123.4+123.4i)+(num-test (/ 1 -1.0+1.0i 123.4) -0.00405186385737-0.00405186385737i)+(num-test (= 1 -1.0+1.0i 123.4) #f)+(num-test (+ 1 -1.0+1.0i 1234/11) 112.18181818181819+1.0i)+(num-test (- 1 -1.0+1.0i 1234/11) -110.18181818181819-1.0i)+(num-test (* 1 -1.0+1.0i 1234/11) -112.18181818181819+112.18181818181819i)+(num-test (/ 1 -1.0+1.0i 1234/11) -0.00445705024311-0.00445705024311i)+(num-test (= 1 -1.0+1.0i 1234/11) #f)+(num-test (+ 1 -1.0+1.0i 1.234+1.234i) 1.234+2.234i)+(num-test (- 1 -1.0+1.0i 1.234+1.234i) 0.766-2.234i)+(num-test (* 1 -1.0+1.0i 1.234+1.234i) -2.468)+(num-test (/ 1 -1.0+1.0i 1.234+1.234i) -0.40518638573744)+(num-test (= 1 -1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1 -1.0+1.0i -1.0+1.0i) -1.0+2.0i)+(num-test (- 1 -1.0+1.0i -1.0+1.0i) 3.0-2.0i)+(num-test (* 1 -1.0+1.0i -1.0+1.0i) 0.0-2.0i)+(num-test (/ 1 -1.0+1.0i -1.0+1.0i) -0.0+0.5i)+(num-test (= 1 -1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1 -1.0+1.0i 0.0+1.0i) 0.0+2.0i)+(num-test (- 1 -1.0+1.0i 0.0+1.0i) 2.0-2.0i)+(num-test (* 1 -1.0+1.0i 0.0+1.0i) -1.0-1.0i)+(num-test (/ 1 -1.0+1.0i 0.0+1.0i) -0.5+0.5i)+(num-test (= 1 -1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1 0.0+1.0i 1) 2.0+1.0i)+(num-test (- 1 0.0+1.0i 1) 0.0-1.0i)+(num-test (* 1 0.0+1.0i 1) 0.0+1.0i)+(num-test (/ 1 0.0+1.0i 1) 0.0-1.0i)+(num-test (= 1 0.0+1.0i 1) #f)+(num-test (+ 1 0.0+1.0i 1.0) 2.0+1.0i)+(num-test (- 1 0.0+1.0i 1.0) 0.0-1.0i)+(num-test (* 1 0.0+1.0i 1.0) 0.0+1.0i)+(num-test (/ 1 0.0+1.0i 1.0) 0.0-1.0i)+(num-test (= 1 0.0+1.0i 1.0) #f)+(num-test (+ 1 0.0+1.0i 1/1) 2.0+1.0i)+(num-test (- 1 0.0+1.0i 1/1) 0.0-1.0i)+(num-test (* 1 0.0+1.0i 1/1) 0.0+1.0i)+(num-test (/ 1 0.0+1.0i 1/1) 0.0-1.0i)+(num-test (= 1 0.0+1.0i 1/1) #f)+(num-test (+ 1 0.0+1.0i 1.0+1.0i) 2.0+2.0i)+(num-test (- 1 0.0+1.0i 1.0+1.0i) 0.0-2.0i)+(num-test (* 1 0.0+1.0i 1.0+1.0i) -1.0+1.0i)+(num-test (/ 1 0.0+1.0i 1.0+1.0i) -0.5-0.5i)+(num-test (= 1 0.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1 0.0+1.0i 0) 1.0+1.0i)+(num-test (- 1 0.0+1.0i 0) 1.0-1.0i)+(num-test (* 1 0.0+1.0i 0) 0.0)+(num-test (+ 1 0.0+1.0i 0.0) 1.0+1.0i)+(num-test (- 1 0.0+1.0i 0.0) 1.0-1.0i)+(num-test (* 1 0.0+1.0i 0.0) 0.0)+(num-test (+ 1 0.0+1.0i 1234) 1235.0+1.0i)+(num-test (- 1 0.0+1.0i 1234) -1233.0-1.0i)+(num-test (* 1 0.0+1.0i 1234) 0.0+1234.0i)+(num-test (/ 1 0.0+1.0i 1234) 0.0-0.00081037277147i)+(num-test (= 1 0.0+1.0i 1234) #f)+(num-test (+ 1 0.0+1.0i 123.4) 124.4+1.0i)+(num-test (- 1 0.0+1.0i 123.4) -122.4-1.0i)+(num-test (* 1 0.0+1.0i 123.4) 0.0+123.4i)+(num-test (/ 1 0.0+1.0i 123.4) 0.0-0.00810372771475i)+(num-test (= 1 0.0+1.0i 123.4) #f)+(num-test (+ 1 0.0+1.0i 1234/11) 113.18181818181819+1.0i)+(num-test (- 1 0.0+1.0i 1234/11) -111.18181818181819-1.0i)+(num-test (* 1 0.0+1.0i 1234/11) 0.0+112.18181818181819i)+(num-test (/ 1 0.0+1.0i 1234/11) 0.0-0.00891410048622i)+(num-test (= 1 0.0+1.0i 1234/11) #f)+(num-test (+ 1 0.0+1.0i 1.234+1.234i) 2.234+2.234i)+(num-test (- 1 0.0+1.0i 1.234+1.234i) -0.234-2.234i)+(num-test (* 1 0.0+1.0i 1.234+1.234i) -1.234+1.234i)+(num-test (/ 1 0.0+1.0i 1.234+1.234i) -0.40518638573744-0.40518638573744i)+(num-test (= 1 0.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1 0.0+1.0i -1.0+1.0i) 0.0+2.0i)+(num-test (- 1 0.0+1.0i -1.0+1.0i) 2.0-2.0i)+(num-test (* 1 0.0+1.0i -1.0+1.0i) -1.0-1.0i)+(num-test (/ 1 0.0+1.0i -1.0+1.0i) -0.5+0.5i)+(num-test (= 1 0.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1 0.0+1.0i 0.0+1.0i) 1.0+2.0i)+(num-test (- 1 0.0+1.0i 0.0+1.0i) 1.0-2.0i)+(num-test (* 1 0.0+1.0i 0.0+1.0i) -1.0)+(num-test (/ 1 0.0+1.0i 0.0+1.0i) -1.0)+(num-test (= 1 0.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1.0 1 1) 3.0)+(num-test (- 1.0 1 1) -1.0)+(num-test (* 1.0 1 1) 1.0)+(num-test (/ 1.0 1 1) 1.0)+(num-test (= 1.0 1 1) #t)+(num-test (< 1.0 1 1) #f)+(num-test (<= 1.0 1 1) #t)+(num-test (> 1.0 1 1) #f)+(num-test (>= 1.0 1 1) #t)+(num-test (+ 1.0 1 1.0) 3.0)+(num-test (- 1.0 1 1.0) -1.0)+(num-test (* 1.0 1 1.0) 1.0)+(num-test (/ 1.0 1 1.0) 1.0)+(num-test (= 1.0 1 1.0) #t)+(num-test (< 1.0 1 1.0) #f)+(num-test (<= 1.0 1 1.0) #t)+(num-test (> 1.0 1 1.0) #f)+(num-test (>= 1.0 1 1.0) #t)+(num-test (+ 1.0 1 1/1) 3.0)+(num-test (- 1.0 1 1/1) -1.0)+(num-test (* 1.0 1 1/1) 1.0)+(num-test (/ 1.0 1 1/1) 1.0)+(num-test (= 1.0 1 1/1) #t)+(num-test (< 1.0 1 1/1) #f)+(num-test (<= 1.0 1 1/1) #t)+(num-test (> 1.0 1 1/1) #f)+(num-test (>= 1.0 1 1/1) #t)+(num-test (+ 1.0 1 1.0+1.0i) 3.0+1.0i)+(num-test (- 1.0 1 1.0+1.0i) -1.0-1.0i)+(num-test (* 1.0 1 1.0+1.0i) 1.0+1.0i)+(num-test (/ 1.0 1 1.0+1.0i) 0.5-0.5i)+(num-test (= 1.0 1 1.0+1.0i) #f)+(num-test (+ 1.0 1 0) 2.0)+(num-test (- 1.0 1 0) 0.0)+(num-test (* 1.0 1 0) 0.0)+(num-test (+ 1.0 1 0.0) 2.0)+(num-test (- 1.0 1 0.0) 0.0)+(num-test (* 1.0 1 0.0) 0.0)+(num-test (+ 1.0 1 1234) 1236.0)+(num-test (- 1.0 1 1234) -1234.0)+(num-test (* 1.0 1 1234) 1234.0)+(num-test (/ 1.0 1 1234) 0.00081037277147)+(num-test (= 1.0 1 1234) #f)+(num-test (< 1.0 1 1234) #f)+(num-test (<= 1.0 1 1234) #t)+(num-test (> 1.0 1 1234) #f)+(num-test (>= 1.0 1 1234) #f)+(num-test (+ 1.0 1 123.4) 125.4)+(num-test (- 1.0 1 123.4) -123.4)+(num-test (* 1.0 1 123.4) 123.4)+(num-test (/ 1.0 1 123.4) 0.00810372771475)+(num-test (= 1.0 1 123.4) #f)+(num-test (< 1.0 1 123.4) #f)+(num-test (<= 1.0 1 123.4) #t)+(num-test (> 1.0 1 123.4) #f)+(num-test (>= 1.0 1 123.4) #f)+(num-test (+ 1.0 1 1234/11) 114.18181818181819)+(num-test (- 1.0 1 1234/11) -112.18181818181819)+(num-test (* 1.0 1 1234/11) 112.18181818181819)+(num-test (/ 1.0 1 1234/11) 0.00891410048622)+(num-test (= 1.0 1 1234/11) #f)+(num-test (< 1.0 1 1234/11) #f)+(num-test (<= 1.0 1 1234/11) #t)+(num-test (> 1.0 1 1234/11) #f)+(num-test (>= 1.0 1 1234/11) #f)+(num-test (+ 1.0 1 1.234+1.234i) 3.234+1.234i)+(num-test (- 1.0 1 1.234+1.234i) -1.234-1.234i)+(num-test (* 1.0 1 1.234+1.234i) 1.234+1.234i)+(num-test (/ 1.0 1 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1.0 1 1.234+1.234i) #f)+(num-test (+ 1.0 1 -1.0+1.0i) 1.0+1.0i)+(num-test (- 1.0 1 -1.0+1.0i) 1.0-1.0i)+(num-test (* 1.0 1 -1.0+1.0i) -1.0+1.0i)+(num-test (/ 1.0 1 -1.0+1.0i) -0.5-0.5i)+(num-test (= 1.0 1 -1.0+1.0i) #f)+(num-test (+ 1.0 1 0.0+1.0i) 2.0+1.0i)+(num-test (- 1.0 1 0.0+1.0i) 0.0-1.0i)+(num-test (* 1.0 1 0.0+1.0i) 0.0+1.0i)+(num-test (/ 1.0 1 0.0+1.0i) 0.0-1.0i)+(num-test (= 1.0 1 0.0+1.0i) #f)+(num-test (+ 1.0 1.0 1) 3.0)+(num-test (- 1.0 1.0 1) -1.0)+(num-test (* 1.0 1.0 1) 1.0)+(num-test (/ 1.0 1.0 1) 1.0)+(num-test (= 1.0 1.0 1) #t)+(num-test (< 1.0 1.0 1) #f)+(num-test (<= 1.0 1.0 1) #t)+(num-test (> 1.0 1.0 1) #f)+(num-test (>= 1.0 1.0 1) #t)+(num-test (+ 1.0 1.0 1.0) 3.0)+(num-test (- 1.0 1.0 1.0) -1.0)+(num-test (* 1.0 1.0 1.0) 1.0)+(num-test (/ 1.0 1.0 1.0) 1.0)+(num-test (= 1.0 1.0 1.0) #t)+(num-test (< 1.0 1.0 1.0) #f)+(num-test (<= 1.0 1.0 1.0) #t)+(num-test (> 1.0 1.0 1.0) #f)+(num-test (>= 1.0 1.0 1.0) #t)+(num-test (+ 1.0 1.0 1/1) 3.0)+(num-test (- 1.0 1.0 1/1) -1.0)+(num-test (* 1.0 1.0 1/1) 1.0)+(num-test (/ 1.0 1.0 1/1) 1.0)+(num-test (= 1.0 1.0 1/1) #t)+(num-test (< 1.0 1.0 1/1) #f)+(num-test (<= 1.0 1.0 1/1) #t)+(num-test (> 1.0 1.0 1/1) #f)+(num-test (>= 1.0 1.0 1/1) #t)+(num-test (+ 1.0 1.0 1.0+1.0i) 3.0+1.0i)+(num-test (- 1.0 1.0 1.0+1.0i) -1.0-1.0i)+(num-test (* 1.0 1.0 1.0+1.0i) 1.0+1.0i)+(num-test (/ 1.0 1.0 1.0+1.0i) 0.5-0.5i)+(num-test (= 1.0 1.0 1.0+1.0i) #f)+(num-test (+ 1.0 1.0 0) 2.0)+(num-test (- 1.0 1.0 0) 0.0)+(num-test (* 1.0 1.0 0) 0.0)+(num-test (+ 1.0 1.0 0.0) 2.0)+(num-test (- 1.0 1.0 0.0) 0.0)+(num-test (* 1.0 1.0 0.0) 0.0)+(num-test (+ 1.0 1.0 1234) 1236.0)+(num-test (- 1.0 1.0 1234) -1234.0)+(num-test (* 1.0 1.0 1234) 1234.0)+(num-test (/ 1.0 1.0 1234) 0.00081037277147)+(num-test (= 1.0 1.0 1234) #f)+(num-test (< 1.0 1.0 1234) #f)+(num-test (<= 1.0 1.0 1234) #t)+(num-test (> 1.0 1.0 1234) #f)+(num-test (>= 1.0 1.0 1234) #f)+(num-test (+ 1.0 1.0 123.4) 125.4)+(num-test (- 1.0 1.0 123.4) -123.4)+(num-test (* 1.0 1.0 123.4) 123.4)+(num-test (/ 1.0 1.0 123.4) 0.00810372771475)+(num-test (= 1.0 1.0 123.4) #f)+(num-test (< 1.0 1.0 123.4) #f)+(num-test (<= 1.0 1.0 123.4) #t)+(num-test (> 1.0 1.0 123.4) #f)+(num-test (>= 1.0 1.0 123.4) #f)+(num-test (+ 1.0 1.0 1234/11) 114.18181818181819)+(num-test (- 1.0 1.0 1234/11) -112.18181818181819)+(num-test (* 1.0 1.0 1234/11) 112.18181818181819)+(num-test (/ 1.0 1.0 1234/11) 0.00891410048622)+(num-test (= 1.0 1.0 1234/11) #f)+(num-test (< 1.0 1.0 1234/11) #f)+(num-test (<= 1.0 1.0 1234/11) #t)+(num-test (> 1.0 1.0 1234/11) #f)+(num-test (>= 1.0 1.0 1234/11) #f)+(num-test (+ 1.0 1.0 1.234+1.234i) 3.234+1.234i)+(num-test (- 1.0 1.0 1.234+1.234i) -1.234-1.234i)+(num-test (* 1.0 1.0 1.234+1.234i) 1.234+1.234i)+(num-test (/ 1.0 1.0 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1.0 1.0 1.234+1.234i) #f)+(num-test (+ 1.0 1.0 -1.0+1.0i) 1.0+1.0i)+(num-test (- 1.0 1.0 -1.0+1.0i) 1.0-1.0i)+(num-test (* 1.0 1.0 -1.0+1.0i) -1.0+1.0i)+(num-test (/ 1.0 1.0 -1.0+1.0i) -0.5-0.5i)+(num-test (= 1.0 1.0 -1.0+1.0i) #f)+(num-test (+ 1.0 1.0 0.0+1.0i) 2.0+1.0i)+(num-test (- 1.0 1.0 0.0+1.0i) 0.0-1.0i)+(num-test (* 1.0 1.0 0.0+1.0i) 0.0+1.0i)+(num-test (/ 1.0 1.0 0.0+1.0i) 0.0-1.0i)+(num-test (= 1.0 1.0 0.0+1.0i) #f)+(num-test (+ 1.0 1/1 1) 3.0)+(num-test (- 1.0 1/1 1) -1.0)+(num-test (* 1.0 1/1 1) 1.0)+(num-test (/ 1.0 1/1 1) 1.0)+(num-test (= 1.0 1/1 1) #t)+(num-test (< 1.0 1/1 1) #f)+(num-test (<= 1.0 1/1 1) #t)+(num-test (> 1.0 1/1 1) #f)+(num-test (>= 1.0 1/1 1) #t)+(num-test (+ 1.0 1/1 1.0) 3.0)+(num-test (- 1.0 1/1 1.0) -1.0)+(num-test (* 1.0 1/1 1.0) 1.0)+(num-test (/ 1.0 1/1 1.0) 1.0)+(num-test (= 1.0 1/1 1.0) #t)+(num-test (< 1.0 1/1 1.0) #f)+(num-test (<= 1.0 1/1 1.0) #t)+(num-test (> 1.0 1/1 1.0) #f)+(num-test (>= 1.0 1/1 1.0) #t)+(num-test (+ 1.0 1/1 1/1) 3.0)+(num-test (- 1.0 1/1 1/1) -1.0)+(num-test (* 1.0 1/1 1/1) 1.0)+(num-test (/ 1.0 1/1 1/1) 1.0)+(num-test (= 1.0 1/1 1/1) #t)+(num-test (< 1.0 1/1 1/1) #f)+(num-test (<= 1.0 1/1 1/1) #t)+(num-test (> 1.0 1/1 1/1) #f)+(num-test (>= 1.0 1/1 1/1) #t)+(num-test (+ 1.0 1/1 1.0+1.0i) 3.0+1.0i)+(num-test (- 1.0 1/1 1.0+1.0i) -1.0-1.0i)+(num-test (* 1.0 1/1 1.0+1.0i) 1.0+1.0i)+(num-test (/ 1.0 1/1 1.0+1.0i) 0.5-0.5i)+(num-test (= 1.0 1/1 1.0+1.0i) #f)+(num-test (+ 1.0 1/1 0) 2.0)+(num-test (- 1.0 1/1 0) 0.0)+(num-test (* 1.0 1/1 0) 0.0)+(num-test (+ 1.0 1/1 0.0) 2.0)+(num-test (- 1.0 1/1 0.0) 0.0)+(num-test (* 1.0 1/1 0.0) 0.0)+(num-test (+ 1.0 1/1 1234) 1236.0)+(num-test (- 1.0 1/1 1234) -1234.0)+(num-test (* 1.0 1/1 1234) 1234.0)+(num-test (/ 1.0 1/1 1234) 0.00081037277147)+(num-test (= 1.0 1/1 1234) #f)+(num-test (< 1.0 1/1 1234) #f)+(num-test (<= 1.0 1/1 1234) #t)+(num-test (> 1.0 1/1 1234) #f)+(num-test (>= 1.0 1/1 1234) #f)+(num-test (+ 1.0 1/1 123.4) 125.4)+(num-test (- 1.0 1/1 123.4) -123.4)+(num-test (* 1.0 1/1 123.4) 123.4)+(num-test (/ 1.0 1/1 123.4) 0.00810372771475)+(num-test (= 1.0 1/1 123.4) #f)+(num-test (< 1.0 1/1 123.4) #f)+(num-test (<= 1.0 1/1 123.4) #t)+(num-test (> 1.0 1/1 123.4) #f)+(num-test (>= 1.0 1/1 123.4) #f)+(num-test (+ 1.0 1/1 1234/11) 114.18181818181819)+(num-test (- 1.0 1/1 1234/11) -112.18181818181819)+(num-test (* 1.0 1/1 1234/11) 112.18181818181819)+(num-test (/ 1.0 1/1 1234/11) 0.00891410048622)+(num-test (= 1.0 1/1 1234/11) #f)+(num-test (< 1.0 1/1 1234/11) #f)+(num-test (<= 1.0 1/1 1234/11) #t)+(num-test (> 1.0 1/1 1234/11) #f)+(num-test (>= 1.0 1/1 1234/11) #f)+(num-test (+ 1.0 1/1 1.234+1.234i) 3.234+1.234i)+(num-test (- 1.0 1/1 1.234+1.234i) -1.234-1.234i)+(num-test (* 1.0 1/1 1.234+1.234i) 1.234+1.234i)+(num-test (/ 1.0 1/1 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1.0 1/1 1.234+1.234i) #f)+(num-test (+ 1.0 1/1 -1.0+1.0i) 1.0+1.0i)+(num-test (- 1.0 1/1 -1.0+1.0i) 1.0-1.0i)+(num-test (* 1.0 1/1 -1.0+1.0i) -1.0+1.0i)+(num-test (/ 1.0 1/1 -1.0+1.0i) -0.5-0.5i)+(num-test (= 1.0 1/1 -1.0+1.0i) #f)+(num-test (+ 1.0 1/1 0.0+1.0i) 2.0+1.0i)+(num-test (- 1.0 1/1 0.0+1.0i) 0.0-1.0i)+(num-test (* 1.0 1/1 0.0+1.0i) 0.0+1.0i)+(num-test (/ 1.0 1/1 0.0+1.0i) 0.0-1.0i)+(num-test (= 1.0 1/1 0.0+1.0i) #f)+(num-test (+ 1.0 1.0+1.0i 1) 3.0+1.0i)+(num-test (- 1.0 1.0+1.0i 1) -1.0-1.0i)+(num-test (* 1.0 1.0+1.0i 1) 1.0+1.0i)+(num-test (/ 1.0 1.0+1.0i 1) 0.5-0.5i)+(num-test (= 1.0 1.0+1.0i 1) #f)+(num-test (+ 1.0 1.0+1.0i 1.0) 3.0+1.0i)+(num-test (- 1.0 1.0+1.0i 1.0) -1.0-1.0i)+(num-test (* 1.0 1.0+1.0i 1.0) 1.0+1.0i)+(num-test (/ 1.0 1.0+1.0i 1.0) 0.5-0.5i)+(num-test (= 1.0 1.0+1.0i 1.0) #f)+(num-test (+ 1.0 1.0+1.0i 1/1) 3.0+1.0i)+(num-test (- 1.0 1.0+1.0i 1/1) -1.0-1.0i)+(num-test (* 1.0 1.0+1.0i 1/1) 1.0+1.0i)+(num-test (/ 1.0 1.0+1.0i 1/1) 0.5-0.5i)+(num-test (= 1.0 1.0+1.0i 1/1) #f)+(num-test (+ 1.0 1.0+1.0i 1.0+1.0i) 3.0+2.0i)+(num-test (- 1.0 1.0+1.0i 1.0+1.0i) -1.0-2.0i)+(num-test (* 1.0 1.0+1.0i 1.0+1.0i) 0.0+2.0i)+(num-test (/ 1.0 1.0+1.0i 1.0+1.0i) 0.0-0.5i)+(num-test (= 1.0 1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1.0 1.0+1.0i 0) 2.0+1.0i)+(num-test (- 1.0 1.0+1.0i 0) 0.0-1.0i)+(num-test (* 1.0 1.0+1.0i 0) 0.0)+(num-test (+ 1.0 1.0+1.0i 0.0) 2.0+1.0i)+(num-test (- 1.0 1.0+1.0i 0.0) 0.0-1.0i)+(num-test (* 1.0 1.0+1.0i 0.0) 0.0)+(num-test (+ 1.0 1.0+1.0i 1234) 1236.0+1.0i)+(num-test (- 1.0 1.0+1.0i 1234) -1234.0-1.0i)+(num-test (* 1.0 1.0+1.0i 1234) 1234.0+1234.0i)+(num-test (/ 1.0 1.0+1.0i 1234) 0.00040518638574-0.00040518638574i)+(num-test (= 1.0 1.0+1.0i 1234) #f)+(num-test (+ 1.0 1.0+1.0i 123.4) 125.4+1.0i)+(num-test (- 1.0 1.0+1.0i 123.4) -123.4-1.0i)+(num-test (* 1.0 1.0+1.0i 123.4) 123.4+123.4i)+(num-test (/ 1.0 1.0+1.0i 123.4) 0.00405186385737-0.00405186385737i)+(num-test (= 1.0 1.0+1.0i 123.4) #f)+(num-test (+ 1.0 1.0+1.0i 1234/11) 114.18181818181819+1.0i)+(num-test (- 1.0 1.0+1.0i 1234/11) -112.18181818181819-1.0i)+(num-test (* 1.0 1.0+1.0i 1234/11) 112.18181818181819+112.18181818181819i)+(num-test (/ 1.0 1.0+1.0i 1234/11) 0.00445705024311-0.00445705024311i)+(num-test (= 1.0 1.0+1.0i 1234/11) #f)+(num-test (+ 1.0 1.0+1.0i 1.234+1.234i) 3.234+2.234i)+(num-test (- 1.0 1.0+1.0i 1.234+1.234i) -1.234-2.234i)+(num-test (* 1.0 1.0+1.0i 1.234+1.234i) 0.0+2.468i)+(num-test (/ 1.0 1.0+1.0i 1.234+1.234i) 0.0-0.40518638573744i)+(num-test (= 1.0 1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1.0 1.0+1.0i -1.0+1.0i) 1.0+2.0i)+(num-test (- 1.0 1.0+1.0i -1.0+1.0i) 1.0-2.0i)+(num-test (* 1.0 1.0+1.0i -1.0+1.0i) -2.0)+(num-test (/ 1.0 1.0+1.0i -1.0+1.0i) -0.5)+(num-test (= 1.0 1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1.0 1.0+1.0i 0.0+1.0i) 2.0+2.0i)+(num-test (- 1.0 1.0+1.0i 0.0+1.0i) 0.0-2.0i)+(num-test (* 1.0 1.0+1.0i 0.0+1.0i) -1.0+1.0i)+(num-test (/ 1.0 1.0+1.0i 0.0+1.0i) -0.5-0.5i)+(num-test (= 1.0 1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1.0 0 1) 2.0)+(num-test (- 1.0 0 1) 0.0)+(num-test (* 1.0 0 1) 0.0)+(num-test (+ 1.0 0 1.0) 2.0)+(num-test (- 1.0 0 1.0) 0.0)+(num-test (* 1.0 0 1.0) 0.0)+(num-test (+ 1.0 0 1/1) 2.0)+(num-test (- 1.0 0 1/1) 0.0)+(num-test (* 1.0 0 1/1) 0.0)+(num-test (+ 1.0 0 1.0+1.0i) 2.0+1.0i)+(num-test (- 1.0 0 1.0+1.0i) 0.0-1.0i)+(num-test (* 1.0 0 1.0+1.0i) 0.0)+(num-test (+ 1.0 0 0) 1.0)+(num-test (- 1.0 0 0) 1.0)+(num-test (* 1.0 0 0) 0.0)+(num-test (+ 1.0 0 0.0) 1.0)+(num-test (- 1.0 0 0.0) 1.0)+(num-test (* 1.0 0 0.0) 0.0)+(num-test (+ 1.0 0 1234) 1235.0)+(num-test (- 1.0 0 1234) -1233.0)+(num-test (* 1.0 0 1234) 0.0)+(num-test (+ 1.0 0 123.4) 124.4)+(num-test (- 1.0 0 123.4) -122.4)+(num-test (* 1.0 0 123.4) 0.0)+(num-test (+ 1.0 0 1234/11) 113.18181818181819)+(num-test (- 1.0 0 1234/11) -111.18181818181819)+(num-test (* 1.0 0 1234/11) 0.0)+(num-test (+ 1.0 0 1.234+1.234i) 2.234+1.234i)+(num-test (- 1.0 0 1.234+1.234i) -0.234-1.234i)+(num-test (* 1.0 0 1.234+1.234i) 0.0)+(num-test (+ 1.0 0 -1.0+1.0i) 0.0+1.0i)+(num-test (- 1.0 0 -1.0+1.0i) 2.0-1.0i)+(num-test (* 1.0 0 -1.0+1.0i) -0.0)+(num-test (+ 1.0 0 0.0+1.0i) 1.0+1.0i)+(num-test (- 1.0 0 0.0+1.0i) 1.0-1.0i)+(num-test (* 1.0 0 0.0+1.0i) 0.0)+(num-test (+ 1.0 0.0 1) 2.0)+(num-test (- 1.0 0.0 1) 0.0)+(num-test (* 1.0 0.0 1) 0.0)+(num-test (+ 1.0 0.0 1.0) 2.0)+(num-test (- 1.0 0.0 1.0) 0.0)+(num-test (* 1.0 0.0 1.0) 0.0)+(num-test (+ 1.0 0.0 1/1) 2.0)+(num-test (- 1.0 0.0 1/1) 0.0)+(num-test (* 1.0 0.0 1/1) 0.0)+(num-test (+ 1.0 0.0 1.0+1.0i) 2.0+1.0i)+(num-test (- 1.0 0.0 1.0+1.0i) 0.0-1.0i)+(num-test (* 1.0 0.0 1.0+1.0i) 0.0)+(num-test (+ 1.0 0.0 0) 1.0)+(num-test (- 1.0 0.0 0) 1.0)+(num-test (* 1.0 0.0 0) 0.0)+(num-test (+ 1.0 0.0 0.0) 1.0)+(num-test (- 1.0 0.0 0.0) 1.0)+(num-test (* 1.0 0.0 0.0) 0.0)+(num-test (+ 1.0 0.0 1234) 1235.0)+(num-test (- 1.0 0.0 1234) -1233.0)+(num-test (* 1.0 0.0 1234) 0.0)+(num-test (+ 1.0 0.0 123.4) 124.4)+(num-test (- 1.0 0.0 123.4) -122.4)+(num-test (* 1.0 0.0 123.4) 0.0)+(num-test (+ 1.0 0.0 1234/11) 113.18181818181819)+(num-test (- 1.0 0.0 1234/11) -111.18181818181819)+(num-test (* 1.0 0.0 1234/11) 0.0)+(num-test (+ 1.0 0.0 1.234+1.234i) 2.234+1.234i)+(num-test (- 1.0 0.0 1.234+1.234i) -0.234-1.234i)+(num-test (* 1.0 0.0 1.234+1.234i) 0.0)+(num-test (+ 1.0 0.0 -1.0+1.0i) 0.0+1.0i)+(num-test (- 1.0 0.0 -1.0+1.0i) 2.0-1.0i)+(num-test (* 1.0 0.0 -1.0+1.0i) -0.0)+(num-test (+ 1.0 0.0 0.0+1.0i) 1.0+1.0i)+(num-test (- 1.0 0.0 0.0+1.0i) 1.0-1.0i)+(num-test (* 1.0 0.0 0.0+1.0i) 0.0)+(num-test (+ 1.0 1234 1) 1236.0)+(num-test (- 1.0 1234 1) -1234.0)+(num-test (* 1.0 1234 1) 1234.0)+(num-test (/ 1.0 1234 1) 0.00081037277147)+(num-test (= 1.0 1234 1) #f)+(num-test (< 1.0 1234 1) #f)+(num-test (<= 1.0 1234 1) #f)+(num-test (> 1.0 1234 1) #f)+(num-test (>= 1.0 1234 1) #f)+(num-test (+ 1.0 1234 1.0) 1236.0)+(num-test (- 1.0 1234 1.0) -1234.0)+(num-test (* 1.0 1234 1.0) 1234.0)+(num-test (/ 1.0 1234 1.0) 0.00081037277147)+(num-test (= 1.0 1234 1.0) #f)+(num-test (< 1.0 1234 1.0) #f)+(num-test (<= 1.0 1234 1.0) #f)+(num-test (> 1.0 1234 1.0) #f)+(num-test (>= 1.0 1234 1.0) #f)+(num-test (+ 1.0 1234 1/1) 1236.0)+(num-test (- 1.0 1234 1/1) -1234.0)+(num-test (* 1.0 1234 1/1) 1234.0)+(num-test (/ 1.0 1234 1/1) 0.00081037277147)+(num-test (= 1.0 1234 1/1) #f)+(num-test (< 1.0 1234 1/1) #f)+(num-test (<= 1.0 1234 1/1) #f)+(num-test (> 1.0 1234 1/1) #f)+(num-test (>= 1.0 1234 1/1) #f)+(num-test (+ 1.0 1234 1.0+1.0i) 1236.0+1.0i)+(num-test (- 1.0 1234 1.0+1.0i) -1234.0-1.0i)+(num-test (* 1.0 1234 1.0+1.0i) 1234.0+1234.0i)+(num-test (/ 1.0 1234 1.0+1.0i) 0.00040518638574-0.00040518638574i)+(num-test (= 1.0 1234 1.0+1.0i) #f)+(num-test (+ 1.0 1234 0) 1235.0)+(num-test (- 1.0 1234 0) -1233.0)+(num-test (* 1.0 1234 0) 0.0)+(num-test (+ 1.0 1234 0.0) 1235.0)+(num-test (- 1.0 1234 0.0) -1233.0)+(num-test (* 1.0 1234 0.0) 0.0)+(num-test (+ 1.0 1234 1234) 2469.0)+(num-test (- 1.0 1234 1234) -2467.0)+(num-test (* 1.0 1234 1234) 1522756.0)+(num-test (/ 1.0 1234 1234) 0.00000065670403)+(num-test (= 1.0 1234 1234) #f)+(num-test (< 1.0 1234 1234) #f)+(num-test (<= 1.0 1234 1234) #t)+(num-test (> 1.0 1234 1234) #f)+(num-test (>= 1.0 1234 1234) #f)+(num-test (+ 1.0 1234 123.4) 1358.4)+(num-test (- 1.0 1234 123.4) -1356.4)+(num-test (* 1.0 1234 123.4) 152275.60000000000582)+(num-test (/ 1.0 1234 123.4) 0.00000656704029)+(num-test (= 1.0 1234 123.4) #f)+(num-test (< 1.0 1234 123.4) #f)+(num-test (<= 1.0 1234 123.4) #f)+(num-test (> 1.0 1234 123.4) #f)+(num-test (>= 1.0 1234 123.4) #f)+(num-test (+ 1.0 1234 1234/11) 1347.18181818181824)+(num-test (- 1.0 1234 1234/11) -1345.18181818181824)+(num-test (* 1.0 1234 1234/11) 138432.36363636364695)+(num-test (/ 1.0 1234 1234/11) 0.00000722374432)+(num-test (= 1.0 1234 1234/11) #f)+(num-test (< 1.0 1234 1234/11) #f)+(num-test (<= 1.0 1234 1234/11) #f)+(num-test (> 1.0 1234 1234/11) #f)+(num-test (>= 1.0 1234 1234/11) #f)+(num-test (+ 1.0 1234 1.234+1.234i) 1236.23399999999992+1.234i)+(num-test (- 1.0 1234 1.234+1.234i) -1234.23399999999992-1.234i)+(num-test (* 1.0 1234 1.234+1.234i) 1522.756+1522.756i)+(num-test (/ 1.0 1234 1.234+1.234i) 0.00032835201437-0.00032835201437i)+(num-test (= 1.0 1234 1.234+1.234i) #f)+(num-test (+ 1.0 1234 -1.0+1.0i) 1234.0+1.0i)+(num-test (- 1.0 1234 -1.0+1.0i) -1232.0-1.0i)+(num-test (* 1.0 1234 -1.0+1.0i) -1234.0+1234.0i)+(num-test (/ 1.0 1234 -1.0+1.0i) -0.00040518638574-0.00040518638574i)+(num-test (= 1.0 1234 -1.0+1.0i) #f)+(num-test (+ 1.0 1234 0.0+1.0i) 1235.0+1.0i)+(num-test (- 1.0 1234 0.0+1.0i) -1233.0-1.0i)+(num-test (* 1.0 1234 0.0+1.0i) 0.0+1234.0i)+(num-test (/ 1.0 1234 0.0+1.0i) 0.0-0.00081037277147i)+(num-test (= 1.0 1234 0.0+1.0i) #f)+(num-test (+ 1.0 123.4 1) 125.4)+(num-test (- 1.0 123.4 1) -123.4)+(num-test (* 1.0 123.4 1) 123.4)+(num-test (/ 1.0 123.4 1) 0.00810372771475)+(num-test (= 1.0 123.4 1) #f)+(num-test (< 1.0 123.4 1) #f)+(num-test (<= 1.0 123.4 1) #f)+(num-test (> 1.0 123.4 1) #f)+(num-test (>= 1.0 123.4 1) #f)+(num-test (+ 1.0 123.4 1.0) 125.4)+(num-test (- 1.0 123.4 1.0) -123.4)+(num-test (* 1.0 123.4 1.0) 123.4)+(num-test (/ 1.0 123.4 1.0) 0.00810372771475)+(num-test (= 1.0 123.4 1.0) #f)+(num-test (< 1.0 123.4 1.0) #f)+(num-test (<= 1.0 123.4 1.0) #f)+(num-test (> 1.0 123.4 1.0) #f)+(num-test (>= 1.0 123.4 1.0) #f)+(num-test (+ 1.0 123.4 1/1) 125.4)+(num-test (- 1.0 123.4 1/1) -123.4)+(num-test (* 1.0 123.4 1/1) 123.4)+(num-test (/ 1.0 123.4 1/1) 0.00810372771475)+(num-test (= 1.0 123.4 1/1) #f)+(num-test (< 1.0 123.4 1/1) #f)+(num-test (<= 1.0 123.4 1/1) #f)+(num-test (> 1.0 123.4 1/1) #f)+(num-test (>= 1.0 123.4 1/1) #f)+(num-test (+ 1.0 123.4 1.0+1.0i) 125.4+1.0i)+(num-test (- 1.0 123.4 1.0+1.0i) -123.4-1.0i)+(num-test (* 1.0 123.4 1.0+1.0i) 123.4+123.4i)+(num-test (/ 1.0 123.4 1.0+1.0i) 0.00405186385737-0.00405186385737i)+(num-test (= 1.0 123.4 1.0+1.0i) #f)+(num-test (+ 1.0 123.4 0) 124.4)+(num-test (- 1.0 123.4 0) -122.4)+(num-test (* 1.0 123.4 0) 0.0)+(num-test (+ 1.0 123.4 0.0) 124.4)+(num-test (- 1.0 123.4 0.0) -122.4)+(num-test (* 1.0 123.4 0.0) 0.0)+(num-test (+ 1.0 123.4 1234) 1358.4)+(num-test (- 1.0 123.4 1234) -1356.4)+(num-test (* 1.0 123.4 1234) 152275.60000000000582)+(num-test (/ 1.0 123.4 1234) 0.00000656704029)+(num-test (= 1.0 123.4 1234) #f)+(num-test (< 1.0 123.4 1234) #t)+(num-test (<= 1.0 123.4 1234) #t)+(num-test (> 1.0 123.4 1234) #f)+(num-test (>= 1.0 123.4 1234) #f)+(num-test (+ 1.0 123.4 123.4) 247.8)+(num-test (- 1.0 123.4 123.4) -245.8)+(num-test (* 1.0 123.4 123.4) 15227.56000000000131)+(num-test (/ 1.0 123.4 123.4) 0.00006567040287)+(num-test (= 1.0 123.4 123.4) #f)+(num-test (< 1.0 123.4 123.4) #f)+(num-test (<= 1.0 123.4 123.4) #t)+(num-test (> 1.0 123.4 123.4) #f)+(num-test (>= 1.0 123.4 123.4) #f)+(num-test (+ 1.0 123.4 1234/11) 236.58181818181819)+(num-test (- 1.0 123.4 1234/11) -234.58181818181819)+(num-test (* 1.0 123.4 1234/11) 13843.23636363636433)+(num-test (/ 1.0 123.4 1234/11) 0.00007223744316)+(num-test (= 1.0 123.4 1234/11) #f)+(num-test (< 1.0 123.4 1234/11) #f)+(num-test (<= 1.0 123.4 1234/11) #f)+(num-test (> 1.0 123.4 1234/11) #f)+(num-test (>= 1.0 123.4 1234/11) #f)+(num-test (+ 1.0 123.4 1.234+1.234i) 125.634+1.234i)+(num-test (- 1.0 123.4 1.234+1.234i) -123.634-1.234i)+(num-test (* 1.0 123.4 1.234+1.234i) 152.2756+152.2756i)+(num-test (/ 1.0 123.4 1.234+1.234i) 0.00328352014374-0.00328352014374i)+(num-test (= 1.0 123.4 1.234+1.234i) #f)+(num-test (+ 1.0 123.4 -1.0+1.0i) 123.4+1.0i)+(num-test (- 1.0 123.4 -1.0+1.0i) -121.4-1.0i)+(num-test (* 1.0 123.4 -1.0+1.0i) -123.4+123.4i)+(num-test (/ 1.0 123.4 -1.0+1.0i) -0.00405186385737-0.00405186385737i)+(num-test (= 1.0 123.4 -1.0+1.0i) #f)+(num-test (+ 1.0 123.4 0.0+1.0i) 124.4+1.0i)+(num-test (- 1.0 123.4 0.0+1.0i) -122.4-1.0i)+(num-test (* 1.0 123.4 0.0+1.0i) 0.0+123.4i)+(num-test (/ 1.0 123.4 0.0+1.0i) 0.0-0.00810372771475i)+(num-test (= 1.0 123.4 0.0+1.0i) #f)+(num-test (+ 1.0 1234/11 1) 114.18181818181819)+(num-test (- 1.0 1234/11 1) -112.18181818181819)+(num-test (* 1.0 1234/11 1) 112.18181818181819)+(num-test (/ 1.0 1234/11 1) 0.00891410048622)+(num-test (= 1.0 1234/11 1) #f)+(num-test (< 1.0 1234/11 1) #f)+(num-test (<= 1.0 1234/11 1) #f)+(num-test (> 1.0 1234/11 1) #f)+(num-test (>= 1.0 1234/11 1) #f)+(num-test (+ 1.0 1234/11 1.0) 114.18181818181819)+(num-test (- 1.0 1234/11 1.0) -112.18181818181819)+(num-test (* 1.0 1234/11 1.0) 112.18181818181819)+(num-test (/ 1.0 1234/11 1.0) 0.00891410048622)+(num-test (= 1.0 1234/11 1.0) #f)+(num-test (< 1.0 1234/11 1.0) #f)+(num-test (<= 1.0 1234/11 1.0) #f)+(num-test (> 1.0 1234/11 1.0) #f)+(num-test (>= 1.0 1234/11 1.0) #f)+(num-test (+ 1.0 1234/11 1/1) 114.18181818181819)+(num-test (- 1.0 1234/11 1/1) -112.18181818181819)+(num-test (* 1.0 1234/11 1/1) 112.18181818181819)+(num-test (/ 1.0 1234/11 1/1) 0.00891410048622)+(num-test (= 1.0 1234/11 1/1) #f)+(num-test (< 1.0 1234/11 1/1) #f)+(num-test (<= 1.0 1234/11 1/1) #f)+(num-test (> 1.0 1234/11 1/1) #f)+(num-test (>= 1.0 1234/11 1/1) #f)+(num-test (+ 1.0 1234/11 1.0+1.0i) 114.18181818181819+1.0i)+(num-test (- 1.0 1234/11 1.0+1.0i) -112.18181818181819-1.0i)+(num-test (* 1.0 1234/11 1.0+1.0i) 112.18181818181819+112.18181818181819i)+(num-test (/ 1.0 1234/11 1.0+1.0i) 0.00445705024311-0.00445705024311i)+(num-test (= 1.0 1234/11 1.0+1.0i) #f)+(num-test (+ 1.0 1234/11 0) 113.18181818181819)+(num-test (- 1.0 1234/11 0) -111.18181818181819)+(num-test (* 1.0 1234/11 0) 0.0)+(num-test (+ 1.0 1234/11 0.0) 113.18181818181819)+(num-test (- 1.0 1234/11 0.0) -111.18181818181819)+(num-test (* 1.0 1234/11 0.0) 0.0)+(num-test (+ 1.0 1234/11 1234) 1347.18181818181824)+(num-test (- 1.0 1234/11 1234) -1345.18181818181824)+(num-test (* 1.0 1234/11 1234) 138432.36363636364695)+(num-test (/ 1.0 1234/11 1234) 0.00000722374432)+(num-test (= 1.0 1234/11 1234) #f)+(num-test (< 1.0 1234/11 1234) #t)+(num-test (<= 1.0 1234/11 1234) #t)+(num-test (> 1.0 1234/11 1234) #f)+(num-test (>= 1.0 1234/11 1234) #f)+(num-test (+ 1.0 1234/11 123.4) 236.58181818181819)+(num-test (- 1.0 1234/11 123.4) -234.58181818181819)+(num-test (* 1.0 1234/11 123.4) 13843.23636363636433)+(num-test (/ 1.0 1234/11 123.4) 0.00007223744316)+(num-test (= 1.0 1234/11 123.4) #f)+(num-test (< 1.0 1234/11 123.4) #t)+(num-test (<= 1.0 1234/11 123.4) #t)+(num-test (> 1.0 1234/11 123.4) #f)+(num-test (>= 1.0 1234/11 123.4) #f)+(num-test (+ 1.0 1234/11 1234/11) 225.36363636363637)+(num-test (- 1.0 1234/11 1234/11) -223.36363636363637)+(num-test (* 1.0 1234/11 1234/11) 12584.76033057851237)+(num-test (/ 1.0 1234/11 1234/11) 0.00007946118748)+(num-test (= 1.0 1234/11 1234/11) #f)+(num-test (< 1.0 1234/11 1234/11) #f)+(num-test (<= 1.0 1234/11 1234/11) #t)+(num-test (> 1.0 1234/11 1234/11) #f)+(num-test (>= 1.0 1234/11 1234/11) #f)+(num-test (+ 1.0 1234/11 1.234+1.234i) 114.41581818181818+1.234i)+(num-test (- 1.0 1234/11 1.234+1.234i) -112.41581818181818-1.234i)+(num-test (* 1.0 1234/11 1.234+1.234i) 138.43236363636365+138.43236363636365i)+(num-test (/ 1.0 1234/11 1.234+1.234i) 0.00361187215811-0.00361187215811i)+(num-test (= 1.0 1234/11 1.234+1.234i) #f)+(num-test (+ 1.0 1234/11 -1.0+1.0i) 112.18181818181819+1.0i)+(num-test (- 1.0 1234/11 -1.0+1.0i) -110.18181818181819-1.0i)+(num-test (* 1.0 1234/11 -1.0+1.0i) -112.18181818181819+112.18181818181819i)+(num-test (/ 1.0 1234/11 -1.0+1.0i) -0.00445705024311-0.00445705024311i)+(num-test (= 1.0 1234/11 -1.0+1.0i) #f)+(num-test (+ 1.0 1234/11 0.0+1.0i) 113.18181818181819+1.0i)+(num-test (- 1.0 1234/11 0.0+1.0i) -111.18181818181819-1.0i)+(num-test (* 1.0 1234/11 0.0+1.0i) 0.0+112.18181818181819i)+(num-test (/ 1.0 1234/11 0.0+1.0i) 0.0-0.00891410048622i)+(num-test (= 1.0 1234/11 0.0+1.0i) #f)+(num-test (+ 1.0 1.234+1.234i 1) 3.234+1.234i)+(num-test (- 1.0 1.234+1.234i 1) -1.234-1.234i)+(num-test (* 1.0 1.234+1.234i 1) 1.234+1.234i)+(num-test (/ 1.0 1.234+1.234i 1) 0.40518638573744-0.40518638573744i)+(num-test (= 1.0 1.234+1.234i 1) #f)+(num-test (+ 1.0 1.234+1.234i 1.0) 3.234+1.234i)+(num-test (- 1.0 1.234+1.234i 1.0) -1.234-1.234i)+(num-test (* 1.0 1.234+1.234i 1.0) 1.234+1.234i)+(num-test (/ 1.0 1.234+1.234i 1.0) 0.40518638573744-0.40518638573744i)+(num-test (= 1.0 1.234+1.234i 1.0) #f)+(num-test (+ 1.0 1.234+1.234i 1/1) 3.234+1.234i)+(num-test (- 1.0 1.234+1.234i 1/1) -1.234-1.234i)+(num-test (* 1.0 1.234+1.234i 1/1) 1.234+1.234i)+(num-test (/ 1.0 1.234+1.234i 1/1) 0.40518638573744-0.40518638573744i)+(num-test (= 1.0 1.234+1.234i 1/1) #f)+(num-test (+ 1.0 1.234+1.234i 1.0+1.0i) 3.234+2.234i)+(num-test (- 1.0 1.234+1.234i 1.0+1.0i) -1.234-2.234i)+(num-test (* 1.0 1.234+1.234i 1.0+1.0i) 0.0+2.468i)+(num-test (/ 1.0 1.234+1.234i 1.0+1.0i) 0.0-0.40518638573744i)+(num-test (= 1.0 1.234+1.234i 1.0+1.0i) #f)+(num-test (+ 1.0 1.234+1.234i 0) 2.234+1.234i)+(num-test (- 1.0 1.234+1.234i 0) -0.234-1.234i)+(num-test (* 1.0 1.234+1.234i 0) 0.0)+(num-test (+ 1.0 1.234+1.234i 0.0) 2.234+1.234i)+(num-test (- 1.0 1.234+1.234i 0.0) -0.234-1.234i)+(num-test (* 1.0 1.234+1.234i 0.0) 0.0)+(num-test (+ 1.0 1.234+1.234i 1234) 1236.23399999999992+1.234i)+(num-test (- 1.0 1.234+1.234i 1234) -1234.23399999999992-1.234i)+(num-test (* 1.0 1.234+1.234i 1234) 1522.756+1522.756i)+(num-test (/ 1.0 1.234+1.234i 1234) 0.00032835201437-0.00032835201437i)+(num-test (= 1.0 1.234+1.234i 1234) #f)+(num-test (+ 1.0 1.234+1.234i 123.4) 125.634+1.234i)+(num-test (- 1.0 1.234+1.234i 123.4) -123.634-1.234i)+(num-test (* 1.0 1.234+1.234i 123.4) 152.2756+152.2756i)+(num-test (/ 1.0 1.234+1.234i 123.4) 0.00328352014374-0.00328352014374i)+(num-test (= 1.0 1.234+1.234i 123.4) #f)+(num-test (+ 1.0 1.234+1.234i 1234/11) 114.41581818181818+1.234i)+(num-test (- 1.0 1.234+1.234i 1234/11) -112.41581818181818-1.234i)+(num-test (* 1.0 1.234+1.234i 1234/11) 138.43236363636365+138.43236363636365i)+(num-test (/ 1.0 1.234+1.234i 1234/11) 0.00361187215811-0.00361187215811i)+(num-test (= 1.0 1.234+1.234i 1234/11) #f)+(num-test (+ 1.0 1.234+1.234i 1.234+1.234i) 3.468+2.468i)+(num-test (- 1.0 1.234+1.234i 1.234+1.234i) -1.468-2.468i)+(num-test (* 1.0 1.234+1.234i 1.234+1.234i) 0.0+3.04551200000000i)+(num-test (/ 1.0 1.234+1.234i 1.234+1.234i) 0.0-0.32835201437394i)+(num-test (= 1.0 1.234+1.234i 1.234+1.234i) #f)+(num-test (+ 1.0 1.234+1.234i -1.0+1.0i) 1.234+2.234i)+(num-test (- 1.0 1.234+1.234i -1.0+1.0i) 0.766-2.234i)+(num-test (* 1.0 1.234+1.234i -1.0+1.0i) -2.468)+(num-test (/ 1.0 1.234+1.234i -1.0+1.0i) -0.40518638573744)+(num-test (= 1.0 1.234+1.234i -1.0+1.0i) #f)+(num-test (+ 1.0 1.234+1.234i 0.0+1.0i) 2.234+2.234i)+(num-test (- 1.0 1.234+1.234i 0.0+1.0i) -0.234-2.234i)+(num-test (* 1.0 1.234+1.234i 0.0+1.0i) -1.234+1.234i)+(num-test (/ 1.0 1.234+1.234i 0.0+1.0i) -0.40518638573744-0.40518638573744i)+(num-test (= 1.0 1.234+1.234i 0.0+1.0i) #f)+(num-test (+ 1.0 -1.0+1.0i 1) 1.0+1.0i)+(num-test (- 1.0 -1.0+1.0i 1) 1.0-1.0i)+(num-test (* 1.0 -1.0+1.0i 1) -1.0+1.0i)+(num-test (/ 1.0 -1.0+1.0i 1) -0.5-0.5i)+(num-test (= 1.0 -1.0+1.0i 1) #f)+(num-test (+ 1.0 -1.0+1.0i 1.0) 1.0+1.0i)+(num-test (- 1.0 -1.0+1.0i 1.0) 1.0-1.0i)+(num-test (* 1.0 -1.0+1.0i 1.0) -1.0+1.0i)+(num-test (/ 1.0 -1.0+1.0i 1.0) -0.5-0.5i)+(num-test (= 1.0 -1.0+1.0i 1.0) #f)+(num-test (+ 1.0 -1.0+1.0i 1/1) 1.0+1.0i)+(num-test (- 1.0 -1.0+1.0i 1/1) 1.0-1.0i)+(num-test (* 1.0 -1.0+1.0i 1/1) -1.0+1.0i)+(num-test (/ 1.0 -1.0+1.0i 1/1) -0.5-0.5i)+(num-test (= 1.0 -1.0+1.0i 1/1) #f)+(num-test (+ 1.0 -1.0+1.0i 1.0+1.0i) 1.0+2.0i)+(num-test (- 1.0 -1.0+1.0i 1.0+1.0i) 1.0-2.0i)+(num-test (* 1.0 -1.0+1.0i 1.0+1.0i) -2.0)+(num-test (/ 1.0 -1.0+1.0i 1.0+1.0i) -0.5)+(num-test (= 1.0 -1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1.0 -1.0+1.0i 0) 0.0+1.0i)+(num-test (- 1.0 -1.0+1.0i 0) 2.0-1.0i)+(num-test (* 1.0 -1.0+1.0i 0) -0.0)+(num-test (+ 1.0 -1.0+1.0i 0.0) 0.0+1.0i)+(num-test (- 1.0 -1.0+1.0i 0.0) 2.0-1.0i)+(num-test (* 1.0 -1.0+1.0i 0.0) -0.0)+(num-test (+ 1.0 -1.0+1.0i 1234) 1234.0+1.0i)+(num-test (- 1.0 -1.0+1.0i 1234) -1232.0-1.0i)+(num-test (* 1.0 -1.0+1.0i 1234) -1234.0+1234.0i)+(num-test (/ 1.0 -1.0+1.0i 1234) -0.00040518638574-0.00040518638574i)+(num-test (= 1.0 -1.0+1.0i 1234) #f)+(num-test (+ 1.0 -1.0+1.0i 123.4) 123.4+1.0i)+(num-test (- 1.0 -1.0+1.0i 123.4) -121.4-1.0i)+(num-test (* 1.0 -1.0+1.0i 123.4) -123.4+123.4i)+(num-test (/ 1.0 -1.0+1.0i 123.4) -0.00405186385737-0.00405186385737i)+(num-test (= 1.0 -1.0+1.0i 123.4) #f)+(num-test (+ 1.0 -1.0+1.0i 1234/11) 112.18181818181819+1.0i)+(num-test (- 1.0 -1.0+1.0i 1234/11) -110.18181818181819-1.0i)+(num-test (* 1.0 -1.0+1.0i 1234/11) -112.18181818181819+112.18181818181819i)+(num-test (/ 1.0 -1.0+1.0i 1234/11) -0.00445705024311-0.00445705024311i)+(num-test (= 1.0 -1.0+1.0i 1234/11) #f)+(num-test (+ 1.0 -1.0+1.0i 1.234+1.234i) 1.234+2.234i)+(num-test (- 1.0 -1.0+1.0i 1.234+1.234i) 0.766-2.234i)+(num-test (* 1.0 -1.0+1.0i 1.234+1.234i) -2.468)+(num-test (/ 1.0 -1.0+1.0i 1.234+1.234i) -0.40518638573744)+(num-test (= 1.0 -1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1.0 -1.0+1.0i -1.0+1.0i) -1.0+2.0i)+(num-test (- 1.0 -1.0+1.0i -1.0+1.0i) 3.0-2.0i)+(num-test (* 1.0 -1.0+1.0i -1.0+1.0i) 0.0-2.0i)+(num-test (/ 1.0 -1.0+1.0i -1.0+1.0i) -0.0+0.5i)+(num-test (= 1.0 -1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1.0 -1.0+1.0i 0.0+1.0i) 0.0+2.0i)+(num-test (- 1.0 -1.0+1.0i 0.0+1.0i) 2.0-2.0i)+(num-test (* 1.0 -1.0+1.0i 0.0+1.0i) -1.0-1.0i)+(num-test (/ 1.0 -1.0+1.0i 0.0+1.0i) -0.5+0.5i)+(num-test (= 1.0 -1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1.0 0.0+1.0i 1) 2.0+1.0i)+(num-test (- 1.0 0.0+1.0i 1) 0.0-1.0i)+(num-test (* 1.0 0.0+1.0i 1) 0.0+1.0i)+(num-test (/ 1.0 0.0+1.0i 1) 0.0-1.0i)+(num-test (= 1.0 0.0+1.0i 1) #f)+(num-test (+ 1.0 0.0+1.0i 1.0) 2.0+1.0i)+(num-test (- 1.0 0.0+1.0i 1.0) 0.0-1.0i)+(num-test (* 1.0 0.0+1.0i 1.0) 0.0+1.0i)+(num-test (/ 1.0 0.0+1.0i 1.0) 0.0-1.0i)+(num-test (= 1.0 0.0+1.0i 1.0) #f)+(num-test (+ 1.0 0.0+1.0i 1/1) 2.0+1.0i)+(num-test (- 1.0 0.0+1.0i 1/1) 0.0-1.0i)+(num-test (* 1.0 0.0+1.0i 1/1) 0.0+1.0i)+(num-test (/ 1.0 0.0+1.0i 1/1) 0.0-1.0i)+(num-test (= 1.0 0.0+1.0i 1/1) #f)+(num-test (+ 1.0 0.0+1.0i 1.0+1.0i) 2.0+2.0i)+(num-test (- 1.0 0.0+1.0i 1.0+1.0i) 0.0-2.0i)+(num-test (* 1.0 0.0+1.0i 1.0+1.0i) -1.0+1.0i)+(num-test (/ 1.0 0.0+1.0i 1.0+1.0i) -0.5-0.5i)+(num-test (= 1.0 0.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1.0 0.0+1.0i 0) 1.0+1.0i)+(num-test (- 1.0 0.0+1.0i 0) 1.0-1.0i)+(num-test (* 1.0 0.0+1.0i 0) 0.0)+(num-test (+ 1.0 0.0+1.0i 0.0) 1.0+1.0i)+(num-test (- 1.0 0.0+1.0i 0.0) 1.0-1.0i)+(num-test (* 1.0 0.0+1.0i 0.0) 0.0)+(num-test (+ 1.0 0.0+1.0i 1234) 1235.0+1.0i)+(num-test (- 1.0 0.0+1.0i 1234) -1233.0-1.0i)+(num-test (* 1.0 0.0+1.0i 1234) 0.0+1234.0i)+(num-test (/ 1.0 0.0+1.0i 1234) 0.0-0.00081037277147i)+(num-test (= 1.0 0.0+1.0i 1234) #f)+(num-test (+ 1.0 0.0+1.0i 123.4) 124.4+1.0i)+(num-test (- 1.0 0.0+1.0i 123.4) -122.4-1.0i)+(num-test (* 1.0 0.0+1.0i 123.4) 0.0+123.4i)+(num-test (/ 1.0 0.0+1.0i 123.4) 0.0-0.00810372771475i)+(num-test (= 1.0 0.0+1.0i 123.4) #f)+(num-test (+ 1.0 0.0+1.0i 1234/11) 113.18181818181819+1.0i)+(num-test (- 1.0 0.0+1.0i 1234/11) -111.18181818181819-1.0i)+(num-test (* 1.0 0.0+1.0i 1234/11) 0.0+112.18181818181819i)+(num-test (/ 1.0 0.0+1.0i 1234/11) 0.0-0.00891410048622i)+(num-test (= 1.0 0.0+1.0i 1234/11) #f)+(num-test (+ 1.0 0.0+1.0i 1.234+1.234i) 2.234+2.234i)+(num-test (- 1.0 0.0+1.0i 1.234+1.234i) -0.234-2.234i)+(num-test (* 1.0 0.0+1.0i 1.234+1.234i) -1.234+1.234i)+(num-test (/ 1.0 0.0+1.0i 1.234+1.234i) -0.40518638573744-0.40518638573744i)+(num-test (= 1.0 0.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1.0 0.0+1.0i -1.0+1.0i) 0.0+2.0i)+(num-test (- 1.0 0.0+1.0i -1.0+1.0i) 2.0-2.0i)+(num-test (* 1.0 0.0+1.0i -1.0+1.0i) -1.0-1.0i)+(num-test (/ 1.0 0.0+1.0i -1.0+1.0i) -0.5+0.5i)+(num-test (= 1.0 0.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1.0 0.0+1.0i 0.0+1.0i) 1.0+2.0i)+(num-test (- 1.0 0.0+1.0i 0.0+1.0i) 1.0-2.0i)+(num-test (* 1.0 0.0+1.0i 0.0+1.0i) -1.0)+(num-test (/ 1.0 0.0+1.0i 0.0+1.0i) -1.0)+(num-test (= 1.0 0.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1/1 1 1) 3)+(num-test (- 1/1 1 1) -1)+(num-test (* 1/1 1 1) 1)+(num-test (/ 1/1 1 1) 1)+(num-test (= 1/1 1 1) #t)+(num-test (< 1/1 1 1) #f)+(num-test (<= 1/1 1 1) #t)+(num-test (> 1/1 1 1) #f)+(num-test (>= 1/1 1 1) #t)+(num-test (+ 1/1 1 1.0) 3.0)+(num-test (- 1/1 1 1.0) -1.0)+(num-test (* 1/1 1 1.0) 1.0)+(num-test (/ 1/1 1 1.0) 1.0)+(num-test (= 1/1 1 1.0) #t)+(num-test (< 1/1 1 1.0) #f)+(num-test (<= 1/1 1 1.0) #t)+(num-test (> 1/1 1 1.0) #f)+(num-test (>= 1/1 1 1.0) #t)+(num-test (+ 1/1 1 1/1) 3)+(num-test (- 1/1 1 1/1) -1)+(num-test (* 1/1 1 1/1) 1)+(num-test (/ 1/1 1 1/1) 1)+(num-test (= 1/1 1 1/1) #t)+(num-test (< 1/1 1 1/1) #f)+(num-test (<= 1/1 1 1/1) #t)+(num-test (> 1/1 1 1/1) #f)+(num-test (>= 1/1 1 1/1) #t)+(num-test (+ 1/1 1 1.0+1.0i) 3.0+1.0i)+(num-test (- 1/1 1 1.0+1.0i) -1.0-1.0i)+(num-test (* 1/1 1 1.0+1.0i) 1.0+1.0i)+(num-test (/ 1/1 1 1.0+1.0i) 0.5-0.5i)+(num-test (= 1/1 1 1.0+1.0i) #f)+(num-test (+ 1/1 1 0) 2)+(num-test (- 1/1 1 0) 0)+(num-test (* 1/1 1 0) 0)+(num-test (+ 1/1 1 0.0) 2.0)+(num-test (- 1/1 1 0.0) 0.0)+(num-test (* 1/1 1 0.0) 0.0)+(num-test (+ 1/1 1 1234) 1236)+(num-test (- 1/1 1 1234) -1234)+(num-test (* 1/1 1 1234) 1234)+(num-test (/ 1/1 1 1234) 1/1234)+(num-test (= 1/1 1 1234) #f)+(num-test (< 1/1 1 1234) #f)+(num-test (<= 1/1 1 1234) #t)+(num-test (> 1/1 1 1234) #f)+(num-test (>= 1/1 1 1234) #f)+(num-test (+ 1/1 1 123.4) 125.4)+(num-test (- 1/1 1 123.4) -123.4)+(num-test (* 1/1 1 123.4) 123.4)+(num-test (/ 1/1 1 123.4) 0.00810372771475)+(num-test (= 1/1 1 123.4) #f)+(num-test (< 1/1 1 123.4) #f)+(num-test (<= 1/1 1 123.4) #t)+(num-test (> 1/1 1 123.4) #f)+(num-test (>= 1/1 1 123.4) #f)+(num-test (+ 1/1 1 1234/11) 1256/11)+(num-test (- 1/1 1 1234/11) -1234/11)+(num-test (* 1/1 1 1234/11) 1234/11)+(num-test (/ 1/1 1 1234/11) 11/1234)+(num-test (= 1/1 1 1234/11) #f)+(num-test (< 1/1 1 1234/11) #f)+(num-test (<= 1/1 1 1234/11) #t)+(num-test (> 1/1 1 1234/11) #f)+(num-test (>= 1/1 1 1234/11) #f)+(num-test (+ 1/1 1 1.234+1.234i) 3.234+1.234i)+(num-test (- 1/1 1 1.234+1.234i) -1.234-1.234i)+(num-test (* 1/1 1 1.234+1.234i) 1.234+1.234i)+(num-test (/ 1/1 1 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1/1 1 1.234+1.234i) #f)+(num-test (+ 1/1 1 -1.0+1.0i) 1.0+1.0i)+(num-test (- 1/1 1 -1.0+1.0i) 1.0-1.0i)+(num-test (* 1/1 1 -1.0+1.0i) -1.0+1.0i)+(num-test (/ 1/1 1 -1.0+1.0i) -0.5-0.5i)+(num-test (= 1/1 1 -1.0+1.0i) #f)+(num-test (+ 1/1 1 0.0+1.0i) 2.0+1.0i)+(num-test (- 1/1 1 0.0+1.0i) 0.0-1.0i)+(num-test (* 1/1 1 0.0+1.0i) 0.0+1.0i)+(num-test (/ 1/1 1 0.0+1.0i) 0.0-1.0i)+(num-test (= 1/1 1 0.0+1.0i) #f)+(num-test (+ 1/1 1.0 1) 3.0)+(num-test (- 1/1 1.0 1) -1.0)+(num-test (* 1/1 1.0 1) 1.0)+(num-test (/ 1/1 1.0 1) 1.0)+(num-test (= 1/1 1.0 1) #t)+(num-test (< 1/1 1.0 1) #f)+(num-test (<= 1/1 1.0 1) #t)+(num-test (> 1/1 1.0 1) #f)+(num-test (>= 1/1 1.0 1) #t)+(num-test (+ 1/1 1.0 1.0) 3.0)+(num-test (- 1/1 1.0 1.0) -1.0)+(num-test (* 1/1 1.0 1.0) 1.0)+(num-test (/ 1/1 1.0 1.0) 1.0)+(num-test (= 1/1 1.0 1.0) #t)+(num-test (< 1/1 1.0 1.0) #f)+(num-test (<= 1/1 1.0 1.0) #t)+(num-test (> 1/1 1.0 1.0) #f)+(num-test (>= 1/1 1.0 1.0) #t)+(num-test (+ 1/1 1.0 1/1) 3.0)+(num-test (- 1/1 1.0 1/1) -1.0)+(num-test (* 1/1 1.0 1/1) 1.0)+(num-test (/ 1/1 1.0 1/1) 1.0)+(num-test (= 1/1 1.0 1/1) #t)+(num-test (< 1/1 1.0 1/1) #f)+(num-test (<= 1/1 1.0 1/1) #t)+(num-test (> 1/1 1.0 1/1) #f)+(num-test (>= 1/1 1.0 1/1) #t)+(num-test (+ 1/1 1.0 1.0+1.0i) 3.0+1.0i)+(num-test (- 1/1 1.0 1.0+1.0i) -1.0-1.0i)+(num-test (* 1/1 1.0 1.0+1.0i) 1.0+1.0i)+(num-test (/ 1/1 1.0 1.0+1.0i) 0.5-0.5i)+(num-test (= 1/1 1.0 1.0+1.0i) #f)+(num-test (+ 1/1 1.0 0) 2.0)+(num-test (- 1/1 1.0 0) 0.0)+(num-test (* 1/1 1.0 0) 0.0)+(num-test (+ 1/1 1.0 0.0) 2.0)+(num-test (- 1/1 1.0 0.0) 0.0)+(num-test (* 1/1 1.0 0.0) 0.0)+(num-test (+ 1/1 1.0 1234) 1236.0)+(num-test (- 1/1 1.0 1234) -1234.0)+(num-test (* 1/1 1.0 1234) 1234.0)+(num-test (/ 1/1 1.0 1234) 0.00081037277147)+(num-test (= 1/1 1.0 1234) #f)+(num-test (< 1/1 1.0 1234) #f)+(num-test (<= 1/1 1.0 1234) #t)+(num-test (> 1/1 1.0 1234) #f)+(num-test (>= 1/1 1.0 1234) #f)+(num-test (+ 1/1 1.0 123.4) 125.4)+(num-test (- 1/1 1.0 123.4) -123.4)+(num-test (* 1/1 1.0 123.4) 123.4)+(num-test (/ 1/1 1.0 123.4) 0.00810372771475)+(num-test (= 1/1 1.0 123.4) #f)+(num-test (< 1/1 1.0 123.4) #f)+(num-test (<= 1/1 1.0 123.4) #t)+(num-test (> 1/1 1.0 123.4) #f)+(num-test (>= 1/1 1.0 123.4) #f)+(num-test (+ 1/1 1.0 1234/11) 114.18181818181819)+(num-test (- 1/1 1.0 1234/11) -112.18181818181819)+(num-test (* 1/1 1.0 1234/11) 112.18181818181819)+(num-test (/ 1/1 1.0 1234/11) 0.00891410048622)+(num-test (= 1/1 1.0 1234/11) #f)+(num-test (< 1/1 1.0 1234/11) #f)+(num-test (<= 1/1 1.0 1234/11) #t)+(num-test (> 1/1 1.0 1234/11) #f)+(num-test (>= 1/1 1.0 1234/11) #f)+(num-test (+ 1/1 1.0 1.234+1.234i) 3.234+1.234i)+(num-test (- 1/1 1.0 1.234+1.234i) -1.234-1.234i)+(num-test (* 1/1 1.0 1.234+1.234i) 1.234+1.234i)+(num-test (/ 1/1 1.0 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1/1 1.0 1.234+1.234i) #f)+(num-test (+ 1/1 1.0 -1.0+1.0i) 1.0+1.0i)+(num-test (- 1/1 1.0 -1.0+1.0i) 1.0-1.0i)+(num-test (* 1/1 1.0 -1.0+1.0i) -1.0+1.0i)+(num-test (/ 1/1 1.0 -1.0+1.0i) -0.5-0.5i)+(num-test (= 1/1 1.0 -1.0+1.0i) #f)+(num-test (+ 1/1 1.0 0.0+1.0i) 2.0+1.0i)+(num-test (- 1/1 1.0 0.0+1.0i) 0.0-1.0i)+(num-test (* 1/1 1.0 0.0+1.0i) 0.0+1.0i)+(num-test (/ 1/1 1.0 0.0+1.0i) 0.0-1.0i)+(num-test (= 1/1 1.0 0.0+1.0i) #f)+(num-test (+ 1/1 1/1 1) 3)+(num-test (- 1/1 1/1 1) -1)+(num-test (* 1/1 1/1 1) 1)+(num-test (/ 1/1 1/1 1) 1)+(num-test (= 1/1 1/1 1) #t)+(num-test (< 1/1 1/1 1) #f)+(num-test (<= 1/1 1/1 1) #t)+(num-test (> 1/1 1/1 1) #f)+(num-test (>= 1/1 1/1 1) #t)+(num-test (+ 1/1 1/1 1.0) 3.0)+(num-test (- 1/1 1/1 1.0) -1.0)+(num-test (* 1/1 1/1 1.0) 1.0)+(num-test (/ 1/1 1/1 1.0) 1.0)+(num-test (= 1/1 1/1 1.0) #t)+(num-test (< 1/1 1/1 1.0) #f)+(num-test (<= 1/1 1/1 1.0) #t)+(num-test (> 1/1 1/1 1.0) #f)+(num-test (>= 1/1 1/1 1.0) #t)+(num-test (+ 1/1 1/1 1/1) 3)+(num-test (- 1/1 1/1 1/1) -1)+(num-test (* 1/1 1/1 1/1) 1)+(num-test (/ 1/1 1/1 1/1) 1)+(num-test (= 1/1 1/1 1/1) #t)+(num-test (< 1/1 1/1 1/1) #f)+(num-test (<= 1/1 1/1 1/1) #t)+(num-test (> 1/1 1/1 1/1) #f)+(num-test (>= 1/1 1/1 1/1) #t)+(num-test (+ 1/1 1/1 1.0+1.0i) 3.0+1.0i)+(num-test (- 1/1 1/1 1.0+1.0i) -1.0-1.0i)+(num-test (* 1/1 1/1 1.0+1.0i) 1.0+1.0i)+(num-test (/ 1/1 1/1 1.0+1.0i) 0.5-0.5i)+(num-test (= 1/1 1/1 1.0+1.0i) #f)+(num-test (+ 1/1 1/1 0) 2)+(num-test (- 1/1 1/1 0) 0)+(num-test (* 1/1 1/1 0) 0)+(num-test (+ 1/1 1/1 0.0) 2.0)+(num-test (- 1/1 1/1 0.0) 0.0)+(num-test (* 1/1 1/1 0.0) 0.0)+(num-test (+ 1/1 1/1 1234) 1236)+(num-test (- 1/1 1/1 1234) -1234)+(num-test (* 1/1 1/1 1234) 1234)+(num-test (/ 1/1 1/1 1234) 1/1234)+(num-test (= 1/1 1/1 1234) #f)+(num-test (< 1/1 1/1 1234) #f)+(num-test (<= 1/1 1/1 1234) #t)+(num-test (> 1/1 1/1 1234) #f)+(num-test (>= 1/1 1/1 1234) #f)+(num-test (+ 1/1 1/1 123.4) 125.4)+(num-test (- 1/1 1/1 123.4) -123.4)+(num-test (* 1/1 1/1 123.4) 123.4)+(num-test (/ 1/1 1/1 123.4) 0.00810372771475)+(num-test (= 1/1 1/1 123.4) #f)+(num-test (< 1/1 1/1 123.4) #f)+(num-test (<= 1/1 1/1 123.4) #t)+(num-test (> 1/1 1/1 123.4) #f)+(num-test (>= 1/1 1/1 123.4) #f)+(num-test (+ 1/1 1/1 1234/11) 1256/11)+(num-test (- 1/1 1/1 1234/11) -1234/11)+(num-test (* 1/1 1/1 1234/11) 1234/11)+(num-test (/ 1/1 1/1 1234/11) 11/1234)+(num-test (= 1/1 1/1 1234/11) #f)+(num-test (< 1/1 1/1 1234/11) #f)+(num-test (<= 1/1 1/1 1234/11) #t)+(num-test (> 1/1 1/1 1234/11) #f)+(num-test (>= 1/1 1/1 1234/11) #f)+(num-test (+ 1/1 1/1 1.234+1.234i) 3.234+1.234i)+(num-test (- 1/1 1/1 1.234+1.234i) -1.234-1.234i)+(num-test (* 1/1 1/1 1.234+1.234i) 1.234+1.234i)+(num-test (/ 1/1 1/1 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1/1 1/1 1.234+1.234i) #f)+(num-test (+ 1/1 1/1 -1.0+1.0i) 1.0+1.0i)+(num-test (- 1/1 1/1 -1.0+1.0i) 1.0-1.0i)+(num-test (* 1/1 1/1 -1.0+1.0i) -1.0+1.0i)+(num-test (/ 1/1 1/1 -1.0+1.0i) -0.5-0.5i)+(num-test (= 1/1 1/1 -1.0+1.0i) #f)+(num-test (+ 1/1 1/1 0.0+1.0i) 2.0+1.0i)+(num-test (- 1/1 1/1 0.0+1.0i) 0.0-1.0i)+(num-test (* 1/1 1/1 0.0+1.0i) 0.0+1.0i)+(num-test (/ 1/1 1/1 0.0+1.0i) 0.0-1.0i)+(num-test (= 1/1 1/1 0.0+1.0i) #f)+(num-test (+ 1/1 1.0+1.0i 1) 3.0+1.0i)+(num-test (- 1/1 1.0+1.0i 1) -1.0-1.0i)+(num-test (* 1/1 1.0+1.0i 1) 1.0+1.0i)+(num-test (/ 1/1 1.0+1.0i 1) 0.5-0.5i)+(num-test (= 1/1 1.0+1.0i 1) #f)+(num-test (+ 1/1 1.0+1.0i 1.0) 3.0+1.0i)+(num-test (- 1/1 1.0+1.0i 1.0) -1.0-1.0i)+(num-test (* 1/1 1.0+1.0i 1.0) 1.0+1.0i)+(num-test (/ 1/1 1.0+1.0i 1.0) 0.5-0.5i)+(num-test (= 1/1 1.0+1.0i 1.0) #f)+(num-test (+ 1/1 1.0+1.0i 1/1) 3.0+1.0i)+(num-test (- 1/1 1.0+1.0i 1/1) -1.0-1.0i)+(num-test (* 1/1 1.0+1.0i 1/1) 1.0+1.0i)+(num-test (/ 1/1 1.0+1.0i 1/1) 0.5-0.5i)+(num-test (= 1/1 1.0+1.0i 1/1) #f)+(num-test (+ 1/1 1.0+1.0i 1.0+1.0i) 3.0+2.0i)+(num-test (- 1/1 1.0+1.0i 1.0+1.0i) -1.0-2.0i)+(num-test (* 1/1 1.0+1.0i 1.0+1.0i) 0.0+2.0i)+(num-test (/ 1/1 1.0+1.0i 1.0+1.0i) 0.0-0.5i)+(num-test (= 1/1 1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1/1 1.0+1.0i 0) 2.0+1.0i)+(num-test (- 1/1 1.0+1.0i 0) 0.0-1.0i)+(num-test (* 1/1 1.0+1.0i 0) 0.0)+(num-test (+ 1/1 1.0+1.0i 0.0) 2.0+1.0i)+(num-test (- 1/1 1.0+1.0i 0.0) 0.0-1.0i)+(num-test (* 1/1 1.0+1.0i 0.0) 0.0)+(num-test (+ 1/1 1.0+1.0i 1234) 1236.0+1.0i)+(num-test (- 1/1 1.0+1.0i 1234) -1234.0-1.0i)+(num-test (* 1/1 1.0+1.0i 1234) 1234.0+1234.0i)+(num-test (/ 1/1 1.0+1.0i 1234) 0.00040518638574-0.00040518638574i)+(num-test (= 1/1 1.0+1.0i 1234) #f)+(num-test (+ 1/1 1.0+1.0i 123.4) 125.4+1.0i)+(num-test (- 1/1 1.0+1.0i 123.4) -123.4-1.0i)+(num-test (* 1/1 1.0+1.0i 123.4) 123.4+123.4i)+(num-test (/ 1/1 1.0+1.0i 123.4) 0.00405186385737-0.00405186385737i)+(num-test (= 1/1 1.0+1.0i 123.4) #f)+(num-test (+ 1/1 1.0+1.0i 1234/11) 114.18181818181819+1.0i)+(num-test (- 1/1 1.0+1.0i 1234/11) -112.18181818181819-1.0i)+(num-test (* 1/1 1.0+1.0i 1234/11) 112.18181818181819+112.18181818181819i)+(num-test (/ 1/1 1.0+1.0i 1234/11) 0.00445705024311-0.00445705024311i)+(num-test (= 1/1 1.0+1.0i 1234/11) #f)+(num-test (+ 1/1 1.0+1.0i 1.234+1.234i) 3.234+2.234i)+(num-test (- 1/1 1.0+1.0i 1.234+1.234i) -1.234-2.234i)+(num-test (* 1/1 1.0+1.0i 1.234+1.234i) 0.0+2.468i)+(num-test (/ 1/1 1.0+1.0i 1.234+1.234i) 0.0-0.40518638573744i)+(num-test (= 1/1 1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1/1 1.0+1.0i -1.0+1.0i) 1.0+2.0i)+(num-test (- 1/1 1.0+1.0i -1.0+1.0i) 1.0-2.0i)+(num-test (* 1/1 1.0+1.0i -1.0+1.0i) -2.0)+(num-test (/ 1/1 1.0+1.0i -1.0+1.0i) -0.5)+(num-test (= 1/1 1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1/1 1.0+1.0i 0.0+1.0i) 2.0+2.0i)+(num-test (- 1/1 1.0+1.0i 0.0+1.0i) 0.0-2.0i)+(num-test (* 1/1 1.0+1.0i 0.0+1.0i) -1.0+1.0i)+(num-test (/ 1/1 1.0+1.0i 0.0+1.0i) -0.5-0.5i)+(num-test (= 1/1 1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1/1 0 1) 2)+(num-test (- 1/1 0 1) 0)+(num-test (* 1/1 0 1) 0)+(num-test (+ 1/1 0 1.0) 2.0)+(num-test (- 1/1 0 1.0) 0.0)+(num-test (* 1/1 0 1.0) 0.0)+(num-test (+ 1/1 0 1/1) 2)+(num-test (- 1/1 0 1/1) 0)+(num-test (* 1/1 0 1/1) 0)+(num-test (+ 1/1 0 1.0+1.0i) 2.0+1.0i)+(num-test (- 1/1 0 1.0+1.0i) 0.0-1.0i)+(num-test (* 1/1 0 1.0+1.0i) 0.0)+(num-test (+ 1/1 0 0) 1)+(num-test (- 1/1 0 0) 1)+(num-test (* 1/1 0 0) 0)+(num-test (+ 1/1 0 0.0) 1.0)+(num-test (- 1/1 0 0.0) 1.0)+(num-test (* 1/1 0 0.0) 0.0)+(num-test (+ 1/1 0 1234) 1235)+(num-test (- 1/1 0 1234) -1233)+(num-test (* 1/1 0 1234) 0)+(num-test (+ 1/1 0 123.4) 124.4)+(num-test (- 1/1 0 123.4) -122.4)+(num-test (* 1/1 0 123.4) 0.0)+(num-test (+ 1/1 0 1234/11) 1245/11)+(num-test (- 1/1 0 1234/11) -1223/11)+(num-test (* 1/1 0 1234/11) 0)+(num-test (+ 1/1 0 1.234+1.234i) 2.234+1.234i)+(num-test (- 1/1 0 1.234+1.234i) -0.234-1.234i)+(num-test (* 1/1 0 1.234+1.234i) 0.0)+(num-test (+ 1/1 0 -1.0+1.0i) 0.0+1.0i)+(num-test (- 1/1 0 -1.0+1.0i) 2.0-1.0i)+(num-test (* 1/1 0 -1.0+1.0i) -0.0)+(num-test (+ 1/1 0 0.0+1.0i) 1.0+1.0i)+(num-test (- 1/1 0 0.0+1.0i) 1.0-1.0i)+(num-test (* 1/1 0 0.0+1.0i) 0.0)+(num-test (+ 1/1 0.0 1) 2.0)+(num-test (- 1/1 0.0 1) 0.0)+(num-test (* 1/1 0.0 1) 0.0)+(num-test (+ 1/1 0.0 1.0) 2.0)+(num-test (- 1/1 0.0 1.0) 0.0)+(num-test (* 1/1 0.0 1.0) 0.0)+(num-test (+ 1/1 0.0 1/1) 2.0)+(num-test (- 1/1 0.0 1/1) 0.0)+(num-test (* 1/1 0.0 1/1) 0.0)+(num-test (+ 1/1 0.0 1.0+1.0i) 2.0+1.0i)+(num-test (- 1/1 0.0 1.0+1.0i) 0.0-1.0i)+(num-test (* 1/1 0.0 1.0+1.0i) 0.0)+(num-test (+ 1/1 0.0 0) 1.0)+(num-test (- 1/1 0.0 0) 1.0)+(num-test (* 1/1 0.0 0) 0.0)+(num-test (+ 1/1 0.0 0.0) 1.0)+(num-test (- 1/1 0.0 0.0) 1.0)+(num-test (* 1/1 0.0 0.0) 0.0)+(num-test (+ 1/1 0.0 1234) 1235.0)+(num-test (- 1/1 0.0 1234) -1233.0)+(num-test (* 1/1 0.0 1234) 0.0)+(num-test (+ 1/1 0.0 123.4) 124.4)+(num-test (- 1/1 0.0 123.4) -122.4)+(num-test (* 1/1 0.0 123.4) 0.0)+(num-test (+ 1/1 0.0 1234/11) 113.18181818181819)+(num-test (- 1/1 0.0 1234/11) -111.18181818181819)+(num-test (* 1/1 0.0 1234/11) 0.0)+(num-test (+ 1/1 0.0 1.234+1.234i) 2.234+1.234i)+(num-test (- 1/1 0.0 1.234+1.234i) -0.234-1.234i)+(num-test (* 1/1 0.0 1.234+1.234i) 0.0)+(num-test (+ 1/1 0.0 -1.0+1.0i) 0.0+1.0i)+(num-test (- 1/1 0.0 -1.0+1.0i) 2.0-1.0i)+(num-test (* 1/1 0.0 -1.0+1.0i) -0.0)+(num-test (+ 1/1 0.0 0.0+1.0i) 1.0+1.0i)+(num-test (- 1/1 0.0 0.0+1.0i) 1.0-1.0i)+(num-test (* 1/1 0.0 0.0+1.0i) 0.0)+(num-test (+ 1/1 1234 1) 1236)+(num-test (- 1/1 1234 1) -1234)+(num-test (* 1/1 1234 1) 1234)+(num-test (/ 1/1 1234 1) 1/1234)+(num-test (= 1/1 1234 1) #f)+(num-test (< 1/1 1234 1) #f)+(num-test (<= 1/1 1234 1) #f)+(num-test (> 1/1 1234 1) #f)+(num-test (>= 1/1 1234 1) #f)+(num-test (+ 1/1 1234 1.0) 1236.0)+(num-test (- 1/1 1234 1.0) -1234.0)+(num-test (* 1/1 1234 1.0) 1234.0)+(num-test (/ 1/1 1234 1.0) 0.00081037277147)+(num-test (= 1/1 1234 1.0) #f)+(num-test (< 1/1 1234 1.0) #f)+(num-test (<= 1/1 1234 1.0) #f)+(num-test (> 1/1 1234 1.0) #f)+(num-test (>= 1/1 1234 1.0) #f)+(num-test (+ 1/1 1234 1/1) 1236)+(num-test (- 1/1 1234 1/1) -1234)+(num-test (* 1/1 1234 1/1) 1234)+(num-test (/ 1/1 1234 1/1) 1/1234)+(num-test (= 1/1 1234 1/1) #f)+(num-test (< 1/1 1234 1/1) #f)+(num-test (<= 1/1 1234 1/1) #f)+(num-test (> 1/1 1234 1/1) #f)+(num-test (>= 1/1 1234 1/1) #f)+(num-test (+ 1/1 1234 1.0+1.0i) 1236.0+1.0i)+(num-test (- 1/1 1234 1.0+1.0i) -1234.0-1.0i)+(num-test (* 1/1 1234 1.0+1.0i) 1234.0+1234.0i)+(num-test (/ 1/1 1234 1.0+1.0i) 0.00040518638574-0.00040518638574i)+(num-test (= 1/1 1234 1.0+1.0i) #f)+(num-test (+ 1/1 1234 0) 1235)+(num-test (- 1/1 1234 0) -1233)+(num-test (* 1/1 1234 0) 0)+(num-test (+ 1/1 1234 0.0) 1235.0)+(num-test (- 1/1 1234 0.0) -1233.0)+(num-test (* 1/1 1234 0.0) 0.0)+(num-test (+ 1/1 1234 1234) 2469)+(num-test (- 1/1 1234 1234) -2467)+(num-test (* 1/1 1234 1234) 1522756)+(num-test (/ 1/1 1234 1234) 1/1522756)+(num-test (= 1/1 1234 1234) #f)+(num-test (< 1/1 1234 1234) #f)+(num-test (<= 1/1 1234 1234) #t)+(num-test (> 1/1 1234 1234) #f)+(num-test (>= 1/1 1234 1234) #f)+(num-test (+ 1/1 1234 123.4) 1358.4)+(num-test (- 1/1 1234 123.4) -1356.4)+(num-test (* 1/1 1234 123.4) 152275.60000000000582)+(num-test (/ 1/1 1234 123.4) 0.00000656704029)+(num-test (= 1/1 1234 123.4) #f)+(num-test (< 1/1 1234 123.4) #f)+(num-test (<= 1/1 1234 123.4) #f)+(num-test (> 1/1 1234 123.4) #f)+(num-test (>= 1/1 1234 123.4) #f)+(num-test (+ 1/1 1234 1234/11) 14819/11)+(num-test (- 1/1 1234 1234/11) -14797/11)+(num-test (* 1/1 1234 1234/11) 1522756/11)+(num-test (/ 1/1 1234 1234/11) 11/1522756)+(num-test (= 1/1 1234 1234/11) #f)+(num-test (< 1/1 1234 1234/11) #f)+(num-test (<= 1/1 1234 1234/11) #f)+(num-test (> 1/1 1234 1234/11) #f)+(num-test (>= 1/1 1234 1234/11) #f)+(num-test (+ 1/1 1234 1.234+1.234i) 1236.23399999999992+1.234i)+(num-test (- 1/1 1234 1.234+1.234i) -1234.23399999999992-1.234i)+(num-test (* 1/1 1234 1.234+1.234i) 1522.756+1522.756i)+(num-test (/ 1/1 1234 1.234+1.234i) 0.00032835201437-0.00032835201437i)+(num-test (= 1/1 1234 1.234+1.234i) #f)+(num-test (+ 1/1 1234 -1.0+1.0i) 1234.0+1.0i)+(num-test (- 1/1 1234 -1.0+1.0i) -1232.0-1.0i)+(num-test (* 1/1 1234 -1.0+1.0i) -1234.0+1234.0i)+(num-test (/ 1/1 1234 -1.0+1.0i) -0.00040518638574-0.00040518638574i)+(num-test (= 1/1 1234 -1.0+1.0i) #f)+(num-test (+ 1/1 1234 0.0+1.0i) 1235.0+1.0i)+(num-test (- 1/1 1234 0.0+1.0i) -1233.0-1.0i)+(num-test (* 1/1 1234 0.0+1.0i) 0.0+1234.0i)+(num-test (/ 1/1 1234 0.0+1.0i) 0.0-0.00081037277147i)+(num-test (= 1/1 1234 0.0+1.0i) #f)+(num-test (+ 1/1 123.4 1) 125.4)+(num-test (- 1/1 123.4 1) -123.4)+(num-test (* 1/1 123.4 1) 123.4)+(num-test (/ 1/1 123.4 1) 0.00810372771475)+(num-test (= 1/1 123.4 1) #f)+(num-test (< 1/1 123.4 1) #f)+(num-test (<= 1/1 123.4 1) #f)+(num-test (> 1/1 123.4 1) #f)+(num-test (>= 1/1 123.4 1) #f)+(num-test (+ 1/1 123.4 1.0) 125.4)+(num-test (- 1/1 123.4 1.0) -123.4)+(num-test (* 1/1 123.4 1.0) 123.4)+(num-test (/ 1/1 123.4 1.0) 0.00810372771475)+(num-test (= 1/1 123.4 1.0) #f)+(num-test (< 1/1 123.4 1.0) #f)+(num-test (<= 1/1 123.4 1.0) #f)+(num-test (> 1/1 123.4 1.0) #f)+(num-test (>= 1/1 123.4 1.0) #f)+(num-test (+ 1/1 123.4 1/1) 125.4)+(num-test (- 1/1 123.4 1/1) -123.4)+(num-test (* 1/1 123.4 1/1) 123.4)+(num-test (/ 1/1 123.4 1/1) 0.00810372771475)+(num-test (= 1/1 123.4 1/1) #f)+(num-test (< 1/1 123.4 1/1) #f)+(num-test (<= 1/1 123.4 1/1) #f)+(num-test (> 1/1 123.4 1/1) #f)+(num-test (>= 1/1 123.4 1/1) #f)+(num-test (+ 1/1 123.4 1.0+1.0i) 125.4+1.0i)+(num-test (- 1/1 123.4 1.0+1.0i) -123.4-1.0i)+(num-test (* 1/1 123.4 1.0+1.0i) 123.4+123.4i)+(num-test (/ 1/1 123.4 1.0+1.0i) 0.00405186385737-0.00405186385737i)+(num-test (= 1/1 123.4 1.0+1.0i) #f)+(num-test (+ 1/1 123.4 0) 124.4)+(num-test (- 1/1 123.4 0) -122.4)+(num-test (* 1/1 123.4 0) 0.0)+(num-test (+ 1/1 123.4 0.0) 124.4)+(num-test (- 1/1 123.4 0.0) -122.4)+(num-test (* 1/1 123.4 0.0) 0.0)+(num-test (+ 1/1 123.4 1234) 1358.4)+(num-test (- 1/1 123.4 1234) -1356.4)+(num-test (* 1/1 123.4 1234) 152275.60000000000582)+(num-test (/ 1/1 123.4 1234) 0.00000656704029)+(num-test (= 1/1 123.4 1234) #f)+(num-test (< 1/1 123.4 1234) #t)+(num-test (<= 1/1 123.4 1234) #t)+(num-test (> 1/1 123.4 1234) #f)+(num-test (>= 1/1 123.4 1234) #f)+(num-test (+ 1/1 123.4 123.4) 247.8)+(num-test (- 1/1 123.4 123.4) -245.8)+(num-test (* 1/1 123.4 123.4) 15227.56000000000131)+(num-test (/ 1/1 123.4 123.4) 0.00006567040287)+(num-test (= 1/1 123.4 123.4) #f)+(num-test (< 1/1 123.4 123.4) #f)+(num-test (<= 1/1 123.4 123.4) #t)+(num-test (> 1/1 123.4 123.4) #f)+(num-test (>= 1/1 123.4 123.4) #f)+(num-test (+ 1/1 123.4 1234/11) 236.58181818181819)+(num-test (- 1/1 123.4 1234/11) -234.58181818181819)+(num-test (* 1/1 123.4 1234/11) 13843.23636363636433)+(num-test (/ 1/1 123.4 1234/11) 0.00007223744316)+(num-test (= 1/1 123.4 1234/11) #f)+(num-test (< 1/1 123.4 1234/11) #f)+(num-test (<= 1/1 123.4 1234/11) #f)+(num-test (> 1/1 123.4 1234/11) #f)+(num-test (>= 1/1 123.4 1234/11) #f)+(num-test (+ 1/1 123.4 1.234+1.234i) 125.634+1.234i)+(num-test (- 1/1 123.4 1.234+1.234i) -123.634-1.234i)+(num-test (* 1/1 123.4 1.234+1.234i) 152.2756+152.2756i)+(num-test (/ 1/1 123.4 1.234+1.234i) 0.00328352014374-0.00328352014374i)+(num-test (= 1/1 123.4 1.234+1.234i) #f)+(num-test (+ 1/1 123.4 -1.0+1.0i) 123.4+1.0i)+(num-test (- 1/1 123.4 -1.0+1.0i) -121.4-1.0i)+(num-test (* 1/1 123.4 -1.0+1.0i) -123.4+123.4i)+(num-test (/ 1/1 123.4 -1.0+1.0i) -0.00405186385737-0.00405186385737i)+(num-test (= 1/1 123.4 -1.0+1.0i) #f)+(num-test (+ 1/1 123.4 0.0+1.0i) 124.4+1.0i)+(num-test (- 1/1 123.4 0.0+1.0i) -122.4-1.0i)+(num-test (* 1/1 123.4 0.0+1.0i) 0.0+123.4i)+(num-test (/ 1/1 123.4 0.0+1.0i) 0.0-0.00810372771475i)+(num-test (= 1/1 123.4 0.0+1.0i) #f)+(num-test (+ 1/1 1234/11 1) 1256/11)+(num-test (- 1/1 1234/11 1) -1234/11)+(num-test (* 1/1 1234/11 1) 1234/11)+(num-test (/ 1/1 1234/11 1) 11/1234)+(num-test (= 1/1 1234/11 1) #f)+(num-test (< 1/1 1234/11 1) #f)+(num-test (<= 1/1 1234/11 1) #f)+(num-test (> 1/1 1234/11 1) #f)+(num-test (>= 1/1 1234/11 1) #f)+(num-test (+ 1/1 1234/11 1.0) 114.18181818181819)+(num-test (- 1/1 1234/11 1.0) -112.18181818181819)+(num-test (* 1/1 1234/11 1.0) 112.18181818181819)+(num-test (/ 1/1 1234/11 1.0) 0.00891410048622)+(num-test (= 1/1 1234/11 1.0) #f)+(num-test (< 1/1 1234/11 1.0) #f)+(num-test (<= 1/1 1234/11 1.0) #f)+(num-test (> 1/1 1234/11 1.0) #f)+(num-test (>= 1/1 1234/11 1.0) #f)+(num-test (+ 1/1 1234/11 1/1) 1256/11)+(num-test (- 1/1 1234/11 1/1) -1234/11)+(num-test (* 1/1 1234/11 1/1) 1234/11)+(num-test (/ 1/1 1234/11 1/1) 11/1234)+(num-test (= 1/1 1234/11 1/1) #f)+(num-test (< 1/1 1234/11 1/1) #f)+(num-test (<= 1/1 1234/11 1/1) #f)+(num-test (> 1/1 1234/11 1/1) #f)+(num-test (>= 1/1 1234/11 1/1) #f)+(num-test (+ 1/1 1234/11 1.0+1.0i) 114.18181818181819+1.0i)+(num-test (- 1/1 1234/11 1.0+1.0i) -112.18181818181819-1.0i)+(num-test (* 1/1 1234/11 1.0+1.0i) 112.18181818181819+112.18181818181819i)+(num-test (/ 1/1 1234/11 1.0+1.0i) 0.00445705024311-0.00445705024311i)+(num-test (= 1/1 1234/11 1.0+1.0i) #f)+(num-test (+ 1/1 1234/11 0) 1245/11)+(num-test (- 1/1 1234/11 0) -1223/11)+(num-test (* 1/1 1234/11 0) 0)+(num-test (+ 1/1 1234/11 0.0) 113.18181818181819)+(num-test (- 1/1 1234/11 0.0) -111.18181818181819)+(num-test (* 1/1 1234/11 0.0) 0.0)+(num-test (+ 1/1 1234/11 1234) 14819/11)+(num-test (- 1/1 1234/11 1234) -14797/11)+(num-test (* 1/1 1234/11 1234) 1522756/11)+(num-test (/ 1/1 1234/11 1234) 11/1522756)+(num-test (= 1/1 1234/11 1234) #f)+(num-test (< 1/1 1234/11 1234) #t)+(num-test (<= 1/1 1234/11 1234) #t)+(num-test (> 1/1 1234/11 1234) #f)+(num-test (>= 1/1 1234/11 1234) #f)+(num-test (+ 1/1 1234/11 123.4) 236.58181818181819)+(num-test (- 1/1 1234/11 123.4) -234.58181818181819)+(num-test (* 1/1 1234/11 123.4) 13843.23636363636433)+(num-test (/ 1/1 1234/11 123.4) 0.00007223744316)+(num-test (= 1/1 1234/11 123.4) #f)+(num-test (< 1/1 1234/11 123.4) #t)+(num-test (<= 1/1 1234/11 123.4) #t)+(num-test (> 1/1 1234/11 123.4) #f)+(num-test (>= 1/1 1234/11 123.4) #f)+(num-test (+ 1/1 1234/11 1234/11) 2479/11)+(num-test (- 1/1 1234/11 1234/11) -2457/11)+(num-test (* 1/1 1234/11 1234/11) 1522756/121)+(num-test (/ 1/1 1234/11 1234/11) 121/1522756)+(num-test (= 1/1 1234/11 1234/11) #f)+(num-test (< 1/1 1234/11 1234/11) #f)+(num-test (<= 1/1 1234/11 1234/11) #t)+(num-test (> 1/1 1234/11 1234/11) #f)+(num-test (>= 1/1 1234/11 1234/11) #f)+(num-test (+ 1/1 1234/11 1.234+1.234i) 114.41581818181818+1.234i)+(num-test (- 1/1 1234/11 1.234+1.234i) -112.41581818181818-1.234i)+(num-test (* 1/1 1234/11 1.234+1.234i) 138.43236363636365+138.43236363636365i)+(num-test (/ 1/1 1234/11 1.234+1.234i) 0.00361187215811-0.00361187215811i)+(num-test (= 1/1 1234/11 1.234+1.234i) #f)+(num-test (+ 1/1 1234/11 -1.0+1.0i) 112.18181818181819+1.0i)+(num-test (- 1/1 1234/11 -1.0+1.0i) -110.18181818181819-1.0i)+(num-test (* 1/1 1234/11 -1.0+1.0i) -112.18181818181819+112.18181818181819i)+(num-test (/ 1/1 1234/11 -1.0+1.0i) -0.00445705024311-0.00445705024311i)+(num-test (= 1/1 1234/11 -1.0+1.0i) #f)+(num-test (+ 1/1 1234/11 0.0+1.0i) 113.18181818181819+1.0i)+(num-test (- 1/1 1234/11 0.0+1.0i) -111.18181818181819-1.0i)+(num-test (* 1/1 1234/11 0.0+1.0i) 0.0+112.18181818181819i)+(num-test (/ 1/1 1234/11 0.0+1.0i) 0.0-0.00891410048622i)+(num-test (= 1/1 1234/11 0.0+1.0i) #f)+(num-test (+ 1/1 1.234+1.234i 1) 3.234+1.234i)+(num-test (- 1/1 1.234+1.234i 1) -1.234-1.234i)+(num-test (* 1/1 1.234+1.234i 1) 1.234+1.234i)+(num-test (/ 1/1 1.234+1.234i 1) 0.40518638573744-0.40518638573744i)+(num-test (= 1/1 1.234+1.234i 1) #f)+(num-test (+ 1/1 1.234+1.234i 1.0) 3.234+1.234i)+(num-test (- 1/1 1.234+1.234i 1.0) -1.234-1.234i)+(num-test (* 1/1 1.234+1.234i 1.0) 1.234+1.234i)+(num-test (/ 1/1 1.234+1.234i 1.0) 0.40518638573744-0.40518638573744i)+(num-test (= 1/1 1.234+1.234i 1.0) #f)+(num-test (+ 1/1 1.234+1.234i 1/1) 3.234+1.234i)+(num-test (- 1/1 1.234+1.234i 1/1) -1.234-1.234i)+(num-test (* 1/1 1.234+1.234i 1/1) 1.234+1.234i)+(num-test (/ 1/1 1.234+1.234i 1/1) 0.40518638573744-0.40518638573744i)+(num-test (= 1/1 1.234+1.234i 1/1) #f)+(num-test (+ 1/1 1.234+1.234i 1.0+1.0i) 3.234+2.234i)+(num-test (- 1/1 1.234+1.234i 1.0+1.0i) -1.234-2.234i)+(num-test (* 1/1 1.234+1.234i 1.0+1.0i) 0.0+2.468i)+(num-test (/ 1/1 1.234+1.234i 1.0+1.0i) 0.0-0.40518638573744i)+(num-test (= 1/1 1.234+1.234i 1.0+1.0i) #f)+(num-test (+ 1/1 1.234+1.234i 0) 2.234+1.234i)+(num-test (- 1/1 1.234+1.234i 0) -0.234-1.234i)+(num-test (* 1/1 1.234+1.234i 0) 0.0)+(num-test (+ 1/1 1.234+1.234i 0.0) 2.234+1.234i)+(num-test (- 1/1 1.234+1.234i 0.0) -0.234-1.234i)+(num-test (* 1/1 1.234+1.234i 0.0) 0.0)+(num-test (+ 1/1 1.234+1.234i 1234) 1236.23399999999992+1.234i)+(num-test (- 1/1 1.234+1.234i 1234) -1234.23399999999992-1.234i)+(num-test (* 1/1 1.234+1.234i 1234) 1522.756+1522.756i)+(num-test (/ 1/1 1.234+1.234i 1234) 0.00032835201437-0.00032835201437i)+(num-test (= 1/1 1.234+1.234i 1234) #f)+(num-test (+ 1/1 1.234+1.234i 123.4) 125.634+1.234i)+(num-test (- 1/1 1.234+1.234i 123.4) -123.634-1.234i)+(num-test (* 1/1 1.234+1.234i 123.4) 152.2756+152.2756i)+(num-test (/ 1/1 1.234+1.234i 123.4) 0.00328352014374-0.00328352014374i)+(num-test (= 1/1 1.234+1.234i 123.4) #f)+(num-test (+ 1/1 1.234+1.234i 1234/11) 114.41581818181818+1.234i)+(num-test (- 1/1 1.234+1.234i 1234/11) -112.41581818181818-1.234i)+(num-test (* 1/1 1.234+1.234i 1234/11) 138.43236363636365+138.43236363636365i)+(num-test (/ 1/1 1.234+1.234i 1234/11) 0.00361187215811-0.00361187215811i)+(num-test (= 1/1 1.234+1.234i 1234/11) #f)+(num-test (+ 1/1 1.234+1.234i 1.234+1.234i) 3.468+2.468i)+(num-test (- 1/1 1.234+1.234i 1.234+1.234i) -1.468-2.468i)+(num-test (* 1/1 1.234+1.234i 1.234+1.234i) 0.0+3.04551200000000i)+(num-test (/ 1/1 1.234+1.234i 1.234+1.234i) 0.0-0.32835201437394i)+(num-test (= 1/1 1.234+1.234i 1.234+1.234i) #f)+(num-test (+ 1/1 1.234+1.234i -1.0+1.0i) 1.234+2.234i)+(num-test (- 1/1 1.234+1.234i -1.0+1.0i) 0.766-2.234i)+(num-test (* 1/1 1.234+1.234i -1.0+1.0i) -2.468)+(num-test (/ 1/1 1.234+1.234i -1.0+1.0i) -0.40518638573744)+(num-test (= 1/1 1.234+1.234i -1.0+1.0i) #f)+(num-test (+ 1/1 1.234+1.234i 0.0+1.0i) 2.234+2.234i)+(num-test (- 1/1 1.234+1.234i 0.0+1.0i) -0.234-2.234i)+(num-test (* 1/1 1.234+1.234i 0.0+1.0i) -1.234+1.234i)+(num-test (/ 1/1 1.234+1.234i 0.0+1.0i) -0.40518638573744-0.40518638573744i)+(num-test (= 1/1 1.234+1.234i 0.0+1.0i) #f)+(num-test (+ 1/1 -1.0+1.0i 1) 1.0+1.0i)+(num-test (- 1/1 -1.0+1.0i 1) 1.0-1.0i)+(num-test (* 1/1 -1.0+1.0i 1) -1.0+1.0i)+(num-test (/ 1/1 -1.0+1.0i 1) -0.5-0.5i)+(num-test (= 1/1 -1.0+1.0i 1) #f)+(num-test (+ 1/1 -1.0+1.0i 1.0) 1.0+1.0i)+(num-test (- 1/1 -1.0+1.0i 1.0) 1.0-1.0i)+(num-test (* 1/1 -1.0+1.0i 1.0) -1.0+1.0i)+(num-test (/ 1/1 -1.0+1.0i 1.0) -0.5-0.5i)+(num-test (= 1/1 -1.0+1.0i 1.0) #f)+(num-test (+ 1/1 -1.0+1.0i 1/1) 1.0+1.0i)+(num-test (- 1/1 -1.0+1.0i 1/1) 1.0-1.0i)+(num-test (* 1/1 -1.0+1.0i 1/1) -1.0+1.0i)+(num-test (/ 1/1 -1.0+1.0i 1/1) -0.5-0.5i)+(num-test (= 1/1 -1.0+1.0i 1/1) #f)+(num-test (+ 1/1 -1.0+1.0i 1.0+1.0i) 1.0+2.0i)+(num-test (- 1/1 -1.0+1.0i 1.0+1.0i) 1.0-2.0i)+(num-test (* 1/1 -1.0+1.0i 1.0+1.0i) -2.0)+(num-test (/ 1/1 -1.0+1.0i 1.0+1.0i) -0.5)+(num-test (= 1/1 -1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1/1 -1.0+1.0i 0) 0.0+1.0i)+(num-test (- 1/1 -1.0+1.0i 0) 2.0-1.0i)+(num-test (* 1/1 -1.0+1.0i 0) -0.0)+(num-test (+ 1/1 -1.0+1.0i 0.0) 0.0+1.0i)+(num-test (- 1/1 -1.0+1.0i 0.0) 2.0-1.0i)+(num-test (* 1/1 -1.0+1.0i 0.0) -0.0)+(num-test (+ 1/1 -1.0+1.0i 1234) 1234.0+1.0i)+(num-test (- 1/1 -1.0+1.0i 1234) -1232.0-1.0i)+(num-test (* 1/1 -1.0+1.0i 1234) -1234.0+1234.0i)+(num-test (/ 1/1 -1.0+1.0i 1234) -0.00040518638574-0.00040518638574i)+(num-test (= 1/1 -1.0+1.0i 1234) #f)+(num-test (+ 1/1 -1.0+1.0i 123.4) 123.4+1.0i)+(num-test (- 1/1 -1.0+1.0i 123.4) -121.4-1.0i)+(num-test (* 1/1 -1.0+1.0i 123.4) -123.4+123.4i)+(num-test (/ 1/1 -1.0+1.0i 123.4) -0.00405186385737-0.00405186385737i)+(num-test (= 1/1 -1.0+1.0i 123.4) #f)+(num-test (+ 1/1 -1.0+1.0i 1234/11) 112.18181818181819+1.0i)+(num-test (- 1/1 -1.0+1.0i 1234/11) -110.18181818181819-1.0i)+(num-test (* 1/1 -1.0+1.0i 1234/11) -112.18181818181819+112.18181818181819i)+(num-test (/ 1/1 -1.0+1.0i 1234/11) -0.00445705024311-0.00445705024311i)+(num-test (= 1/1 -1.0+1.0i 1234/11) #f)+(num-test (+ 1/1 -1.0+1.0i 1.234+1.234i) 1.234+2.234i)+(num-test (- 1/1 -1.0+1.0i 1.234+1.234i) 0.766-2.234i)+(num-test (* 1/1 -1.0+1.0i 1.234+1.234i) -2.468)+(num-test (/ 1/1 -1.0+1.0i 1.234+1.234i) -0.40518638573744)+(num-test (= 1/1 -1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1/1 -1.0+1.0i -1.0+1.0i) -1.0+2.0i)+(num-test (- 1/1 -1.0+1.0i -1.0+1.0i) 3.0-2.0i)+(num-test (* 1/1 -1.0+1.0i -1.0+1.0i) 0.0-2.0i)+(num-test (/ 1/1 -1.0+1.0i -1.0+1.0i) -0.0+0.5i)+(num-test (= 1/1 -1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1/1 -1.0+1.0i 0.0+1.0i) 0.0+2.0i)+(num-test (- 1/1 -1.0+1.0i 0.0+1.0i) 2.0-2.0i)+(num-test (* 1/1 -1.0+1.0i 0.0+1.0i) -1.0-1.0i)+(num-test (/ 1/1 -1.0+1.0i 0.0+1.0i) -0.5+0.5i)+(num-test (= 1/1 -1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1/1 0.0+1.0i 1) 2.0+1.0i)+(num-test (- 1/1 0.0+1.0i 1) 0.0-1.0i)+(num-test (* 1/1 0.0+1.0i 1) 0.0+1.0i)+(num-test (/ 1/1 0.0+1.0i 1) 0.0-1.0i)+(num-test (= 1/1 0.0+1.0i 1) #f)+(num-test (+ 1/1 0.0+1.0i 1.0) 2.0+1.0i)+(num-test (- 1/1 0.0+1.0i 1.0) 0.0-1.0i)+(num-test (* 1/1 0.0+1.0i 1.0) 0.0+1.0i)+(num-test (/ 1/1 0.0+1.0i 1.0) 0.0-1.0i)+(num-test (= 1/1 0.0+1.0i 1.0) #f)+(num-test (+ 1/1 0.0+1.0i 1/1) 2.0+1.0i)+(num-test (- 1/1 0.0+1.0i 1/1) 0.0-1.0i)+(num-test (* 1/1 0.0+1.0i 1/1) 0.0+1.0i)+(num-test (/ 1/1 0.0+1.0i 1/1) 0.0-1.0i)+(num-test (= 1/1 0.0+1.0i 1/1) #f)+(num-test (+ 1/1 0.0+1.0i 1.0+1.0i) 2.0+2.0i)+(num-test (- 1/1 0.0+1.0i 1.0+1.0i) 0.0-2.0i)+(num-test (* 1/1 0.0+1.0i 1.0+1.0i) -1.0+1.0i)+(num-test (/ 1/1 0.0+1.0i 1.0+1.0i) -0.5-0.5i)+(num-test (= 1/1 0.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1/1 0.0+1.0i 0) 1.0+1.0i)+(num-test (- 1/1 0.0+1.0i 0) 1.0-1.0i)+(num-test (* 1/1 0.0+1.0i 0) 0.0)+(num-test (+ 1/1 0.0+1.0i 0.0) 1.0+1.0i)+(num-test (- 1/1 0.0+1.0i 0.0) 1.0-1.0i)+(num-test (* 1/1 0.0+1.0i 0.0) 0.0)+(num-test (+ 1/1 0.0+1.0i 1234) 1235.0+1.0i)+(num-test (- 1/1 0.0+1.0i 1234) -1233.0-1.0i)+(num-test (* 1/1 0.0+1.0i 1234) 0.0+1234.0i)+(num-test (/ 1/1 0.0+1.0i 1234) 0.0-0.00081037277147i)+(num-test (= 1/1 0.0+1.0i 1234) #f)+(num-test (+ 1/1 0.0+1.0i 123.4) 124.4+1.0i)+(num-test (- 1/1 0.0+1.0i 123.4) -122.4-1.0i)+(num-test (* 1/1 0.0+1.0i 123.4) 0.0+123.4i)+(num-test (/ 1/1 0.0+1.0i 123.4) 0.0-0.00810372771475i)+(num-test (= 1/1 0.0+1.0i 123.4) #f)+(num-test (+ 1/1 0.0+1.0i 1234/11) 113.18181818181819+1.0i)+(num-test (- 1/1 0.0+1.0i 1234/11) -111.18181818181819-1.0i)+(num-test (* 1/1 0.0+1.0i 1234/11) 0.0+112.18181818181819i)+(num-test (/ 1/1 0.0+1.0i 1234/11) 0.0-0.00891410048622i)+(num-test (= 1/1 0.0+1.0i 1234/11) #f)+(num-test (+ 1/1 0.0+1.0i 1.234+1.234i) 2.234+2.234i)+(num-test (- 1/1 0.0+1.0i 1.234+1.234i) -0.234-2.234i)+(num-test (* 1/1 0.0+1.0i 1.234+1.234i) -1.234+1.234i)+(num-test (/ 1/1 0.0+1.0i 1.234+1.234i) -0.40518638573744-0.40518638573744i)+(num-test (= 1/1 0.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1/1 0.0+1.0i -1.0+1.0i) 0.0+2.0i)+(num-test (- 1/1 0.0+1.0i -1.0+1.0i) 2.0-2.0i)+(num-test (* 1/1 0.0+1.0i -1.0+1.0i) -1.0-1.0i)+(num-test (/ 1/1 0.0+1.0i -1.0+1.0i) -0.5+0.5i)+(num-test (= 1/1 0.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1/1 0.0+1.0i 0.0+1.0i) 1.0+2.0i)+(num-test (- 1/1 0.0+1.0i 0.0+1.0i) 1.0-2.0i)+(num-test (* 1/1 0.0+1.0i 0.0+1.0i) -1.0)+(num-test (/ 1/1 0.0+1.0i 0.0+1.0i) -1.0)+(num-test (= 1/1 0.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1 1) 3.0+1.0i)+(num-test (- 1.0+1.0i 1 1) -1.0+1.0i)+(num-test (* 1.0+1.0i 1 1) 1.0+1.0i)+(num-test (/ 1.0+1.0i 1 1) 1.0+1.0i)+(num-test (= 1.0+1.0i 1 1) #f)+(num-test (+ 1.0+1.0i 1 1.0) 3.0+1.0i)+(num-test (- 1.0+1.0i 1 1.0) -1.0+1.0i)+(num-test (* 1.0+1.0i 1 1.0) 1.0+1.0i)+(num-test (/ 1.0+1.0i 1 1.0) 1.0+1.0i)+(num-test (= 1.0+1.0i 1 1.0) #f)+(num-test (+ 1.0+1.0i 1 1/1) 3.0+1.0i)+(num-test (- 1.0+1.0i 1 1/1) -1.0+1.0i)+(num-test (* 1.0+1.0i 1 1/1) 1.0+1.0i)+(num-test (/ 1.0+1.0i 1 1/1) 1.0+1.0i)+(num-test (= 1.0+1.0i 1 1/1) #f)+(num-test (+ 1.0+1.0i 1 1.0+1.0i) 3.0+2.0i)+(num-test (- 1.0+1.0i 1 1.0+1.0i) -1.0)+(num-test (* 1.0+1.0i 1 1.0+1.0i) 0.0+2.0i)+(num-test (/ 1.0+1.0i 1 1.0+1.0i) 1.0)+(num-test (= 1.0+1.0i 1 1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1 0) 2.0+1.0i)+(num-test (- 1.0+1.0i 1 0) 0.0+1.0i)+(num-test (* 1.0+1.0i 1 0) 0.0)+(num-test (+ 1.0+1.0i 1 0.0) 2.0+1.0i)+(num-test (- 1.0+1.0i 1 0.0) 0.0+1.0i)+(num-test (* 1.0+1.0i 1 0.0) 0.0)+(num-test (+ 1.0+1.0i 1 1234) 1236.0+1.0i)+(num-test (- 1.0+1.0i 1 1234) -1234.0+1.0i)+(num-test (* 1.0+1.0i 1 1234) 1234.0+1234.0i)+(num-test (/ 1.0+1.0i 1 1234) 0.00081037277147+0.00081037277147i)+(num-test (= 1.0+1.0i 1 1234) #f)+(num-test (+ 1.0+1.0i 1 123.4) 125.4+1.0i)+(num-test (- 1.0+1.0i 1 123.4) -123.4+1.0i)+(num-test (* 1.0+1.0i 1 123.4) 123.4+123.4i)+(num-test (/ 1.0+1.0i 1 123.4) 0.00810372771475+0.00810372771475i)+(num-test (= 1.0+1.0i 1 123.4) #f)+(num-test (+ 1.0+1.0i 1 1234/11) 114.18181818181819+1.0i)+(num-test (- 1.0+1.0i 1 1234/11) -112.18181818181819+1.0i)+(num-test (* 1.0+1.0i 1 1234/11) 112.18181818181819+112.18181818181819i)+(num-test (/ 1.0+1.0i 1 1234/11) 0.00891410048622+0.00891410048622i)+(num-test (= 1.0+1.0i 1 1234/11) #f)+(num-test (+ 1.0+1.0i 1 1.234+1.234i) 3.234+2.234i)+(num-test (- 1.0+1.0i 1 1.234+1.234i) -1.234-0.234i)+(num-test (* 1.0+1.0i 1 1.234+1.234i) 0.0+2.468i)+(num-test (/ 1.0+1.0i 1 1.234+1.234i) 0.81037277147488)+(num-test (= 1.0+1.0i 1 1.234+1.234i) #f)+(num-test (+ 1.0+1.0i 1 -1.0+1.0i) 1.0+2.0i)+(num-test (- 1.0+1.0i 1 -1.0+1.0i) 1.0)+(num-test (* 1.0+1.0i 1 -1.0+1.0i) -2.0)+(num-test (/ 1.0+1.0i 1 -1.0+1.0i) -0.0-1.0i)+(num-test (= 1.0+1.0i 1 -1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1 0.0+1.0i) 2.0+2.0i)+(num-test (- 1.0+1.0i 1 0.0+1.0i) 0.0)+(num-test (* 1.0+1.0i 1 0.0+1.0i) -1.0+1.0i)+(num-test (/ 1.0+1.0i 1 0.0+1.0i) 1.0-1.0i)+(num-test (= 1.0+1.0i 1 0.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1.0 1) 3.0+1.0i)+(num-test (- 1.0+1.0i 1.0 1) -1.0+1.0i)+(num-test (* 1.0+1.0i 1.0 1) 1.0+1.0i)+(num-test (/ 1.0+1.0i 1.0 1) 1.0+1.0i)+(num-test (= 1.0+1.0i 1.0 1) #f)+(num-test (+ 1.0+1.0i 1.0 1.0) 3.0+1.0i)+(num-test (- 1.0+1.0i 1.0 1.0) -1.0+1.0i)+(num-test (* 1.0+1.0i 1.0 1.0) 1.0+1.0i)+(num-test (/ 1.0+1.0i 1.0 1.0) 1.0+1.0i)+(num-test (= 1.0+1.0i 1.0 1.0) #f)+(num-test (+ 1.0+1.0i 1.0 1/1) 3.0+1.0i)+(num-test (- 1.0+1.0i 1.0 1/1) -1.0+1.0i)+(num-test (* 1.0+1.0i 1.0 1/1) 1.0+1.0i)+(num-test (/ 1.0+1.0i 1.0 1/1) 1.0+1.0i)+(num-test (= 1.0+1.0i 1.0 1/1) #f)+(num-test (+ 1.0+1.0i 1.0 1.0+1.0i) 3.0+2.0i)+(num-test (- 1.0+1.0i 1.0 1.0+1.0i) -1.0)+(num-test (* 1.0+1.0i 1.0 1.0+1.0i) 0.0+2.0i)+(num-test (/ 1.0+1.0i 1.0 1.0+1.0i) 1.0)+(num-test (= 1.0+1.0i 1.0 1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1.0 0) 2.0+1.0i)+(num-test (- 1.0+1.0i 1.0 0) 0.0+1.0i)+(num-test (* 1.0+1.0i 1.0 0) 0.0)+(num-test (+ 1.0+1.0i 1.0 0.0) 2.0+1.0i)+(num-test (- 1.0+1.0i 1.0 0.0) 0.0+1.0i)+(num-test (* 1.0+1.0i 1.0 0.0) 0.0)+(num-test (+ 1.0+1.0i 1.0 1234) 1236.0+1.0i)+(num-test (- 1.0+1.0i 1.0 1234) -1234.0+1.0i)+(num-test (* 1.0+1.0i 1.0 1234) 1234.0+1234.0i)+(num-test (/ 1.0+1.0i 1.0 1234) 0.00081037277147+0.00081037277147i)+(num-test (= 1.0+1.0i 1.0 1234) #f)+(num-test (+ 1.0+1.0i 1.0 123.4) 125.4+1.0i)+(num-test (- 1.0+1.0i 1.0 123.4) -123.4+1.0i)+(num-test (* 1.0+1.0i 1.0 123.4) 123.4+123.4i)+(num-test (/ 1.0+1.0i 1.0 123.4) 0.00810372771475+0.00810372771475i)+(num-test (= 1.0+1.0i 1.0 123.4) #f)+(num-test (+ 1.0+1.0i 1.0 1234/11) 114.18181818181819+1.0i)+(num-test (- 1.0+1.0i 1.0 1234/11) -112.18181818181819+1.0i)+(num-test (* 1.0+1.0i 1.0 1234/11) 112.18181818181819+112.18181818181819i)+(num-test (/ 1.0+1.0i 1.0 1234/11) 0.00891410048622+0.00891410048622i)+(num-test (= 1.0+1.0i 1.0 1234/11) #f)+(num-test (+ 1.0+1.0i 1.0 1.234+1.234i) 3.234+2.234i)+(num-test (- 1.0+1.0i 1.0 1.234+1.234i) -1.234-0.234i)+(num-test (* 1.0+1.0i 1.0 1.234+1.234i) 0.0+2.468i)+(num-test (/ 1.0+1.0i 1.0 1.234+1.234i) 0.81037277147488)+(num-test (= 1.0+1.0i 1.0 1.234+1.234i) #f)+(num-test (+ 1.0+1.0i 1.0 -1.0+1.0i) 1.0+2.0i)+(num-test (- 1.0+1.0i 1.0 -1.0+1.0i) 1.0)+(num-test (* 1.0+1.0i 1.0 -1.0+1.0i) -2.0)+(num-test (/ 1.0+1.0i 1.0 -1.0+1.0i) -0.0-1.0i)+(num-test (= 1.0+1.0i 1.0 -1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1.0 0.0+1.0i) 2.0+2.0i)+(num-test (- 1.0+1.0i 1.0 0.0+1.0i) 0.0)+(num-test (* 1.0+1.0i 1.0 0.0+1.0i) -1.0+1.0i)+(num-test (/ 1.0+1.0i 1.0 0.0+1.0i) 1.0-1.0i)+(num-test (= 1.0+1.0i 1.0 0.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1/1 1) 3.0+1.0i)+(num-test (- 1.0+1.0i 1/1 1) -1.0+1.0i)+(num-test (* 1.0+1.0i 1/1 1) 1.0+1.0i)+(num-test (/ 1.0+1.0i 1/1 1) 1.0+1.0i)+(num-test (= 1.0+1.0i 1/1 1) #f)+(num-test (+ 1.0+1.0i 1/1 1.0) 3.0+1.0i)+(num-test (- 1.0+1.0i 1/1 1.0) -1.0+1.0i)+(num-test (* 1.0+1.0i 1/1 1.0) 1.0+1.0i)+(num-test (/ 1.0+1.0i 1/1 1.0) 1.0+1.0i)+(num-test (= 1.0+1.0i 1/1 1.0) #f)+(num-test (+ 1.0+1.0i 1/1 1/1) 3.0+1.0i)+(num-test (- 1.0+1.0i 1/1 1/1) -1.0+1.0i)+(num-test (* 1.0+1.0i 1/1 1/1) 1.0+1.0i)+(num-test (/ 1.0+1.0i 1/1 1/1) 1.0+1.0i)+(num-test (= 1.0+1.0i 1/1 1/1) #f)+(num-test (+ 1.0+1.0i 1/1 1.0+1.0i) 3.0+2.0i)+(num-test (- 1.0+1.0i 1/1 1.0+1.0i) -1.0)+(num-test (* 1.0+1.0i 1/1 1.0+1.0i) 0.0+2.0i)+(num-test (/ 1.0+1.0i 1/1 1.0+1.0i) 1.0)+(num-test (= 1.0+1.0i 1/1 1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1/1 0) 2.0+1.0i)+(num-test (- 1.0+1.0i 1/1 0) 0.0+1.0i)+(num-test (* 1.0+1.0i 1/1 0) 0.0)+(num-test (+ 1.0+1.0i 1/1 0.0) 2.0+1.0i)+(num-test (- 1.0+1.0i 1/1 0.0) 0.0+1.0i)+(num-test (* 1.0+1.0i 1/1 0.0) 0.0)+(num-test (+ 1.0+1.0i 1/1 1234) 1236.0+1.0i)+(num-test (- 1.0+1.0i 1/1 1234) -1234.0+1.0i)+(num-test (* 1.0+1.0i 1/1 1234) 1234.0+1234.0i)+(num-test (/ 1.0+1.0i 1/1 1234) 0.00081037277147+0.00081037277147i)+(num-test (= 1.0+1.0i 1/1 1234) #f)+(num-test (+ 1.0+1.0i 1/1 123.4) 125.4+1.0i)+(num-test (- 1.0+1.0i 1/1 123.4) -123.4+1.0i)+(num-test (* 1.0+1.0i 1/1 123.4) 123.4+123.4i)+(num-test (/ 1.0+1.0i 1/1 123.4) 0.00810372771475+0.00810372771475i)+(num-test (= 1.0+1.0i 1/1 123.4) #f)+(num-test (+ 1.0+1.0i 1/1 1234/11) 114.18181818181819+1.0i)+(num-test (- 1.0+1.0i 1/1 1234/11) -112.18181818181819+1.0i)+(num-test (* 1.0+1.0i 1/1 1234/11) 112.18181818181819+112.18181818181819i)+(num-test (/ 1.0+1.0i 1/1 1234/11) 0.00891410048622+0.00891410048622i)+(num-test (= 1.0+1.0i 1/1 1234/11) #f)+(num-test (+ 1.0+1.0i 1/1 1.234+1.234i) 3.234+2.234i)+(num-test (- 1.0+1.0i 1/1 1.234+1.234i) -1.234-0.234i)+(num-test (* 1.0+1.0i 1/1 1.234+1.234i) 0.0+2.468i)+(num-test (/ 1.0+1.0i 1/1 1.234+1.234i) 0.81037277147488)+(num-test (= 1.0+1.0i 1/1 1.234+1.234i) #f)+(num-test (+ 1.0+1.0i 1/1 -1.0+1.0i) 1.0+2.0i)+(num-test (- 1.0+1.0i 1/1 -1.0+1.0i) 1.0)+(num-test (* 1.0+1.0i 1/1 -1.0+1.0i) -2.0)+(num-test (/ 1.0+1.0i 1/1 -1.0+1.0i) -0.0-1.0i)+(num-test (= 1.0+1.0i 1/1 -1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1/1 0.0+1.0i) 2.0+2.0i)+(num-test (- 1.0+1.0i 1/1 0.0+1.0i) 0.0)+(num-test (* 1.0+1.0i 1/1 0.0+1.0i) -1.0+1.0i)+(num-test (/ 1.0+1.0i 1/1 0.0+1.0i) 1.0-1.0i)+(num-test (= 1.0+1.0i 1/1 0.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1.0+1.0i 1) 3.0+2.0i)+(num-test (- 1.0+1.0i 1.0+1.0i 1) -1.0)+(num-test (* 1.0+1.0i 1.0+1.0i 1) 0.0+2.0i)+(num-test (/ 1.0+1.0i 1.0+1.0i 1) 1.0)+(num-test (= 1.0+1.0i 1.0+1.0i 1) #f)+(num-test (+ 1.0+1.0i 1.0+1.0i 1.0) 3.0+2.0i)+(num-test (- 1.0+1.0i 1.0+1.0i 1.0) -1.0)+(num-test (* 1.0+1.0i 1.0+1.0i 1.0) 0.0+2.0i)+(num-test (/ 1.0+1.0i 1.0+1.0i 1.0) 1.0)+(num-test (= 1.0+1.0i 1.0+1.0i 1.0) #f)+(num-test (+ 1.0+1.0i 1.0+1.0i 1/1) 3.0+2.0i)+(num-test (- 1.0+1.0i 1.0+1.0i 1/1) -1.0)+(num-test (* 1.0+1.0i 1.0+1.0i 1/1) 0.0+2.0i)+(num-test (/ 1.0+1.0i 1.0+1.0i 1/1) 1.0)+(num-test (= 1.0+1.0i 1.0+1.0i 1/1) #f)+(num-test (+ 1.0+1.0i 1.0+1.0i 1.0+1.0i) 3.0+3.0i)+(num-test (- 1.0+1.0i 1.0+1.0i 1.0+1.0i) -1.0-1.0i)+(num-test (* 1.0+1.0i 1.0+1.0i 1.0+1.0i) -2.0+2.0i)+(num-test (/ 1.0+1.0i 1.0+1.0i 1.0+1.0i) 0.5-0.5i)+(num-test (= 1.0+1.0i 1.0+1.0i 1.0+1.0i) #t)+(num-test (+ 1.0+1.0i 1.0+1.0i 0) 2.0+2.0i)+(num-test (- 1.0+1.0i 1.0+1.0i 0) 0.0)+(num-test (* 1.0+1.0i 1.0+1.0i 0) 0.0)+(num-test (+ 1.0+1.0i 1.0+1.0i 0.0) 2.0+2.0i)+(num-test (- 1.0+1.0i 1.0+1.0i 0.0) 0.0)+(num-test (* 1.0+1.0i 1.0+1.0i 0.0) 0.0)+(num-test (+ 1.0+1.0i 1.0+1.0i 1234) 1236.0+2.0i)+(num-test (- 1.0+1.0i 1.0+1.0i 1234) -1234.0)+(num-test (* 1.0+1.0i 1.0+1.0i 1234) 0.0+2468.0i)+(num-test (/ 1.0+1.0i 1.0+1.0i 1234) 0.00081037277147)+(num-test (= 1.0+1.0i 1.0+1.0i 1234) #f)+(num-test (+ 1.0+1.0i 1.0+1.0i 123.4) 125.4+2.0i)+(num-test (- 1.0+1.0i 1.0+1.0i 123.4) -123.4)+(num-test (* 1.0+1.0i 1.0+1.0i 123.4) 0.0+246.8i)+(num-test (/ 1.0+1.0i 1.0+1.0i 123.4) 0.00810372771475)+(num-test (= 1.0+1.0i 1.0+1.0i 123.4) #f)+(num-test (+ 1.0+1.0i 1.0+1.0i 1234/11) 114.18181818181819+2.0i)+(num-test (- 1.0+1.0i 1.0+1.0i 1234/11) -112.18181818181819)+(num-test (* 1.0+1.0i 1.0+1.0i 1234/11) 0.0+224.36363636363637i)+(num-test (/ 1.0+1.0i 1.0+1.0i 1234/11) 0.00891410048622)+(num-test (= 1.0+1.0i 1.0+1.0i 1234/11) #f)+(num-test (+ 1.0+1.0i 1.0+1.0i 1.234+1.234i) 3.234+3.234i)+(num-test (- 1.0+1.0i 1.0+1.0i 1.234+1.234i) -1.234-1.234i)+(num-test (* 1.0+1.0i 1.0+1.0i 1.234+1.234i) -2.468+2.468i)+(num-test (/ 1.0+1.0i 1.0+1.0i 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1.0+1.0i 1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1.0+1.0i 1.0+1.0i -1.0+1.0i) 1.0+3.0i)+(num-test (- 1.0+1.0i 1.0+1.0i -1.0+1.0i) 1.0-1.0i)+(num-test (* 1.0+1.0i 1.0+1.0i -1.0+1.0i) -2.0-2.0i)+(num-test (/ 1.0+1.0i 1.0+1.0i -1.0+1.0i) -0.5-0.5i)+(num-test (= 1.0+1.0i 1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1.0+1.0i 0.0+1.0i) 2.0+3.0i)+(num-test (- 1.0+1.0i 1.0+1.0i 0.0+1.0i) 0.0-1.0i)+(num-test (* 1.0+1.0i 1.0+1.0i 0.0+1.0i) -2.0)+(num-test (/ 1.0+1.0i 1.0+1.0i 0.0+1.0i) 0.0-1.0i)+(num-test (= 1.0+1.0i 1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1.0+1.0i 0 1) 2.0+1.0i)+(num-test (- 1.0+1.0i 0 1) 0.0+1.0i)+(num-test (* 1.0+1.0i 0 1) 0.0)+(num-test (+ 1.0+1.0i 0 1.0) 2.0+1.0i)+(num-test (- 1.0+1.0i 0 1.0) 0.0+1.0i)+(num-test (* 1.0+1.0i 0 1.0) 0.0)+(num-test (+ 1.0+1.0i 0 1/1) 2.0+1.0i)+(num-test (- 1.0+1.0i 0 1/1) 0.0+1.0i)+(num-test (* 1.0+1.0i 0 1/1) 0.0)+(num-test (+ 1.0+1.0i 0 1.0+1.0i) 2.0+2.0i)+(num-test (- 1.0+1.0i 0 1.0+1.0i) 0.0)+(num-test (* 1.0+1.0i 0 1.0+1.0i) 0.0)+(num-test (+ 1.0+1.0i 0 0) 1.0+1.0i)+(num-test (- 1.0+1.0i 0 0) 1.0+1.0i)+(num-test (* 1.0+1.0i 0 0) 0.0)+(num-test (+ 1.0+1.0i 0 0.0) 1.0+1.0i)+(num-test (- 1.0+1.0i 0 0.0) 1.0+1.0i)+(num-test (* 1.0+1.0i 0 0.0) 0.0)+(num-test (+ 1.0+1.0i 0 1234) 1235.0+1.0i)+(num-test (- 1.0+1.0i 0 1234) -1233.0+1.0i)+(num-test (* 1.0+1.0i 0 1234) 0.0)+(num-test (+ 1.0+1.0i 0 123.4) 124.4+1.0i)+(num-test (- 1.0+1.0i 0 123.4) -122.4+1.0i)+(num-test (* 1.0+1.0i 0 123.4) 0.0)+(num-test (+ 1.0+1.0i 0 1234/11) 113.18181818181819+1.0i)+(num-test (- 1.0+1.0i 0 1234/11) -111.18181818181819+1.0i)+(num-test (* 1.0+1.0i 0 1234/11) 0.0)+(num-test (+ 1.0+1.0i 0 1.234+1.234i) 2.234+2.234i)+(num-test (- 1.0+1.0i 0 1.234+1.234i) -0.234-0.234i)+(num-test (* 1.0+1.0i 0 1.234+1.234i) 0.0)+(num-test (+ 1.0+1.0i 0 -1.0+1.0i) 0.0+2.0i)+(num-test (- 1.0+1.0i 0 -1.0+1.0i) 2.0)+(num-test (* 1.0+1.0i 0 -1.0+1.0i) -0.0)+(num-test (+ 1.0+1.0i 0 0.0+1.0i) 1.0+2.0i)+(num-test (- 1.0+1.0i 0 0.0+1.0i) 1.0)+(num-test (* 1.0+1.0i 0 0.0+1.0i) 0.0)+(num-test (+ 1.0+1.0i 0.0 1) 2.0+1.0i)+(num-test (- 1.0+1.0i 0.0 1) 0.0+1.0i)+(num-test (* 1.0+1.0i 0.0 1) 0.0)+(num-test (+ 1.0+1.0i 0.0 1.0) 2.0+1.0i)+(num-test (- 1.0+1.0i 0.0 1.0) 0.0+1.0i)+(num-test (* 1.0+1.0i 0.0 1.0) 0.0)+(num-test (+ 1.0+1.0i 0.0 1/1) 2.0+1.0i)+(num-test (- 1.0+1.0i 0.0 1/1) 0.0+1.0i)+(num-test (* 1.0+1.0i 0.0 1/1) 0.0)+(num-test (+ 1.0+1.0i 0.0 1.0+1.0i) 2.0+2.0i)+(num-test (- 1.0+1.0i 0.0 1.0+1.0i) 0.0)+(num-test (* 1.0+1.0i 0.0 1.0+1.0i) 0.0)+(num-test (+ 1.0+1.0i 0.0 0) 1.0+1.0i)+(num-test (- 1.0+1.0i 0.0 0) 1.0+1.0i)+(num-test (* 1.0+1.0i 0.0 0) 0.0)+(num-test (+ 1.0+1.0i 0.0 0.0) 1.0+1.0i)+(num-test (- 1.0+1.0i 0.0 0.0) 1.0+1.0i)+(num-test (* 1.0+1.0i 0.0 0.0) 0.0)+(num-test (+ 1.0+1.0i 0.0 1234) 1235.0+1.0i)+(num-test (- 1.0+1.0i 0.0 1234) -1233.0+1.0i)+(num-test (* 1.0+1.0i 0.0 1234) 0.0)+(num-test (+ 1.0+1.0i 0.0 123.4) 124.4+1.0i)+(num-test (- 1.0+1.0i 0.0 123.4) -122.4+1.0i)+(num-test (* 1.0+1.0i 0.0 123.4) 0.0)+(num-test (+ 1.0+1.0i 0.0 1234/11) 113.18181818181819+1.0i)+(num-test (- 1.0+1.0i 0.0 1234/11) -111.18181818181819+1.0i)+(num-test (* 1.0+1.0i 0.0 1234/11) 0.0)+(num-test (+ 1.0+1.0i 0.0 1.234+1.234i) 2.234+2.234i)+(num-test (- 1.0+1.0i 0.0 1.234+1.234i) -0.234-0.234i)+(num-test (* 1.0+1.0i 0.0 1.234+1.234i) 0.0)+(num-test (+ 1.0+1.0i 0.0 -1.0+1.0i) 0.0+2.0i)+(num-test (- 1.0+1.0i 0.0 -1.0+1.0i) 2.0)+(num-test (* 1.0+1.0i 0.0 -1.0+1.0i) -0.0)+(num-test (+ 1.0+1.0i 0.0 0.0+1.0i) 1.0+2.0i)+(num-test (- 1.0+1.0i 0.0 0.0+1.0i) 1.0)+(num-test (* 1.0+1.0i 0.0 0.0+1.0i) 0.0)+(num-test (+ 1.0+1.0i 1234 1) 1236.0+1.0i)+(num-test (- 1.0+1.0i 1234 1) -1234.0+1.0i)+(num-test (* 1.0+1.0i 1234 1) 1234.0+1234.0i)+(num-test (/ 1.0+1.0i 1234 1) 0.00081037277147+0.00081037277147i)+(num-test (= 1.0+1.0i 1234 1) #f)+(num-test (+ 1.0+1.0i 1234 1.0) 1236.0+1.0i)+(num-test (- 1.0+1.0i 1234 1.0) -1234.0+1.0i)+(num-test (* 1.0+1.0i 1234 1.0) 1234.0+1234.0i)+(num-test (/ 1.0+1.0i 1234 1.0) 0.00081037277147+0.00081037277147i)+(num-test (= 1.0+1.0i 1234 1.0) #f)+(num-test (+ 1.0+1.0i 1234 1/1) 1236.0+1.0i)+(num-test (- 1.0+1.0i 1234 1/1) -1234.0+1.0i)+(num-test (* 1.0+1.0i 1234 1/1) 1234.0+1234.0i)+(num-test (/ 1.0+1.0i 1234 1/1) 0.00081037277147+0.00081037277147i)+(num-test (= 1.0+1.0i 1234 1/1) #f)+(num-test (+ 1.0+1.0i 1234 1.0+1.0i) 1236.0+2.0i)+(num-test (- 1.0+1.0i 1234 1.0+1.0i) -1234.0)+(num-test (* 1.0+1.0i 1234 1.0+1.0i) 0.0+2468.0i)+(num-test (/ 1.0+1.0i 1234 1.0+1.0i) 0.00081037277147)+(num-test (= 1.0+1.0i 1234 1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1234 0) 1235.0+1.0i)+(num-test (- 1.0+1.0i 1234 0) -1233.0+1.0i)+(num-test (* 1.0+1.0i 1234 0) 0.0)+(num-test (+ 1.0+1.0i 1234 0.0) 1235.0+1.0i)+(num-test (- 1.0+1.0i 1234 0.0) -1233.0+1.0i)+(num-test (* 1.0+1.0i 1234 0.0) 0.0)+(num-test (+ 1.0+1.0i 1234 1234) 2469.0+1.0i)+(num-test (- 1.0+1.0i 1234 1234) -2467.0+1.0i)+(num-test (* 1.0+1.0i 1234 1234) 1522756.0+1522756.0i)+(num-test (/ 1.0+1.0i 1234 1234) 0.00000065670403+0.00000065670403i)+(num-test (= 1.0+1.0i 1234 1234) #f)+(num-test (+ 1.0+1.0i 1234 123.4) 1358.4+1.0i)+(num-test (- 1.0+1.0i 1234 123.4) -1356.4+1.0i)+(num-test (* 1.0+1.0i 1234 123.4) 152275.60000000000582+152275.60000000000582i)+(num-test (/ 1.0+1.0i 1234 123.4) 0.00000656704029+0.00000656704029i)+(num-test (= 1.0+1.0i 1234 123.4) #f)+(num-test (+ 1.0+1.0i 1234 1234/11) 1347.18181818181824+1.0i)+(num-test (- 1.0+1.0i 1234 1234/11) -1345.18181818181824+1.0i)+(num-test (* 1.0+1.0i 1234 1234/11) 138432.36363636364695+138432.36363636364695i)+(num-test (/ 1.0+1.0i 1234 1234/11) 0.00000722374432+0.00000722374432i)+(num-test (= 1.0+1.0i 1234 1234/11) #f)+(num-test (+ 1.0+1.0i 1234 1.234+1.234i) 1236.23399999999992+2.234i)+(num-test (- 1.0+1.0i 1234 1.234+1.234i) -1234.23399999999992-0.234i)+(num-test (* 1.0+1.0i 1234 1.234+1.234i) 0.0+3045.51200000000017i)+(num-test (/ 1.0+1.0i 1234 1.234+1.234i) 0.00065670402875)+(num-test (= 1.0+1.0i 1234 1.234+1.234i) #f)+(num-test (+ 1.0+1.0i 1234 -1.0+1.0i) 1234.0+2.0i)+(num-test (- 1.0+1.0i 1234 -1.0+1.0i) -1232.0)+(num-test (* 1.0+1.0i 1234 -1.0+1.0i) -2468.0)+(num-test (/ 1.0+1.0i 1234 -1.0+1.0i) -0.0-0.00081037277147i)+(num-test (= 1.0+1.0i 1234 -1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1234 0.0+1.0i) 1235.0+2.0i)+(num-test (- 1.0+1.0i 1234 0.0+1.0i) -1233.0)+(num-test (* 1.0+1.0i 1234 0.0+1.0i) -1234.0+1234.0i)+(num-test (/ 1.0+1.0i 1234 0.0+1.0i) 0.00081037277147-0.00081037277147i)+(num-test (= 1.0+1.0i 1234 0.0+1.0i) #f)+(num-test (+ 1.0+1.0i 123.4 1) 125.4+1.0i)+(num-test (- 1.0+1.0i 123.4 1) -123.4+1.0i)+(num-test (* 1.0+1.0i 123.4 1) 123.4+123.4i)+(num-test (/ 1.0+1.0i 123.4 1) 0.00810372771475+0.00810372771475i)+(num-test (= 1.0+1.0i 123.4 1) #f)+(num-test (+ 1.0+1.0i 123.4 1.0) 125.4+1.0i)+(num-test (- 1.0+1.0i 123.4 1.0) -123.4+1.0i)+(num-test (* 1.0+1.0i 123.4 1.0) 123.4+123.4i)+(num-test (/ 1.0+1.0i 123.4 1.0) 0.00810372771475+0.00810372771475i)+(num-test (= 1.0+1.0i 123.4 1.0) #f)+(num-test (+ 1.0+1.0i 123.4 1/1) 125.4+1.0i)+(num-test (- 1.0+1.0i 123.4 1/1) -123.4+1.0i)+(num-test (* 1.0+1.0i 123.4 1/1) 123.4+123.4i)+(num-test (/ 1.0+1.0i 123.4 1/1) 0.00810372771475+0.00810372771475i)+(num-test (= 1.0+1.0i 123.4 1/1) #f)+(num-test (+ 1.0+1.0i 123.4 1.0+1.0i) 125.4+2.0i)+(num-test (- 1.0+1.0i 123.4 1.0+1.0i) -123.4)+(num-test (* 1.0+1.0i 123.4 1.0+1.0i) 0.0+246.8i)+(num-test (/ 1.0+1.0i 123.4 1.0+1.0i) 0.00810372771475)+(num-test (= 1.0+1.0i 123.4 1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 123.4 0) 124.4+1.0i)+(num-test (- 1.0+1.0i 123.4 0) -122.4+1.0i)+(num-test (* 1.0+1.0i 123.4 0) 0.0)+(num-test (+ 1.0+1.0i 123.4 0.0) 124.4+1.0i)+(num-test (- 1.0+1.0i 123.4 0.0) -122.4+1.0i)+(num-test (* 1.0+1.0i 123.4 0.0) 0.0)+(num-test (+ 1.0+1.0i 123.4 1234) 1358.4+1.0i)+(num-test (- 1.0+1.0i 123.4 1234) -1356.4+1.0i)+(num-test (* 1.0+1.0i 123.4 1234) 152275.60000000000582+152275.60000000000582i)+(num-test (/ 1.0+1.0i 123.4 1234) 0.00000656704029+0.00000656704029i)+(num-test (= 1.0+1.0i 123.4 1234) #f)+(num-test (+ 1.0+1.0i 123.4 123.4) 247.8+1.0i)+(num-test (- 1.0+1.0i 123.4 123.4) -245.8+1.0i)+(num-test (* 1.0+1.0i 123.4 123.4) 15227.56000000000131+15227.56000000000131i)+(num-test (/ 1.0+1.0i 123.4 123.4) 0.00006567040287+0.00006567040287i)+(num-test (= 1.0+1.0i 123.4 123.4) #f)+(num-test (+ 1.0+1.0i 123.4 1234/11) 236.58181818181819+1.0i)+(num-test (- 1.0+1.0i 123.4 1234/11) -234.58181818181819+1.0i)+(num-test (* 1.0+1.0i 123.4 1234/11) 13843.23636363636433+13843.23636363636433i)+(num-test (/ 1.0+1.0i 123.4 1234/11) 0.00007223744316+0.00007223744316i)+(num-test (= 1.0+1.0i 123.4 1234/11) #f)+(num-test (+ 1.0+1.0i 123.4 1.234+1.234i) 125.634+2.234i)+(num-test (- 1.0+1.0i 123.4 1.234+1.234i) -123.634-0.234i)+(num-test (* 1.0+1.0i 123.4 1.234+1.234i) 0.0+304.55119999999999i)+(num-test (/ 1.0+1.0i 123.4 1.234+1.234i) 0.00656704028748)+(num-test (= 1.0+1.0i 123.4 1.234+1.234i) #f)+(num-test (+ 1.0+1.0i 123.4 -1.0+1.0i) 123.4+2.0i)+(num-test (- 1.0+1.0i 123.4 -1.0+1.0i) -121.4)+(num-test (* 1.0+1.0i 123.4 -1.0+1.0i) -246.8)+(num-test (/ 1.0+1.0i 123.4 -1.0+1.0i) -0.0-0.00810372771475i)+(num-test (= 1.0+1.0i 123.4 -1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 123.4 0.0+1.0i) 124.4+2.0i)+(num-test (- 1.0+1.0i 123.4 0.0+1.0i) -122.4)+(num-test (* 1.0+1.0i 123.4 0.0+1.0i) -123.4+123.4i)+(num-test (/ 1.0+1.0i 123.4 0.0+1.0i) 0.00810372771475-0.00810372771475i)+(num-test (= 1.0+1.0i 123.4 0.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1234/11 1) 114.18181818181819+1.0i)+(num-test (- 1.0+1.0i 1234/11 1) -112.18181818181819+1.0i)+(num-test (* 1.0+1.0i 1234/11 1) 112.18181818181819+112.18181818181819i)+(num-test (/ 1.0+1.0i 1234/11 1) 0.00891410048622+0.00891410048622i)+(num-test (= 1.0+1.0i 1234/11 1) #f)+(num-test (+ 1.0+1.0i 1234/11 1.0) 114.18181818181819+1.0i)+(num-test (- 1.0+1.0i 1234/11 1.0) -112.18181818181819+1.0i)+(num-test (* 1.0+1.0i 1234/11 1.0) 112.18181818181819+112.18181818181819i)+(num-test (/ 1.0+1.0i 1234/11 1.0) 0.00891410048622+0.00891410048622i)+(num-test (= 1.0+1.0i 1234/11 1.0) #f)+(num-test (+ 1.0+1.0i 1234/11 1/1) 114.18181818181819+1.0i)+(num-test (- 1.0+1.0i 1234/11 1/1) -112.18181818181819+1.0i)+(num-test (* 1.0+1.0i 1234/11 1/1) 112.18181818181819+112.18181818181819i)+(num-test (/ 1.0+1.0i 1234/11 1/1) 0.00891410048622+0.00891410048622i)+(num-test (= 1.0+1.0i 1234/11 1/1) #f)+(num-test (+ 1.0+1.0i 1234/11 1.0+1.0i) 114.18181818181819+2.0i)+(num-test (- 1.0+1.0i 1234/11 1.0+1.0i) -112.18181818181819)+(num-test (* 1.0+1.0i 1234/11 1.0+1.0i) 0.0+224.36363636363637i)+(num-test (/ 1.0+1.0i 1234/11 1.0+1.0i) 0.00891410048622)+(num-test (= 1.0+1.0i 1234/11 1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1234/11 0) 113.18181818181819+1.0i)+(num-test (- 1.0+1.0i 1234/11 0) -111.18181818181819+1.0i)+(num-test (* 1.0+1.0i 1234/11 0) 0.0)+(num-test (+ 1.0+1.0i 1234/11 0.0) 113.18181818181819+1.0i)+(num-test (- 1.0+1.0i 1234/11 0.0) -111.18181818181819+1.0i)+(num-test (* 1.0+1.0i 1234/11 0.0) 0.0)+(num-test (+ 1.0+1.0i 1234/11 1234) 1347.18181818181824+1.0i)+(num-test (- 1.0+1.0i 1234/11 1234) -1345.18181818181824+1.0i)+(num-test (* 1.0+1.0i 1234/11 1234) 138432.36363636364695+138432.36363636364695i)+(num-test (/ 1.0+1.0i 1234/11 1234) 0.00000722374432+0.00000722374432i)+(num-test (= 1.0+1.0i 1234/11 1234) #f)+(num-test (+ 1.0+1.0i 1234/11 123.4) 236.58181818181819+1.0i)+(num-test (- 1.0+1.0i 1234/11 123.4) -234.58181818181819+1.0i)+(num-test (* 1.0+1.0i 1234/11 123.4) 13843.23636363636433+13843.23636363636433i)+(num-test (/ 1.0+1.0i 1234/11 123.4) 0.00007223744316+0.00007223744316i)+(num-test (= 1.0+1.0i 1234/11 123.4) #f)+(num-test (+ 1.0+1.0i 1234/11 1234/11) 225.36363636363637+1.0i)+(num-test (- 1.0+1.0i 1234/11 1234/11) -223.36363636363637+1.0i)+(num-test (* 1.0+1.0i 1234/11 1234/11) 12584.76033057851419+12584.76033057851419i)+(num-test (/ 1.0+1.0i 1234/11 1234/11) 0.00007946118748+0.00007946118748i)+(num-test (= 1.0+1.0i 1234/11 1234/11) #f)+(num-test (+ 1.0+1.0i 1234/11 1.234+1.234i) 114.41581818181818+2.234i)+(num-test (- 1.0+1.0i 1234/11 1.234+1.234i) -112.41581818181818-0.234i)+(num-test (* 1.0+1.0i 1234/11 1.234+1.234i) 0.0+276.86472727272729i)+(num-test (/ 1.0+1.0i 1234/11 1.234+1.234i) 0.00722374431623)+(num-test (= 1.0+1.0i 1234/11 1.234+1.234i) #f)+(num-test (+ 1.0+1.0i 1234/11 -1.0+1.0i) 112.18181818181819+2.0i)+(num-test (- 1.0+1.0i 1234/11 -1.0+1.0i) -110.18181818181819)+(num-test (* 1.0+1.0i 1234/11 -1.0+1.0i) -224.36363636363637)+(num-test (/ 1.0+1.0i 1234/11 -1.0+1.0i) -0.0-0.00891410048622i)+(num-test (= 1.0+1.0i 1234/11 -1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1234/11 0.0+1.0i) 113.18181818181819+2.0i)+(num-test (- 1.0+1.0i 1234/11 0.0+1.0i) -111.18181818181819)+(num-test (* 1.0+1.0i 1234/11 0.0+1.0i) -112.18181818181819+112.18181818181819i)+(num-test (/ 1.0+1.0i 1234/11 0.0+1.0i) 0.00891410048622-0.00891410048622i)+(num-test (= 1.0+1.0i 1234/11 0.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1.234+1.234i 1) 3.234+2.234i)+(num-test (- 1.0+1.0i 1.234+1.234i 1) -1.234-0.234i)+(num-test (* 1.0+1.0i 1.234+1.234i 1) 0.0+2.468i)+(num-test (/ 1.0+1.0i 1.234+1.234i 1) 0.81037277147488)+(num-test (= 1.0+1.0i 1.234+1.234i 1) #f)+(num-test (+ 1.0+1.0i 1.234+1.234i 1.0) 3.234+2.234i)+(num-test (- 1.0+1.0i 1.234+1.234i 1.0) -1.234-0.234i)+(num-test (* 1.0+1.0i 1.234+1.234i 1.0) 0.0+2.468i)+(num-test (/ 1.0+1.0i 1.234+1.234i 1.0) 0.81037277147488)+(num-test (= 1.0+1.0i 1.234+1.234i 1.0) #f)+(num-test (+ 1.0+1.0i 1.234+1.234i 1/1) 3.234+2.234i)+(num-test (- 1.0+1.0i 1.234+1.234i 1/1) -1.234-0.234i)+(num-test (* 1.0+1.0i 1.234+1.234i 1/1) 0.0+2.468i)+(num-test (/ 1.0+1.0i 1.234+1.234i 1/1) 0.81037277147488)+(num-test (= 1.0+1.0i 1.234+1.234i 1/1) #f)+(num-test (+ 1.0+1.0i 1.234+1.234i 1.0+1.0i) 3.234+3.234i)+(num-test (- 1.0+1.0i 1.234+1.234i 1.0+1.0i) -1.234-1.234i)+(num-test (* 1.0+1.0i 1.234+1.234i 1.0+1.0i) -2.468+2.468i)+(num-test (/ 1.0+1.0i 1.234+1.234i 1.0+1.0i) 0.40518638573744-0.40518638573744i)+(num-test (= 1.0+1.0i 1.234+1.234i 1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1.234+1.234i 0) 2.234+2.234i)+(num-test (- 1.0+1.0i 1.234+1.234i 0) -0.234-0.234i)+(num-test (* 1.0+1.0i 1.234+1.234i 0) 0.0)+(num-test (+ 1.0+1.0i 1.234+1.234i 0.0) 2.234+2.234i)+(num-test (- 1.0+1.0i 1.234+1.234i 0.0) -0.234-0.234i)+(num-test (* 1.0+1.0i 1.234+1.234i 0.0) 0.0)+(num-test (+ 1.0+1.0i 1.234+1.234i 1234) 1236.23399999999992+2.234i)+(num-test (- 1.0+1.0i 1.234+1.234i 1234) -1234.23399999999992-0.234i)+(num-test (* 1.0+1.0i 1.234+1.234i 1234) 0.0+3045.51200000000017i)+(num-test (/ 1.0+1.0i 1.234+1.234i 1234) 0.00065670402875)+(num-test (= 1.0+1.0i 1.234+1.234i 1234) #f)+(num-test (+ 1.0+1.0i 1.234+1.234i 123.4) 125.634+2.234i)+(num-test (- 1.0+1.0i 1.234+1.234i 123.4) -123.634-0.234i)+(num-test (* 1.0+1.0i 1.234+1.234i 123.4) 0.0+304.55119999999999i)+(num-test (/ 1.0+1.0i 1.234+1.234i 123.4) 0.00656704028748)+(num-test (= 1.0+1.0i 1.234+1.234i 123.4) #f)+(num-test (+ 1.0+1.0i 1.234+1.234i 1234/11) 114.41581818181818+2.234i)+(num-test (- 1.0+1.0i 1.234+1.234i 1234/11) -112.41581818181818-0.234i)+(num-test (* 1.0+1.0i 1.234+1.234i 1234/11) 0.0+276.86472727272729i)+(num-test (/ 1.0+1.0i 1.234+1.234i 1234/11) 0.00722374431623)+(num-test (= 1.0+1.0i 1.234+1.234i 1234/11) #f)+(num-test (+ 1.0+1.0i 1.234+1.234i 1.234+1.234i) 3.468+3.468i)+(num-test (- 1.0+1.0i 1.234+1.234i 1.234+1.234i) -1.468-1.468i)+(num-test (* 1.0+1.0i 1.234+1.234i 1.234+1.234i) -3.04551200000000+3.04551200000000i)+(num-test (/ 1.0+1.0i 1.234+1.234i 1.234+1.234i) 0.32835201437394-0.32835201437394i)+(num-test (= 1.0+1.0i 1.234+1.234i 1.234+1.234i) #f)+(num-test (+ 1.0+1.0i 1.234+1.234i -1.0+1.0i) 1.234+3.234i)+(num-test (- 1.0+1.0i 1.234+1.234i -1.0+1.0i) 0.766-1.234i)+(num-test (* 1.0+1.0i 1.234+1.234i -1.0+1.0i) -2.468-2.468i)+(num-test (/ 1.0+1.0i 1.234+1.234i -1.0+1.0i) -0.40518638573744-0.40518638573744i)+(num-test (= 1.0+1.0i 1.234+1.234i -1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 1.234+1.234i 0.0+1.0i) 2.234+3.234i)+(num-test (- 1.0+1.0i 1.234+1.234i 0.0+1.0i) -0.234-1.234i)+(num-test (* 1.0+1.0i 1.234+1.234i 0.0+1.0i) -2.468)+(num-test (/ 1.0+1.0i 1.234+1.234i 0.0+1.0i) 0.0-0.81037277147488i)+(num-test (= 1.0+1.0i 1.234+1.234i 0.0+1.0i) #f)+(num-test (+ 1.0+1.0i -1.0+1.0i 1) 1.0+2.0i)+(num-test (- 1.0+1.0i -1.0+1.0i 1) 1.0)+(num-test (* 1.0+1.0i -1.0+1.0i 1) -2.0)+(num-test (/ 1.0+1.0i -1.0+1.0i 1) -0.0-1.0i)+(num-test (= 1.0+1.0i -1.0+1.0i 1) #f)+(num-test (+ 1.0+1.0i -1.0+1.0i 1.0) 1.0+2.0i)+(num-test (- 1.0+1.0i -1.0+1.0i 1.0) 1.0)+(num-test (* 1.0+1.0i -1.0+1.0i 1.0) -2.0)+(num-test (/ 1.0+1.0i -1.0+1.0i 1.0) -0.0-1.0i)+(num-test (= 1.0+1.0i -1.0+1.0i 1.0) #f)+(num-test (+ 1.0+1.0i -1.0+1.0i 1/1) 1.0+2.0i)+(num-test (- 1.0+1.0i -1.0+1.0i 1/1) 1.0)+(num-test (* 1.0+1.0i -1.0+1.0i 1/1) -2.0)+(num-test (/ 1.0+1.0i -1.0+1.0i 1/1) -0.0-1.0i)+(num-test (= 1.0+1.0i -1.0+1.0i 1/1) #f)+(num-test (+ 1.0+1.0i -1.0+1.0i 1.0+1.0i) 1.0+3.0i)+(num-test (- 1.0+1.0i -1.0+1.0i 1.0+1.0i) 1.0-1.0i)+(num-test (* 1.0+1.0i -1.0+1.0i 1.0+1.0i) -2.0-2.0i)+(num-test (/ 1.0+1.0i -1.0+1.0i 1.0+1.0i) -0.5-0.5i)+(num-test (= 1.0+1.0i -1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1.0+1.0i -1.0+1.0i 0) 0.0+2.0i)+(num-test (- 1.0+1.0i -1.0+1.0i 0) 2.0)+(num-test (* 1.0+1.0i -1.0+1.0i 0) -0.0)+(num-test (+ 1.0+1.0i -1.0+1.0i 0.0) 0.0+2.0i)+(num-test (- 1.0+1.0i -1.0+1.0i 0.0) 2.0)+(num-test (* 1.0+1.0i -1.0+1.0i 0.0) -0.0)+(num-test (+ 1.0+1.0i -1.0+1.0i 1234) 1234.0+2.0i)+(num-test (- 1.0+1.0i -1.0+1.0i 1234) -1232.0)+(num-test (* 1.0+1.0i -1.0+1.0i 1234) -2468.0)+(num-test (/ 1.0+1.0i -1.0+1.0i 1234) -0.0-0.00081037277147i)+(num-test (= 1.0+1.0i -1.0+1.0i 1234) #f)+(num-test (+ 1.0+1.0i -1.0+1.0i 123.4) 123.4+2.0i)+(num-test (- 1.0+1.0i -1.0+1.0i 123.4) -121.4)+(num-test (* 1.0+1.0i -1.0+1.0i 123.4) -246.8)+(num-test (/ 1.0+1.0i -1.0+1.0i 123.4) -0.0-0.00810372771475i)+(num-test (= 1.0+1.0i -1.0+1.0i 123.4) #f)+(num-test (+ 1.0+1.0i -1.0+1.0i 1234/11) 112.18181818181819+2.0i)+(num-test (- 1.0+1.0i -1.0+1.0i 1234/11) -110.18181818181819)+(num-test (* 1.0+1.0i -1.0+1.0i 1234/11) -224.36363636363637)+(num-test (/ 1.0+1.0i -1.0+1.0i 1234/11) -0.0-0.00891410048622i)+(num-test (= 1.0+1.0i -1.0+1.0i 1234/11) #f)+(num-test (+ 1.0+1.0i -1.0+1.0i 1.234+1.234i) 1.234+3.234i)+(num-test (- 1.0+1.0i -1.0+1.0i 1.234+1.234i) 0.766-1.234i)+(num-test (* 1.0+1.0i -1.0+1.0i 1.234+1.234i) -2.468-2.468i)+(num-test (/ 1.0+1.0i -1.0+1.0i 1.234+1.234i) -0.40518638573744-0.40518638573744i)+(num-test (= 1.0+1.0i -1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1.0+1.0i -1.0+1.0i -1.0+1.0i) -1.0+3.0i)+(num-test (- 1.0+1.0i -1.0+1.0i -1.0+1.0i) 3.0-1.0i)+(num-test (* 1.0+1.0i -1.0+1.0i -1.0+1.0i) 2.0-2.0i)+(num-test (/ 1.0+1.0i -1.0+1.0i -1.0+1.0i) -0.5+0.5i)+(num-test (= 1.0+1.0i -1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1.0+1.0i -1.0+1.0i 0.0+1.0i) 0.0+3.0i)+(num-test (- 1.0+1.0i -1.0+1.0i 0.0+1.0i) 2.0-1.0i)+(num-test (* 1.0+1.0i -1.0+1.0i 0.0+1.0i) -0.0-2.0i)+(num-test (/ 1.0+1.0i -1.0+1.0i 0.0+1.0i) -1.0)+(num-test (= 1.0+1.0i -1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1.0+1.0i 0.0+1.0i 1) 2.0+2.0i)+(num-test (- 1.0+1.0i 0.0+1.0i 1) 0.0)+(num-test (* 1.0+1.0i 0.0+1.0i 1) -1.0+1.0i)+(num-test (/ 1.0+1.0i 0.0+1.0i 1) 1.0-1.0i)+(num-test (= 1.0+1.0i 0.0+1.0i 1) #f)+(num-test (+ 1.0+1.0i 0.0+1.0i 1.0) 2.0+2.0i)+(num-test (- 1.0+1.0i 0.0+1.0i 1.0) 0.0)+(num-test (* 1.0+1.0i 0.0+1.0i 1.0) -1.0+1.0i)+(num-test (/ 1.0+1.0i 0.0+1.0i 1.0) 1.0-1.0i)+(num-test (= 1.0+1.0i 0.0+1.0i 1.0) #f)+(num-test (+ 1.0+1.0i 0.0+1.0i 1/1) 2.0+2.0i)+(num-test (- 1.0+1.0i 0.0+1.0i 1/1) 0.0)+(num-test (* 1.0+1.0i 0.0+1.0i 1/1) -1.0+1.0i)+(num-test (/ 1.0+1.0i 0.0+1.0i 1/1) 1.0-1.0i)+(num-test (= 1.0+1.0i 0.0+1.0i 1/1) #f)+(num-test (+ 1.0+1.0i 0.0+1.0i 1.0+1.0i) 2.0+3.0i)+(num-test (- 1.0+1.0i 0.0+1.0i 1.0+1.0i) 0.0-1.0i)+(num-test (* 1.0+1.0i 0.0+1.0i 1.0+1.0i) -2.0)+(num-test (/ 1.0+1.0i 0.0+1.0i 1.0+1.0i) 0.0-1.0i)+(num-test (= 1.0+1.0i 0.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 0.0+1.0i 0) 1.0+2.0i)+(num-test (- 1.0+1.0i 0.0+1.0i 0) 1.0)+(num-test (* 1.0+1.0i 0.0+1.0i 0) -0.0)+(num-test (+ 1.0+1.0i 0.0+1.0i 0.0) 1.0+2.0i)+(num-test (- 1.0+1.0i 0.0+1.0i 0.0) 1.0)+(num-test (* 1.0+1.0i 0.0+1.0i 0.0) -0.0)+(num-test (+ 1.0+1.0i 0.0+1.0i 1234) 1235.0+2.0i)+(num-test (- 1.0+1.0i 0.0+1.0i 1234) -1233.0)+(num-test (* 1.0+1.0i 0.0+1.0i 1234) -1234.0+1234.0i)+(num-test (/ 1.0+1.0i 0.0+1.0i 1234) 0.00081037277147-0.00081037277147i)+(num-test (= 1.0+1.0i 0.0+1.0i 1234) #f)+(num-test (+ 1.0+1.0i 0.0+1.0i 123.4) 124.4+2.0i)+(num-test (- 1.0+1.0i 0.0+1.0i 123.4) -122.4)+(num-test (* 1.0+1.0i 0.0+1.0i 123.4) -123.4+123.4i)+(num-test (/ 1.0+1.0i 0.0+1.0i 123.4) 0.00810372771475-0.00810372771475i)+(num-test (= 1.0+1.0i 0.0+1.0i 123.4) #f)+(num-test (+ 1.0+1.0i 0.0+1.0i 1234/11) 113.18181818181819+2.0i)+(num-test (- 1.0+1.0i 0.0+1.0i 1234/11) -111.18181818181819)+(num-test (* 1.0+1.0i 0.0+1.0i 1234/11) -112.18181818181819+112.18181818181819i)+(num-test (/ 1.0+1.0i 0.0+1.0i 1234/11) 0.00891410048622-0.00891410048622i)+(num-test (= 1.0+1.0i 0.0+1.0i 1234/11) #f)+(num-test (+ 1.0+1.0i 0.0+1.0i 1.234+1.234i) 2.234+3.234i)+(num-test (- 1.0+1.0i 0.0+1.0i 1.234+1.234i) -0.234-1.234i)+(num-test (* 1.0+1.0i 0.0+1.0i 1.234+1.234i) -2.468)+(num-test (/ 1.0+1.0i 0.0+1.0i 1.234+1.234i) 0.0-0.81037277147488i)+(num-test (= 1.0+1.0i 0.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1.0+1.0i 0.0+1.0i -1.0+1.0i) 0.0+3.0i)+(num-test (- 1.0+1.0i 0.0+1.0i -1.0+1.0i) 2.0-1.0i)+(num-test (* 1.0+1.0i 0.0+1.0i -1.0+1.0i) 0.0-2.0i)+(num-test (/ 1.0+1.0i 0.0+1.0i -1.0+1.0i) -1.0)+(num-test (= 1.0+1.0i 0.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1.0+1.0i 0.0+1.0i 0.0+1.0i) 1.0+3.0i)+(num-test (- 1.0+1.0i 0.0+1.0i 0.0+1.0i) 1.0-1.0i)+(num-test (* 1.0+1.0i 0.0+1.0i 0.0+1.0i) -1.0-1.0i)+(num-test (/ 1.0+1.0i 0.0+1.0i 0.0+1.0i) -1.0-1.0i)+(num-test (= 1.0+1.0i 0.0+1.0i 0.0+1.0i) #f)+(num-test (+ 0 1 1) 2)+(num-test (- 0 1 1) -2)+(num-test (* 0 1 1) 0)+(num-test (/ 0 1 1) 0)+(num-test (= 0 1 1) #f)+(num-test (< 0 1 1) #f)+(num-test (<= 0 1 1) #t)+(num-test (> 0 1 1) #f)+(num-test (>= 0 1 1) #f)+(num-test (+ 0 1 1.0) 2.0)+(num-test (- 0 1 1.0) -2.0)+(num-test (* 0 1 1.0) 0.0)+(num-test (/ 0 1 1.0) 0.0)+(num-test (= 0 1 1.0) #f)+(num-test (< 0 1 1.0) #f)+(num-test (<= 0 1 1.0) #t)+(num-test (> 0 1 1.0) #f)+(num-test (>= 0 1 1.0) #f)+(num-test (+ 0 1 1/1) 2)+(num-test (- 0 1 1/1) -2)+(num-test (* 0 1 1/1) 0)+(num-test (/ 0 1 1/1) 0)+(num-test (= 0 1 1/1) #f)+(num-test (< 0 1 1/1) #f)+(num-test (<= 0 1 1/1) #t)+(num-test (> 0 1 1/1) #f)+(num-test (>= 0 1 1/1) #f)+(num-test (+ 0 1 1.0+1.0i) 2.0+1.0i)+(num-test (- 0 1 1.0+1.0i) -2.0-1.0i)+(num-test (* 0 1 1.0+1.0i) 0.0)+(num-test (/ 0 1 1.0+1.0i) 0.0)+(num-test (= 0 1 1.0+1.0i) #f)+(num-test (+ 0 1 0) 1)+(num-test (- 0 1 0) -1)+(num-test (* 0 1 0) 0)+(num-test (+ 0 1 0.0) 1.0)+(num-test (- 0 1 0.0) -1.0)+(num-test (* 0 1 0.0) 0.0)+(num-test (+ 0 1 1234) 1235)+(num-test (- 0 1 1234) -1235)+(num-test (* 0 1 1234) 0)+(num-test (/ 0 1 1234) 0)+(num-test (= 0 1 1234) #f)+(num-test (< 0 1 1234) #t)+(num-test (<= 0 1 1234) #t)+(num-test (> 0 1 1234) #f)+(num-test (>= 0 1 1234) #f)+(num-test (+ 0 1 123.4) 124.4)+(num-test (- 0 1 123.4) -124.4)+(num-test (* 0 1 123.4) 0.0)+(num-test (/ 0 1 123.4) 0.0)+(num-test (= 0 1 123.4) #f)+(num-test (< 0 1 123.4) #t)+(num-test (<= 0 1 123.4) #t)+(num-test (> 0 1 123.4) #f)+(num-test (>= 0 1 123.4) #f)+(num-test (+ 0 1 1234/11) 1245/11)+(num-test (- 0 1 1234/11) -1245/11)+(num-test (* 0 1 1234/11) 0)+(num-test (/ 0 1 1234/11) 0)+(num-test (= 0 1 1234/11) #f)+(num-test (< 0 1 1234/11) #t)+(num-test (<= 0 1 1234/11) #t)+(num-test (> 0 1 1234/11) #f)+(num-test (>= 0 1 1234/11) #f)+(num-test (+ 0 1 1.234+1.234i) 2.234+1.234i)+(num-test (- 0 1 1.234+1.234i) -2.234-1.234i)+(num-test (* 0 1 1.234+1.234i) 0.0)+(num-test (/ 0 1 1.234+1.234i) 0.0)+(num-test (= 0 1 1.234+1.234i) #f)+(num-test (+ 0 1 -1.0+1.0i) 0.0+1.0i)+(num-test (- 0 1 -1.0+1.0i) 0.0-1.0i)+(num-test (* 0 1 -1.0+1.0i) -0.0)+(num-test (/ 0 1 -1.0+1.0i) -0.0)+(num-test (= 0 1 -1.0+1.0i) #f)+(num-test (+ 0 1 0.0+1.0i) 1.0+1.0i)+(num-test (- 0 1 0.0+1.0i) -1.0-1.0i)+(num-test (* 0 1 0.0+1.0i) 0.0)+(num-test (/ 0 1 0.0+1.0i) 0.0)+(num-test (= 0 1 0.0+1.0i) #f)+(num-test (+ 0 1.0 1) 2.0)+(num-test (- 0 1.0 1) -2.0)+(num-test (* 0 1.0 1) 0.0)+(num-test (/ 0 1.0 1) 0.0)+(num-test (= 0 1.0 1) #f)+(num-test (< 0 1.0 1) #f)+(num-test (<= 0 1.0 1) #t)+(num-test (> 0 1.0 1) #f)+(num-test (>= 0 1.0 1) #f)+(num-test (+ 0 1.0 1.0) 2.0)+(num-test (- 0 1.0 1.0) -2.0)+(num-test (* 0 1.0 1.0) 0.0)+(num-test (/ 0 1.0 1.0) 0.0)+(num-test (= 0 1.0 1.0) #f)+(num-test (< 0 1.0 1.0) #f)+(num-test (<= 0 1.0 1.0) #t)+(num-test (> 0 1.0 1.0) #f)+(num-test (>= 0 1.0 1.0) #f)+(num-test (+ 0 1.0 1/1) 2.0)+(num-test (- 0 1.0 1/1) -2.0)+(num-test (* 0 1.0 1/1) 0.0)+(num-test (/ 0 1.0 1/1) 0.0)+(num-test (= 0 1.0 1/1) #f)+(num-test (< 0 1.0 1/1) #f)+(num-test (<= 0 1.0 1/1) #t)+(num-test (> 0 1.0 1/1) #f)+(num-test (>= 0 1.0 1/1) #f)+(num-test (+ 0 1.0 1.0+1.0i) 2.0+1.0i)+(num-test (- 0 1.0 1.0+1.0i) -2.0-1.0i)+(num-test (* 0 1.0 1.0+1.0i) 0.0)+(num-test (/ 0 1.0 1.0+1.0i) 0.0)+(num-test (= 0 1.0 1.0+1.0i) #f)+(num-test (+ 0 1.0 0) 1.0)+(num-test (- 0 1.0 0) -1.0)+(num-test (* 0 1.0 0) 0.0)+(num-test (+ 0 1.0 0.0) 1.0)+(num-test (- 0 1.0 0.0) -1.0)+(num-test (* 0 1.0 0.0) 0.0)+(num-test (+ 0 1.0 1234) 1235.0)+(num-test (- 0 1.0 1234) -1235.0)+(num-test (* 0 1.0 1234) 0.0)+(num-test (/ 0 1.0 1234) 0.0)+(num-test (= 0 1.0 1234) #f)+(num-test (< 0 1.0 1234) #t)+(num-test (<= 0 1.0 1234) #t)+(num-test (> 0 1.0 1234) #f)+(num-test (>= 0 1.0 1234) #f)+(num-test (+ 0 1.0 123.4) 124.4)+(num-test (- 0 1.0 123.4) -124.4)+(num-test (* 0 1.0 123.4) 0.0)+(num-test (/ 0 1.0 123.4) 0.0)+(num-test (= 0 1.0 123.4) #f)+(num-test (< 0 1.0 123.4) #t)+(num-test (<= 0 1.0 123.4) #t)+(num-test (> 0 1.0 123.4) #f)+(num-test (>= 0 1.0 123.4) #f)+(num-test (+ 0 1.0 1234/11) 113.18181818181819)+(num-test (- 0 1.0 1234/11) -113.18181818181819)+(num-test (* 0 1.0 1234/11) 0.0)+(num-test (/ 0 1.0 1234/11) 0.0)+(num-test (= 0 1.0 1234/11) #f)+(num-test (< 0 1.0 1234/11) #t)+(num-test (<= 0 1.0 1234/11) #t)+(num-test (> 0 1.0 1234/11) #f)+(num-test (>= 0 1.0 1234/11) #f)+(num-test (+ 0 1.0 1.234+1.234i) 2.234+1.234i)+(num-test (- 0 1.0 1.234+1.234i) -2.234-1.234i)+(num-test (* 0 1.0 1.234+1.234i) 0.0)+(num-test (/ 0 1.0 1.234+1.234i) 0.0)+(num-test (= 0 1.0 1.234+1.234i) #f)+(num-test (+ 0 1.0 -1.0+1.0i) 0.0+1.0i)+(num-test (- 0 1.0 -1.0+1.0i) 0.0-1.0i)+(num-test (* 0 1.0 -1.0+1.0i) -0.0)+(num-test (/ 0 1.0 -1.0+1.0i) -0.0)+(num-test (= 0 1.0 -1.0+1.0i) #f)+(num-test (+ 0 1.0 0.0+1.0i) 1.0+1.0i)+(num-test (- 0 1.0 0.0+1.0i) -1.0-1.0i)+(num-test (* 0 1.0 0.0+1.0i) 0.0)+(num-test (/ 0 1.0 0.0+1.0i) 0.0)+(num-test (= 0 1.0 0.0+1.0i) #f)+(num-test (+ 0 1/1 1) 2)+(num-test (- 0 1/1 1) -2)+(num-test (* 0 1/1 1) 0)+(num-test (/ 0 1/1 1) 0)+(num-test (= 0 1/1 1) #f)+(num-test (< 0 1/1 1) #f)+(num-test (<= 0 1/1 1) #t)+(num-test (> 0 1/1 1) #f)+(num-test (>= 0 1/1 1) #f)+(num-test (+ 0 1/1 1.0) 2.0)+(num-test (- 0 1/1 1.0) -2.0)+(num-test (* 0 1/1 1.0) 0.0)+(num-test (/ 0 1/1 1.0) 0.0)+(num-test (= 0 1/1 1.0) #f)+(num-test (< 0 1/1 1.0) #f)+(num-test (<= 0 1/1 1.0) #t)+(num-test (> 0 1/1 1.0) #f)+(num-test (>= 0 1/1 1.0) #f)+(num-test (+ 0 1/1 1/1) 2)+(num-test (- 0 1/1 1/1) -2)+(num-test (* 0 1/1 1/1) 0)+(num-test (/ 0 1/1 1/1) 0)+(num-test (= 0 1/1 1/1) #f)+(num-test (< 0 1/1 1/1) #f)+(num-test (<= 0 1/1 1/1) #t)+(num-test (> 0 1/1 1/1) #f)+(num-test (>= 0 1/1 1/1) #f)+(num-test (+ 0 1/1 1.0+1.0i) 2.0+1.0i)+(num-test (- 0 1/1 1.0+1.0i) -2.0-1.0i)+(num-test (* 0 1/1 1.0+1.0i) 0.0)+(num-test (/ 0 1/1 1.0+1.0i) 0.0)+(num-test (= 0 1/1 1.0+1.0i) #f)+(num-test (+ 0 1/1 0) 1)+(num-test (- 0 1/1 0) -1)+(num-test (* 0 1/1 0) 0)+(num-test (+ 0 1/1 0.0) 1.0)+(num-test (- 0 1/1 0.0) -1.0)+(num-test (* 0 1/1 0.0) 0.0)+(num-test (+ 0 1/1 1234) 1235)+(num-test (- 0 1/1 1234) -1235)+(num-test (* 0 1/1 1234) 0)+(num-test (/ 0 1/1 1234) 0)+(num-test (= 0 1/1 1234) #f)+(num-test (< 0 1/1 1234) #t)+(num-test (<= 0 1/1 1234) #t)+(num-test (> 0 1/1 1234) #f)+(num-test (>= 0 1/1 1234) #f)+(num-test (+ 0 1/1 123.4) 124.4)+(num-test (- 0 1/1 123.4) -124.4)+(num-test (* 0 1/1 123.4) 0.0)+(num-test (/ 0 1/1 123.4) 0.0)+(num-test (= 0 1/1 123.4) #f)+(num-test (< 0 1/1 123.4) #t)+(num-test (<= 0 1/1 123.4) #t)+(num-test (> 0 1/1 123.4) #f)+(num-test (>= 0 1/1 123.4) #f)+(num-test (+ 0 1/1 1234/11) 1245/11)+(num-test (- 0 1/1 1234/11) -1245/11)+(num-test (* 0 1/1 1234/11) 0)+(num-test (/ 0 1/1 1234/11) 0)+(num-test (= 0 1/1 1234/11) #f)+(num-test (< 0 1/1 1234/11) #t)+(num-test (<= 0 1/1 1234/11) #t)+(num-test (> 0 1/1 1234/11) #f)+(num-test (>= 0 1/1 1234/11) #f)+(num-test (+ 0 1/1 1.234+1.234i) 2.234+1.234i)+(num-test (- 0 1/1 1.234+1.234i) -2.234-1.234i)+(num-test (* 0 1/1 1.234+1.234i) 0.0)+(num-test (/ 0 1/1 1.234+1.234i) 0.0)+(num-test (= 0 1/1 1.234+1.234i) #f)+(num-test (+ 0 1/1 -1.0+1.0i) 0.0+1.0i)+(num-test (- 0 1/1 -1.0+1.0i) 0.0-1.0i)+(num-test (* 0 1/1 -1.0+1.0i) -0.0)+(num-test (/ 0 1/1 -1.0+1.0i) -0.0)+(num-test (= 0 1/1 -1.0+1.0i) #f)+(num-test (+ 0 1/1 0.0+1.0i) 1.0+1.0i)+(num-test (- 0 1/1 0.0+1.0i) -1.0-1.0i)+(num-test (* 0 1/1 0.0+1.0i) 0.0)+(num-test (/ 0 1/1 0.0+1.0i) 0.0)+(num-test (= 0 1/1 0.0+1.0i) #f)+(num-test (+ 0 1.0+1.0i 1) 2.0+1.0i)+(num-test (- 0 1.0+1.0i 1) -2.0-1.0i)+(num-test (* 0 1.0+1.0i 1) 0.0)+(num-test (/ 0 1.0+1.0i 1) 0.0)+(num-test (= 0 1.0+1.0i 1) #f)+(num-test (+ 0 1.0+1.0i 1.0) 2.0+1.0i)+(num-test (- 0 1.0+1.0i 1.0) -2.0-1.0i)+(num-test (* 0 1.0+1.0i 1.0) 0.0)+(num-test (/ 0 1.0+1.0i 1.0) 0.0)+(num-test (= 0 1.0+1.0i 1.0) #f)+(num-test (+ 0 1.0+1.0i 1/1) 2.0+1.0i)+(num-test (- 0 1.0+1.0i 1/1) -2.0-1.0i)+(num-test (* 0 1.0+1.0i 1/1) 0.0)+(num-test (/ 0 1.0+1.0i 1/1) 0.0)+(num-test (= 0 1.0+1.0i 1/1) #f)+(num-test (+ 0 1.0+1.0i 1.0+1.0i) 2.0+2.0i)+(num-test (- 0 1.0+1.0i 1.0+1.0i) -2.0-2.0i)+(num-test (* 0 1.0+1.0i 1.0+1.0i) 0.0)+(num-test (/ 0 1.0+1.0i 1.0+1.0i) 0.0)+(num-test (= 0 1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 0 1.0+1.0i 0) 1.0+1.0i)+(num-test (- 0 1.0+1.0i 0) -1.0-1.0i)+(num-test (* 0 1.0+1.0i 0) 0.0)+(num-test (+ 0 1.0+1.0i 0.0) 1.0+1.0i)+(num-test (- 0 1.0+1.0i 0.0) -1.0-1.0i)+(num-test (* 0 1.0+1.0i 0.0) 0.0)+(num-test (+ 0 1.0+1.0i 1234) 1235.0+1.0i)+(num-test (- 0 1.0+1.0i 1234) -1235.0-1.0i)+(num-test (* 0 1.0+1.0i 1234) 0.0)+(num-test (/ 0 1.0+1.0i 1234) 0.0)+(num-test (= 0 1.0+1.0i 1234) #f)+(num-test (+ 0 1.0+1.0i 123.4) 124.4+1.0i)+(num-test (- 0 1.0+1.0i 123.4) -124.4-1.0i)+(num-test (* 0 1.0+1.0i 123.4) 0.0)+(num-test (/ 0 1.0+1.0i 123.4) 0.0)+(num-test (= 0 1.0+1.0i 123.4) #f)+(num-test (+ 0 1.0+1.0i 1234/11) 113.18181818181819+1.0i)+(num-test (- 0 1.0+1.0i 1234/11) -113.18181818181819-1.0i)+(num-test (* 0 1.0+1.0i 1234/11) 0.0)+(num-test (/ 0 1.0+1.0i 1234/11) 0.0)+(num-test (= 0 1.0+1.0i 1234/11) #f)+(num-test (+ 0 1.0+1.0i 1.234+1.234i) 2.234+2.234i)+(num-test (- 0 1.0+1.0i 1.234+1.234i) -2.234-2.234i)+(num-test (* 0 1.0+1.0i 1.234+1.234i) 0.0)+(num-test (/ 0 1.0+1.0i 1.234+1.234i) 0.0)+(num-test (= 0 1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 0 1.0+1.0i -1.0+1.0i) 0.0+2.0i)+(num-test (- 0 1.0+1.0i -1.0+1.0i) 0.0-2.0i)+(num-test (* 0 1.0+1.0i -1.0+1.0i) -0.0)+(num-test (/ 0 1.0+1.0i -1.0+1.0i) -0.0)+(num-test (= 0 1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 0 1.0+1.0i 0.0+1.0i) 1.0+2.0i)+(num-test (- 0 1.0+1.0i 0.0+1.0i) -1.0-2.0i)+(num-test (* 0 1.0+1.0i 0.0+1.0i) 0.0)+(num-test (/ 0 1.0+1.0i 0.0+1.0i) 0.0)+(num-test (= 0 1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 0 0 1) 1)+(num-test (- 0 0 1) -1)+(num-test (* 0 0 1) 0)+(num-test (+ 0 0 1.0) 1.0)+(num-test (- 0 0 1.0) -1.0)+(num-test (* 0 0 1.0) 0.0)+(num-test (+ 0 0 1/1) 1)+(num-test (- 0 0 1/1) -1)+(num-test (* 0 0 1/1) 0)+(num-test (+ 0 0 1.0+1.0i) 1.0+1.0i)+(num-test (- 0 0 1.0+1.0i) -1.0-1.0i)+(num-test (* 0 0 1.0+1.0i) 0.0)+(num-test (+ 0 0 0) 0)+(num-test (- 0 0 0) 0)+(num-test (* 0 0 0) 0)+(num-test (+ 0 0 0.0) 0.0)+(num-test (- 0 0 0.0) 0.0)+(num-test (* 0 0 0.0) 0.0)+(num-test (+ 0 0 1234) 1234)+(num-test (- 0 0 1234) -1234)+(num-test (* 0 0 1234) 0)+(num-test (+ 0 0 123.4) 123.4)+(num-test (- 0 0 123.4) -123.4)+(num-test (* 0 0 123.4) 0.0)+(num-test (+ 0 0 1234/11) 1234/11)+(num-test (- 0 0 1234/11) -1234/11)+(num-test (* 0 0 1234/11) 0)+(num-test (+ 0 0 1.234+1.234i) 1.234+1.234i)+(num-test (- 0 0 1.234+1.234i) -1.234-1.234i)+(num-test (* 0 0 1.234+1.234i) 0.0)+(num-test (+ 0 0 -1.0+1.0i) -1.0+1.0i)+(num-test (- 0 0 -1.0+1.0i) 1.0-1.0i)+(num-test (* 0 0 -1.0+1.0i) -0.0)+(num-test (+ 0 0 0.0+1.0i) 0.0+1.0i)+(num-test (- 0 0 0.0+1.0i) 0.0-1.0i)+(num-test (* 0 0 0.0+1.0i) 0.0)+(num-test (+ 0 0.0 1) 1.0)+(num-test (- 0 0.0 1) -1.0)+(num-test (* 0 0.0 1) 0.0)+(num-test (+ 0 0.0 1.0) 1.0)+(num-test (- 0 0.0 1.0) -1.0)+(num-test (* 0 0.0 1.0) 0.0)+(num-test (+ 0 0.0 1/1) 1.0)+(num-test (- 0 0.0 1/1) -1.0)+(num-test (* 0 0.0 1/1) 0.0)+(num-test (+ 0 0.0 1.0+1.0i) 1.0+1.0i)+(num-test (- 0 0.0 1.0+1.0i) -1.0-1.0i)+(num-test (* 0 0.0 1.0+1.0i) 0.0)+(num-test (+ 0 0.0 0) 0.0)+(num-test (- 0 0.0 0) 0.0)+(num-test (* 0 0.0 0) 0.0)+(num-test (+ 0 0.0 0.0) 0.0)+(num-test (- 0 0.0 0.0) 0.0)+(num-test (* 0 0.0 0.0) 0.0)+(num-test (+ 0 0.0 1234) 1234.0)+(num-test (- 0 0.0 1234) -1234.0)+(num-test (* 0 0.0 1234) 0.0)+(num-test (+ 0 0.0 123.4) 123.4)+(num-test (- 0 0.0 123.4) -123.4)+(num-test (* 0 0.0 123.4) 0.0)+(num-test (+ 0 0.0 1234/11) 112.18181818181819)+(num-test (- 0 0.0 1234/11) -112.18181818181819)+(num-test (* 0 0.0 1234/11) 0.0)+(num-test (+ 0 0.0 1.234+1.234i) 1.234+1.234i)+(num-test (- 0 0.0 1.234+1.234i) -1.234-1.234i)+(num-test (* 0 0.0 1.234+1.234i) 0.0)+(num-test (+ 0 0.0 -1.0+1.0i) -1.0+1.0i)+(num-test (- 0 0.0 -1.0+1.0i) 1.0-1.0i)+(num-test (* 0 0.0 -1.0+1.0i) -0.0)+(num-test (+ 0 0.0 0.0+1.0i) 0.0+1.0i)+(num-test (- 0 0.0 0.0+1.0i) 0.0-1.0i)+(num-test (* 0 0.0 0.0+1.0i) 0.0)+(num-test (+ 0 1234 1) 1235)+(num-test (- 0 1234 1) -1235)+(num-test (* 0 1234 1) 0)+(num-test (/ 0 1234 1) 0)+(num-test (= 0 1234 1) #f)+(num-test (< 0 1234 1) #f)+(num-test (<= 0 1234 1) #f)+(num-test (> 0 1234 1) #f)+(num-test (>= 0 1234 1) #f)+(num-test (+ 0 1234 1.0) 1235.0)+(num-test (- 0 1234 1.0) -1235.0)+(num-test (* 0 1234 1.0) 0.0)+(num-test (/ 0 1234 1.0) 0.0)+(num-test (= 0 1234 1.0) #f)+(num-test (< 0 1234 1.0) #f)+(num-test (<= 0 1234 1.0) #f)+(num-test (> 0 1234 1.0) #f)+(num-test (>= 0 1234 1.0) #f)+(num-test (+ 0 1234 1/1) 1235)+(num-test (- 0 1234 1/1) -1235)+(num-test (* 0 1234 1/1) 0)+(num-test (/ 0 1234 1/1) 0)+(num-test (= 0 1234 1/1) #f)+(num-test (< 0 1234 1/1) #f)+(num-test (<= 0 1234 1/1) #f)+(num-test (> 0 1234 1/1) #f)+(num-test (>= 0 1234 1/1) #f)+(num-test (+ 0 1234 1.0+1.0i) 1235.0+1.0i)+(num-test (- 0 1234 1.0+1.0i) -1235.0-1.0i)+(num-test (* 0 1234 1.0+1.0i) 0.0)+(num-test (/ 0 1234 1.0+1.0i) 0.0)+(num-test (= 0 1234 1.0+1.0i) #f)+(num-test (+ 0 1234 0) 1234)+(num-test (- 0 1234 0) -1234)+(num-test (* 0 1234 0) 0)+(num-test (+ 0 1234 0.0) 1234.0)+(num-test (- 0 1234 0.0) -1234.0)+(num-test (* 0 1234 0.0) 0.0)+(num-test (+ 0 1234 1234) 2468)+(num-test (- 0 1234 1234) -2468)+(num-test (* 0 1234 1234) 0)+(num-test (/ 0 1234 1234) 0)+(num-test (= 0 1234 1234) #f)+(num-test (< 0 1234 1234) #f)+(num-test (<= 0 1234 1234) #t)+(num-test (> 0 1234 1234) #f)+(num-test (>= 0 1234 1234) #f)+(num-test (+ 0 1234 123.4) 1357.4)+(num-test (- 0 1234 123.4) -1357.4)+(num-test (* 0 1234 123.4) 0.0)+(num-test (/ 0 1234 123.4) 0.0)+(num-test (= 0 1234 123.4) #f)+(num-test (< 0 1234 123.4) #f)+(num-test (<= 0 1234 123.4) #f)+(num-test (> 0 1234 123.4) #f)+(num-test (>= 0 1234 123.4) #f)+(num-test (+ 0 1234 1234/11) 14808/11)+(num-test (- 0 1234 1234/11) -14808/11)+(num-test (* 0 1234 1234/11) 0)+(num-test (/ 0 1234 1234/11) 0)+(num-test (= 0 1234 1234/11) #f)+(num-test (< 0 1234 1234/11) #f)+(num-test (<= 0 1234 1234/11) #f)+(num-test (> 0 1234 1234/11) #f)+(num-test (>= 0 1234 1234/11) #f)+(num-test (+ 0 1234 1.234+1.234i) 1235.23399999999992+1.234i)+(num-test (- 0 1234 1.234+1.234i) -1235.23399999999992-1.234i)+(num-test (* 0 1234 1.234+1.234i) 0.0)+(num-test (/ 0 1234 1.234+1.234i) 0.0)+(num-test (= 0 1234 1.234+1.234i) #f)+(num-test (+ 0 1234 -1.0+1.0i) 1233.0+1.0i)+(num-test (- 0 1234 -1.0+1.0i) -1233.0-1.0i)+(num-test (* 0 1234 -1.0+1.0i) -0.0)+(num-test (/ 0 1234 -1.0+1.0i) -0.0)+(num-test (= 0 1234 -1.0+1.0i) #f)+(num-test (+ 0 1234 0.0+1.0i) 1234.0+1.0i)+(num-test (- 0 1234 0.0+1.0i) -1234.0-1.0i)+(num-test (* 0 1234 0.0+1.0i) 0.0)+(num-test (/ 0 1234 0.0+1.0i) 0.0)+(num-test (= 0 1234 0.0+1.0i) #f)+(num-test (+ 0 123.4 1) 124.4)+(num-test (- 0 123.4 1) -124.4)+(num-test (* 0 123.4 1) 0.0)+(num-test (/ 0 123.4 1) 0.0)+(num-test (= 0 123.4 1) #f)+(num-test (< 0 123.4 1) #f)+(num-test (<= 0 123.4 1) #f)+(num-test (> 0 123.4 1) #f)+(num-test (>= 0 123.4 1) #f)+(num-test (+ 0 123.4 1.0) 124.4)+(num-test (- 0 123.4 1.0) -124.4)+(num-test (* 0 123.4 1.0) 0.0)+(num-test (/ 0 123.4 1.0) 0.0)+(num-test (= 0 123.4 1.0) #f)+(num-test (< 0 123.4 1.0) #f)+(num-test (<= 0 123.4 1.0) #f)+(num-test (> 0 123.4 1.0) #f)+(num-test (>= 0 123.4 1.0) #f)+(num-test (+ 0 123.4 1/1) 124.4)+(num-test (- 0 123.4 1/1) -124.4)+(num-test (* 0 123.4 1/1) 0.0)+(num-test (/ 0 123.4 1/1) 0.0)+(num-test (= 0 123.4 1/1) #f)+(num-test (< 0 123.4 1/1) #f)+(num-test (<= 0 123.4 1/1) #f)+(num-test (> 0 123.4 1/1) #f)+(num-test (>= 0 123.4 1/1) #f)+(num-test (+ 0 123.4 1.0+1.0i) 124.4+1.0i)+(num-test (- 0 123.4 1.0+1.0i) -124.4-1.0i)+(num-test (* 0 123.4 1.0+1.0i) 0.0)+(num-test (/ 0 123.4 1.0+1.0i) 0.0)+(num-test (= 0 123.4 1.0+1.0i) #f)+(num-test (+ 0 123.4 0) 123.4)+(num-test (- 0 123.4 0) -123.4)+(num-test (* 0 123.4 0) 0.0)+(num-test (+ 0 123.4 0.0) 123.4)+(num-test (- 0 123.4 0.0) -123.4)+(num-test (* 0 123.4 0.0) 0.0)+(num-test (+ 0 123.4 1234) 1357.4)+(num-test (- 0 123.4 1234) -1357.4)+(num-test (* 0 123.4 1234) 0.0)+(num-test (/ 0 123.4 1234) 0.0)+(num-test (= 0 123.4 1234) #f)+(num-test (< 0 123.4 1234) #t)+(num-test (<= 0 123.4 1234) #t)+(num-test (> 0 123.4 1234) #f)+(num-test (>= 0 123.4 1234) #f)+(num-test (+ 0 123.4 123.4) 246.8)+(num-test (- 0 123.4 123.4) -246.8)+(num-test (* 0 123.4 123.4) 0.0)+(num-test (/ 0 123.4 123.4) 0.0)+(num-test (= 0 123.4 123.4) #f)+(num-test (< 0 123.4 123.4) #f)+(num-test (<= 0 123.4 123.4) #t)+(num-test (> 0 123.4 123.4) #f)+(num-test (>= 0 123.4 123.4) #f)+(num-test (+ 0 123.4 1234/11) 235.58181818181819)+(num-test (- 0 123.4 1234/11) -235.58181818181819)+(num-test (* 0 123.4 1234/11) 0.0)+(num-test (/ 0 123.4 1234/11) 0.0)+(num-test (= 0 123.4 1234/11) #f)+(num-test (< 0 123.4 1234/11) #f)+(num-test (<= 0 123.4 1234/11) #f)+(num-test (> 0 123.4 1234/11) #f)+(num-test (>= 0 123.4 1234/11) #f)+(num-test (+ 0 123.4 1.234+1.234i) 124.634+1.234i)+(num-test (- 0 123.4 1.234+1.234i) -124.634-1.234i)+(num-test (* 0 123.4 1.234+1.234i) 0.0)+(num-test (/ 0 123.4 1.234+1.234i) 0.0)+(num-test (= 0 123.4 1.234+1.234i) #f)+(num-test (+ 0 123.4 -1.0+1.0i) 122.4+1.0i)+(num-test (- 0 123.4 -1.0+1.0i) -122.4-1.0i)+(num-test (* 0 123.4 -1.0+1.0i) -0.0)+(num-test (/ 0 123.4 -1.0+1.0i) -0.0)+(num-test (= 0 123.4 -1.0+1.0i) #f)+(num-test (+ 0 123.4 0.0+1.0i) 123.4+1.0i)+(num-test (- 0 123.4 0.0+1.0i) -123.4-1.0i)+(num-test (* 0 123.4 0.0+1.0i) 0.0)+(num-test (/ 0 123.4 0.0+1.0i) 0.0)+(num-test (= 0 123.4 0.0+1.0i) #f)+(num-test (+ 0 1234/11 1) 1245/11)+(num-test (- 0 1234/11 1) -1245/11)+(num-test (* 0 1234/11 1) 0)+(num-test (/ 0 1234/11 1) 0)+(num-test (= 0 1234/11 1) #f)+(num-test (< 0 1234/11 1) #f)+(num-test (<= 0 1234/11 1) #f)+(num-test (> 0 1234/11 1) #f)+(num-test (>= 0 1234/11 1) #f)+(num-test (+ 0 1234/11 1.0) 113.18181818181819)+(num-test (- 0 1234/11 1.0) -113.18181818181819)+(num-test (* 0 1234/11 1.0) 0.0)+(num-test (/ 0 1234/11 1.0) 0.0)+(num-test (= 0 1234/11 1.0) #f)+(num-test (< 0 1234/11 1.0) #f)+(num-test (<= 0 1234/11 1.0) #f)+(num-test (> 0 1234/11 1.0) #f)+(num-test (>= 0 1234/11 1.0) #f)+(num-test (+ 0 1234/11 1/1) 1245/11)+(num-test (- 0 1234/11 1/1) -1245/11)+(num-test (* 0 1234/11 1/1) 0)+(num-test (/ 0 1234/11 1/1) 0)+(num-test (= 0 1234/11 1/1) #f)+(num-test (< 0 1234/11 1/1) #f)+(num-test (<= 0 1234/11 1/1) #f)+(num-test (> 0 1234/11 1/1) #f)+(num-test (>= 0 1234/11 1/1) #f)+(num-test (+ 0 1234/11 1.0+1.0i) 113.18181818181819+1.0i)+(num-test (- 0 1234/11 1.0+1.0i) -113.18181818181819-1.0i)+(num-test (* 0 1234/11 1.0+1.0i) 0.0)+(num-test (/ 0 1234/11 1.0+1.0i) 0.0)+(num-test (= 0 1234/11 1.0+1.0i) #f)+(num-test (+ 0 1234/11 0) 1234/11)+(num-test (- 0 1234/11 0) -1234/11)+(num-test (* 0 1234/11 0) 0)+(num-test (+ 0 1234/11 0.0) 112.18181818181819)+(num-test (- 0 1234/11 0.0) -112.18181818181819)+(num-test (* 0 1234/11 0.0) 0.0)+(num-test (+ 0 1234/11 1234) 14808/11)+(num-test (- 0 1234/11 1234) -14808/11)+(num-test (* 0 1234/11 1234) 0)+(num-test (/ 0 1234/11 1234) 0)+(num-test (= 0 1234/11 1234) #f)+(num-test (< 0 1234/11 1234) #t)+(num-test (<= 0 1234/11 1234) #t)+(num-test (> 0 1234/11 1234) #f)+(num-test (>= 0 1234/11 1234) #f)+(num-test (+ 0 1234/11 123.4) 235.58181818181819)+(num-test (- 0 1234/11 123.4) -235.58181818181819)+(num-test (* 0 1234/11 123.4) 0.0)+(num-test (/ 0 1234/11 123.4) 0.0)+(num-test (= 0 1234/11 123.4) #f)+(num-test (< 0 1234/11 123.4) #t)+(num-test (<= 0 1234/11 123.4) #t)+(num-test (> 0 1234/11 123.4) #f)+(num-test (>= 0 1234/11 123.4) #f)+(num-test (+ 0 1234/11 1234/11) 2468/11)+(num-test (- 0 1234/11 1234/11) -2468/11)+(num-test (* 0 1234/11 1234/11) 0)+(num-test (/ 0 1234/11 1234/11) 0)+(num-test (= 0 1234/11 1234/11) #f)+(num-test (< 0 1234/11 1234/11) #f)+(num-test (<= 0 1234/11 1234/11) #t)+(num-test (> 0 1234/11 1234/11) #f)+(num-test (>= 0 1234/11 1234/11) #f)+(num-test (+ 0 1234/11 1.234+1.234i) 113.41581818181818+1.234i)+(num-test (- 0 1234/11 1.234+1.234i) -113.41581818181818-1.234i)+(num-test (* 0 1234/11 1.234+1.234i) 0.0)+(num-test (/ 0 1234/11 1.234+1.234i) 0.0)+(num-test (= 0 1234/11 1.234+1.234i) #f)+(num-test (+ 0 1234/11 -1.0+1.0i) 111.18181818181819+1.0i)+(num-test (- 0 1234/11 -1.0+1.0i) -111.18181818181819-1.0i)+(num-test (* 0 1234/11 -1.0+1.0i) -0.0)+(num-test (/ 0 1234/11 -1.0+1.0i) -0.0)+(num-test (= 0 1234/11 -1.0+1.0i) #f)+(num-test (+ 0 1234/11 0.0+1.0i) 112.18181818181819+1.0i)+(num-test (- 0 1234/11 0.0+1.0i) -112.18181818181819-1.0i)+(num-test (* 0 1234/11 0.0+1.0i) 0.0)+(num-test (/ 0 1234/11 0.0+1.0i) 0.0)+(num-test (= 0 1234/11 0.0+1.0i) #f)+(num-test (+ 0 1.234+1.234i 1) 2.234+1.234i)+(num-test (- 0 1.234+1.234i 1) -2.234-1.234i)+(num-test (* 0 1.234+1.234i 1) 0.0)+(num-test (/ 0 1.234+1.234i 1) 0.0)+(num-test (= 0 1.234+1.234i 1) #f)+(num-test (+ 0 1.234+1.234i 1.0) 2.234+1.234i)+(num-test (- 0 1.234+1.234i 1.0) -2.234-1.234i)+(num-test (* 0 1.234+1.234i 1.0) 0.0)+(num-test (/ 0 1.234+1.234i 1.0) 0.0)+(num-test (= 0 1.234+1.234i 1.0) #f)+(num-test (+ 0 1.234+1.234i 1/1) 2.234+1.234i)+(num-test (- 0 1.234+1.234i 1/1) -2.234-1.234i)+(num-test (* 0 1.234+1.234i 1/1) 0.0)+(num-test (/ 0 1.234+1.234i 1/1) 0.0)+(num-test (= 0 1.234+1.234i 1/1) #f)+(num-test (+ 0 1.234+1.234i 1.0+1.0i) 2.234+2.234i)+(num-test (- 0 1.234+1.234i 1.0+1.0i) -2.234-2.234i)+(num-test (* 0 1.234+1.234i 1.0+1.0i) 0.0)+(num-test (/ 0 1.234+1.234i 1.0+1.0i) 0.0)+(num-test (= 0 1.234+1.234i 1.0+1.0i) #f)+(num-test (+ 0 1.234+1.234i 0) 1.234+1.234i)+(num-test (- 0 1.234+1.234i 0) -1.234-1.234i)+(num-test (* 0 1.234+1.234i 0) 0.0)+(num-test (+ 0 1.234+1.234i 0.0) 1.234+1.234i)+(num-test (- 0 1.234+1.234i 0.0) -1.234-1.234i)+(num-test (* 0 1.234+1.234i 0.0) 0.0)+(num-test (+ 0 1.234+1.234i 1234) 1235.23399999999992+1.234i)+(num-test (- 0 1.234+1.234i 1234) -1235.23399999999992-1.234i)+(num-test (* 0 1.234+1.234i 1234) 0.0)+(num-test (/ 0 1.234+1.234i 1234) 0.0)+(num-test (= 0 1.234+1.234i 1234) #f)+(num-test (+ 0 1.234+1.234i 123.4) 124.634+1.234i)+(num-test (- 0 1.234+1.234i 123.4) -124.634-1.234i)+(num-test (* 0 1.234+1.234i 123.4) 0.0)+(num-test (/ 0 1.234+1.234i 123.4) 0.0)+(num-test (= 0 1.234+1.234i 123.4) #f)+(num-test (+ 0 1.234+1.234i 1234/11) 113.41581818181818+1.234i)+(num-test (- 0 1.234+1.234i 1234/11) -113.41581818181818-1.234i)+(num-test (* 0 1.234+1.234i 1234/11) 0.0)+(num-test (/ 0 1.234+1.234i 1234/11) 0.0)+(num-test (= 0 1.234+1.234i 1234/11) #f)+(num-test (+ 0 1.234+1.234i 1.234+1.234i) 2.468+2.468i)+(num-test (- 0 1.234+1.234i 1.234+1.234i) -2.468-2.468i)+(num-test (* 0 1.234+1.234i 1.234+1.234i) 0.0)+(num-test (/ 0 1.234+1.234i 1.234+1.234i) 0.0)+(num-test (= 0 1.234+1.234i 1.234+1.234i) #f)+(num-test (+ 0 1.234+1.234i -1.0+1.0i) 0.234+2.234i)+(num-test (- 0 1.234+1.234i -1.0+1.0i) -0.234-2.234i)+(num-test (* 0 1.234+1.234i -1.0+1.0i) -0.0)+(num-test (/ 0 1.234+1.234i -1.0+1.0i) -0.0)+(num-test (= 0 1.234+1.234i -1.0+1.0i) #f)+(num-test (+ 0 1.234+1.234i 0.0+1.0i) 1.234+2.234i)+(num-test (- 0 1.234+1.234i 0.0+1.0i) -1.234-2.234i)+(num-test (* 0 1.234+1.234i 0.0+1.0i) 0.0)+(num-test (/ 0 1.234+1.234i 0.0+1.0i) 0.0)+(num-test (= 0 1.234+1.234i 0.0+1.0i) #f)+(num-test (+ 0 -1.0+1.0i 1) 0.0+1.0i)+(num-test (- 0 -1.0+1.0i 1) 0.0-1.0i)+(num-test (* 0 -1.0+1.0i 1) -0.0)+(num-test (/ 0 -1.0+1.0i 1) -0.0)+(num-test (= 0 -1.0+1.0i 1) #f)+(num-test (+ 0 -1.0+1.0i 1.0) 0.0+1.0i)+(num-test (- 0 -1.0+1.0i 1.0) 0.0-1.0i)+(num-test (* 0 -1.0+1.0i 1.0) -0.0)+(num-test (/ 0 -1.0+1.0i 1.0) -0.0)+(num-test (= 0 -1.0+1.0i 1.0) #f)+(num-test (+ 0 -1.0+1.0i 1/1) 0.0+1.0i)+(num-test (- 0 -1.0+1.0i 1/1) 0.0-1.0i)+(num-test (* 0 -1.0+1.0i 1/1) -0.0)+(num-test (/ 0 -1.0+1.0i 1/1) -0.0)+(num-test (= 0 -1.0+1.0i 1/1) #f)+(num-test (+ 0 -1.0+1.0i 1.0+1.0i) 0.0+2.0i)+(num-test (- 0 -1.0+1.0i 1.0+1.0i) 0.0-2.0i)+(num-test (* 0 -1.0+1.0i 1.0+1.0i) -0.0)+(num-test (/ 0 -1.0+1.0i 1.0+1.0i) -0.0)+(num-test (= 0 -1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 0 -1.0+1.0i 0) -1.0+1.0i)+(num-test (- 0 -1.0+1.0i 0) 1.0-1.0i)+(num-test (* 0 -1.0+1.0i 0) -0.0)+(num-test (+ 0 -1.0+1.0i 0.0) -1.0+1.0i)+(num-test (- 0 -1.0+1.0i 0.0) 1.0-1.0i)+(num-test (* 0 -1.0+1.0i 0.0) -0.0)+(num-test (+ 0 -1.0+1.0i 1234) 1233.0+1.0i)+(num-test (- 0 -1.0+1.0i 1234) -1233.0-1.0i)+(num-test (* 0 -1.0+1.0i 1234) -0.0)+(num-test (/ 0 -1.0+1.0i 1234) -0.0)+(num-test (= 0 -1.0+1.0i 1234) #f)+(num-test (+ 0 -1.0+1.0i 123.4) 122.4+1.0i)+(num-test (- 0 -1.0+1.0i 123.4) -122.4-1.0i)+(num-test (* 0 -1.0+1.0i 123.4) -0.0)+(num-test (/ 0 -1.0+1.0i 123.4) -0.0)+(num-test (= 0 -1.0+1.0i 123.4) #f)+(num-test (+ 0 -1.0+1.0i 1234/11) 111.18181818181819+1.0i)+(num-test (- 0 -1.0+1.0i 1234/11) -111.18181818181819-1.0i)+(num-test (* 0 -1.0+1.0i 1234/11) -0.0)+(num-test (/ 0 -1.0+1.0i 1234/11) -0.0)+(num-test (= 0 -1.0+1.0i 1234/11) #f)+(num-test (+ 0 -1.0+1.0i 1.234+1.234i) 0.234+2.234i)+(num-test (- 0 -1.0+1.0i 1.234+1.234i) -0.234-2.234i)+(num-test (* 0 -1.0+1.0i 1.234+1.234i) -0.0)+(num-test (/ 0 -1.0+1.0i 1.234+1.234i) -0.0)+(num-test (= 0 -1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 0 -1.0+1.0i -1.0+1.0i) -2.0+2.0i)+(num-test (- 0 -1.0+1.0i -1.0+1.0i) 2.0-2.0i)+(num-test (* 0 -1.0+1.0i -1.0+1.0i) 0.0)+(num-test (/ 0 -1.0+1.0i -1.0+1.0i) -0.0)+(num-test (= 0 -1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 0 -1.0+1.0i 0.0+1.0i) -1.0+2.0i)+(num-test (- 0 -1.0+1.0i 0.0+1.0i) 1.0-2.0i)+(num-test (* 0 -1.0+1.0i 0.0+1.0i) -0.0)+(num-test (/ 0 -1.0+1.0i 0.0+1.0i) -0.0)+(num-test (= 0 -1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 0 0.0+1.0i 1) 1.0+1.0i)+(num-test (- 0 0.0+1.0i 1) -1.0-1.0i)+(num-test (* 0 0.0+1.0i 1) 0.0)+(num-test (/ 0 0.0+1.0i 1) 0.0)+(num-test (= 0 0.0+1.0i 1) #f)+(num-test (+ 0 0.0+1.0i 1.0) 1.0+1.0i)+(num-test (- 0 0.0+1.0i 1.0) -1.0-1.0i)+(num-test (* 0 0.0+1.0i 1.0) 0.0)+(num-test (/ 0 0.0+1.0i 1.0) 0.0)+(num-test (= 0 0.0+1.0i 1.0) #f)+(num-test (+ 0 0.0+1.0i 1/1) 1.0+1.0i)+(num-test (- 0 0.0+1.0i 1/1) -1.0-1.0i)+(num-test (* 0 0.0+1.0i 1/1) 0.0)+(num-test (/ 0 0.0+1.0i 1/1) 0.0)+(num-test (= 0 0.0+1.0i 1/1) #f)+(num-test (+ 0 0.0+1.0i 1.0+1.0i) 1.0+2.0i)+(num-test (- 0 0.0+1.0i 1.0+1.0i) -1.0-2.0i)+(num-test (* 0 0.0+1.0i 1.0+1.0i) 0.0)+(num-test (/ 0 0.0+1.0i 1.0+1.0i) 0.0)+(num-test (= 0 0.0+1.0i 1.0+1.0i) #f)+(num-test (+ 0 0.0+1.0i 0) 0.0+1.0i)+(num-test (- 0 0.0+1.0i 0) 0.0-1.0i)+(num-test (* 0 0.0+1.0i 0) 0.0)+(num-test (+ 0 0.0+1.0i 0.0) 0.0+1.0i)+(num-test (- 0 0.0+1.0i 0.0) 0.0-1.0i)+(num-test (* 0 0.0+1.0i 0.0) 0.0)+(num-test (+ 0 0.0+1.0i 1234) 1234.0+1.0i)+(num-test (- 0 0.0+1.0i 1234) -1234.0-1.0i)+(num-test (* 0 0.0+1.0i 1234) 0.0)+(num-test (/ 0 0.0+1.0i 1234) 0.0)+(num-test (= 0 0.0+1.0i 1234) #f)+(num-test (+ 0 0.0+1.0i 123.4) 123.4+1.0i)+(num-test (- 0 0.0+1.0i 123.4) -123.4-1.0i)+(num-test (* 0 0.0+1.0i 123.4) 0.0)+(num-test (/ 0 0.0+1.0i 123.4) 0.0)+(num-test (= 0 0.0+1.0i 123.4) #f)+(num-test (+ 0 0.0+1.0i 1234/11) 112.18181818181819+1.0i)+(num-test (- 0 0.0+1.0i 1234/11) -112.18181818181819-1.0i)+(num-test (* 0 0.0+1.0i 1234/11) 0.0)+(num-test (/ 0 0.0+1.0i 1234/11) 0.0)+(num-test (= 0 0.0+1.0i 1234/11) #f)+(num-test (+ 0 0.0+1.0i 1.234+1.234i) 1.234+2.234i)+(num-test (- 0 0.0+1.0i 1.234+1.234i) -1.234-2.234i)+(num-test (* 0 0.0+1.0i 1.234+1.234i) 0.0)+(num-test (/ 0 0.0+1.0i 1.234+1.234i) 0.0)+(num-test (= 0 0.0+1.0i 1.234+1.234i) #f)+(num-test (+ 0 0.0+1.0i -1.0+1.0i) -1.0+2.0i)+(num-test (- 0 0.0+1.0i -1.0+1.0i) 1.0-2.0i)+(num-test (* 0 0.0+1.0i -1.0+1.0i) -0.0)+(num-test (/ 0 0.0+1.0i -1.0+1.0i) -0.0)+(num-test (= 0 0.0+1.0i -1.0+1.0i) #f)+(num-test (+ 0 0.0+1.0i 0.0+1.0i) 0.0+2.0i)+(num-test (- 0 0.0+1.0i 0.0+1.0i) 0.0-2.0i)+(num-test (* 0 0.0+1.0i 0.0+1.0i) 0.0)+(num-test (/ 0 0.0+1.0i 0.0+1.0i) 0.0)+(num-test (= 0 0.0+1.0i 0.0+1.0i) #f)+(num-test (+ 0.0 1 1) 2.0)+(num-test (- 0.0 1 1) -2.0)+(num-test (* 0.0 1 1) 0.0)+(num-test (/ 0.0 1 1) 0.0)+(num-test (= 0.0 1 1) #f)+(num-test (< 0.0 1 1) #f)+(num-test (<= 0.0 1 1) #t)+(num-test (> 0.0 1 1) #f)+(num-test (>= 0.0 1 1) #f)+(num-test (+ 0.0 1 1.0) 2.0)+(num-test (- 0.0 1 1.0) -2.0)+(num-test (* 0.0 1 1.0) 0.0)+(num-test (/ 0.0 1 1.0) 0.0)+(num-test (= 0.0 1 1.0) #f)+(num-test (< 0.0 1 1.0) #f)+(num-test (<= 0.0 1 1.0) #t)+(num-test (> 0.0 1 1.0) #f)+(num-test (>= 0.0 1 1.0) #f)+(num-test (+ 0.0 1 1/1) 2.0)+(num-test (- 0.0 1 1/1) -2.0)+(num-test (* 0.0 1 1/1) 0.0)+(num-test (/ 0.0 1 1/1) 0.0)+(num-test (= 0.0 1 1/1) #f)+(num-test (< 0.0 1 1/1) #f)+(num-test (<= 0.0 1 1/1) #t)+(num-test (> 0.0 1 1/1) #f)+(num-test (>= 0.0 1 1/1) #f)+(num-test (+ 0.0 1 1.0+1.0i) 2.0+1.0i)+(num-test (- 0.0 1 1.0+1.0i) -2.0-1.0i)+(num-test (* 0.0 1 1.0+1.0i) 0.0)+(num-test (/ 0.0 1 1.0+1.0i) 0.0)+(num-test (= 0.0 1 1.0+1.0i) #f)+(num-test (+ 0.0 1 0) 1.0)+(num-test (- 0.0 1 0) -1.0)+(num-test (* 0.0 1 0) 0.0)+(num-test (+ 0.0 1 0.0) 1.0)+(num-test (- 0.0 1 0.0) -1.0)+(num-test (* 0.0 1 0.0) 0.0)+(num-test (+ 0.0 1 1234) 1235.0)+(num-test (- 0.0 1 1234) -1235.0)+(num-test (* 0.0 1 1234) 0.0)+(num-test (/ 0.0 1 1234) 0.0)+(num-test (= 0.0 1 1234) #f)+(num-test (< 0.0 1 1234) #t)+(num-test (<= 0.0 1 1234) #t)+(num-test (> 0.0 1 1234) #f)+(num-test (>= 0.0 1 1234) #f)+(num-test (+ 0.0 1 123.4) 124.4)+(num-test (- 0.0 1 123.4) -124.4)+(num-test (* 0.0 1 123.4) 0.0)+(num-test (/ 0.0 1 123.4) 0.0)+(num-test (= 0.0 1 123.4) #f)+(num-test (< 0.0 1 123.4) #t)+(num-test (<= 0.0 1 123.4) #t)+(num-test (> 0.0 1 123.4) #f)+(num-test (>= 0.0 1 123.4) #f)+(num-test (+ 0.0 1 1234/11) 113.18181818181819)+(num-test (- 0.0 1 1234/11) -113.18181818181819)+(num-test (* 0.0 1 1234/11) 0.0)+(num-test (/ 0.0 1 1234/11) 0.0)+(num-test (= 0.0 1 1234/11) #f)+(num-test (< 0.0 1 1234/11) #t)+(num-test (<= 0.0 1 1234/11) #t)+(num-test (> 0.0 1 1234/11) #f)+(num-test (>= 0.0 1 1234/11) #f)+(num-test (+ 0.0 1 1.234+1.234i) 2.234+1.234i)+(num-test (- 0.0 1 1.234+1.234i) -2.234-1.234i)+(num-test (* 0.0 1 1.234+1.234i) 0.0)+(num-test (/ 0.0 1 1.234+1.234i) 0.0)+(num-test (= 0.0 1 1.234+1.234i) #f)+(num-test (+ 0.0 1 -1.0+1.0i) 0.0+1.0i)+(num-test (- 0.0 1 -1.0+1.0i) 0.0-1.0i)+(num-test (* 0.0 1 -1.0+1.0i) -0.0)+(num-test (/ 0.0 1 -1.0+1.0i) -0.0)+(num-test (= 0.0 1 -1.0+1.0i) #f)+(num-test (+ 0.0 1 0.0+1.0i) 1.0+1.0i)+(num-test (- 0.0 1 0.0+1.0i) -1.0-1.0i)+(num-test (* 0.0 1 0.0+1.0i) 0.0)+(num-test (/ 0.0 1 0.0+1.0i) 0.0)+(num-test (= 0.0 1 0.0+1.0i) #f)+(num-test (+ 0.0 1.0 1) 2.0)+(num-test (- 0.0 1.0 1) -2.0)+(num-test (* 0.0 1.0 1) 0.0)+(num-test (/ 0.0 1.0 1) 0.0)+(num-test (= 0.0 1.0 1) #f)+(num-test (< 0.0 1.0 1) #f)+(num-test (<= 0.0 1.0 1) #t)+(num-test (> 0.0 1.0 1) #f)+(num-test (>= 0.0 1.0 1) #f)+(num-test (+ 0.0 1.0 1.0) 2.0)+(num-test (- 0.0 1.0 1.0) -2.0)+(num-test (* 0.0 1.0 1.0) 0.0)+(num-test (/ 0.0 1.0 1.0) 0.0)+(num-test (= 0.0 1.0 1.0) #f)+(num-test (< 0.0 1.0 1.0) #f)+(num-test (<= 0.0 1.0 1.0) #t)+(num-test (> 0.0 1.0 1.0) #f)+(num-test (>= 0.0 1.0 1.0) #f)+(num-test (+ 0.0 1.0 1/1) 2.0)+(num-test (- 0.0 1.0 1/1) -2.0)+(num-test (* 0.0 1.0 1/1) 0.0)+(num-test (/ 0.0 1.0 1/1) 0.0)+(num-test (= 0.0 1.0 1/1) #f)+(num-test (< 0.0 1.0 1/1) #f)+(num-test (<= 0.0 1.0 1/1) #t)+(num-test (> 0.0 1.0 1/1) #f)+(num-test (>= 0.0 1.0 1/1) #f)+(num-test (+ 0.0 1.0 1.0+1.0i) 2.0+1.0i)+(num-test (- 0.0 1.0 1.0+1.0i) -2.0-1.0i)+(num-test (* 0.0 1.0 1.0+1.0i) 0.0)+(num-test (/ 0.0 1.0 1.0+1.0i) 0.0)+(num-test (= 0.0 1.0 1.0+1.0i) #f)+(num-test (+ 0.0 1.0 0) 1.0)+(num-test (- 0.0 1.0 0) -1.0)+(num-test (* 0.0 1.0 0) 0.0)+(num-test (+ 0.0 1.0 0.0) 1.0)+(num-test (- 0.0 1.0 0.0) -1.0)+(num-test (* 0.0 1.0 0.0) 0.0)+(num-test (+ 0.0 1.0 1234) 1235.0)+(num-test (- 0.0 1.0 1234) -1235.0)+(num-test (* 0.0 1.0 1234) 0.0)+(num-test (/ 0.0 1.0 1234) 0.0)+(num-test (= 0.0 1.0 1234) #f)+(num-test (< 0.0 1.0 1234) #t)+(num-test (<= 0.0 1.0 1234) #t)+(num-test (> 0.0 1.0 1234) #f)+(num-test (>= 0.0 1.0 1234) #f)+(num-test (+ 0.0 1.0 123.4) 124.4)+(num-test (- 0.0 1.0 123.4) -124.4)+(num-test (* 0.0 1.0 123.4) 0.0)+(num-test (/ 0.0 1.0 123.4) 0.0)+(num-test (= 0.0 1.0 123.4) #f)+(num-test (< 0.0 1.0 123.4) #t)+(num-test (<= 0.0 1.0 123.4) #t)+(num-test (> 0.0 1.0 123.4) #f)+(num-test (>= 0.0 1.0 123.4) #f)+(num-test (+ 0.0 1.0 1234/11) 113.18181818181819)+(num-test (- 0.0 1.0 1234/11) -113.18181818181819)+(num-test (* 0.0 1.0 1234/11) 0.0)+(num-test (/ 0.0 1.0 1234/11) 0.0)+(num-test (= 0.0 1.0 1234/11) #f)+(num-test (< 0.0 1.0 1234/11) #t)+(num-test (<= 0.0 1.0 1234/11) #t)+(num-test (> 0.0 1.0 1234/11) #f)+(num-test (>= 0.0 1.0 1234/11) #f)+(num-test (+ 0.0 1.0 1.234+1.234i) 2.234+1.234i)+(num-test (- 0.0 1.0 1.234+1.234i) -2.234-1.234i)+(num-test (* 0.0 1.0 1.234+1.234i) 0.0)+(num-test (/ 0.0 1.0 1.234+1.234i) 0.0)+(num-test (= 0.0 1.0 1.234+1.234i) #f)+(num-test (+ 0.0 1.0 -1.0+1.0i) 0.0+1.0i)+(num-test (- 0.0 1.0 -1.0+1.0i) 0.0-1.0i)+(num-test (* 0.0 1.0 -1.0+1.0i) -0.0)+(num-test (/ 0.0 1.0 -1.0+1.0i) -0.0)+(num-test (= 0.0 1.0 -1.0+1.0i) #f)+(num-test (+ 0.0 1.0 0.0+1.0i) 1.0+1.0i)+(num-test (- 0.0 1.0 0.0+1.0i) -1.0-1.0i)+(num-test (* 0.0 1.0 0.0+1.0i) 0.0)+(num-test (/ 0.0 1.0 0.0+1.0i) 0.0)+(num-test (= 0.0 1.0 0.0+1.0i) #f)+(num-test (+ 0.0 1/1 1) 2.0)+(num-test (- 0.0 1/1 1) -2.0)+(num-test (* 0.0 1/1 1) 0.0)+(num-test (/ 0.0 1/1 1) 0.0)+(num-test (= 0.0 1/1 1) #f)+(num-test (< 0.0 1/1 1) #f)+(num-test (<= 0.0 1/1 1) #t)+(num-test (> 0.0 1/1 1) #f)+(num-test (>= 0.0 1/1 1) #f)+(num-test (+ 0.0 1/1 1.0) 2.0)+(num-test (- 0.0 1/1 1.0) -2.0)+(num-test (* 0.0 1/1 1.0) 0.0)+(num-test (/ 0.0 1/1 1.0) 0.0)+(num-test (= 0.0 1/1 1.0) #f)+(num-test (< 0.0 1/1 1.0) #f)+(num-test (<= 0.0 1/1 1.0) #t)+(num-test (> 0.0 1/1 1.0) #f)+(num-test (>= 0.0 1/1 1.0) #f)+(num-test (+ 0.0 1/1 1/1) 2.0)+(num-test (- 0.0 1/1 1/1) -2.0)+(num-test (* 0.0 1/1 1/1) 0.0)+(num-test (/ 0.0 1/1 1/1) 0.0)+(num-test (= 0.0 1/1 1/1) #f)+(num-test (< 0.0 1/1 1/1) #f)+(num-test (<= 0.0 1/1 1/1) #t)+(num-test (> 0.0 1/1 1/1) #f)+(num-test (>= 0.0 1/1 1/1) #f)+(num-test (+ 0.0 1/1 1.0+1.0i) 2.0+1.0i)+(num-test (- 0.0 1/1 1.0+1.0i) -2.0-1.0i)+(num-test (* 0.0 1/1 1.0+1.0i) 0.0)+(num-test (/ 0.0 1/1 1.0+1.0i) 0.0)+(num-test (= 0.0 1/1 1.0+1.0i) #f)+(num-test (+ 0.0 1/1 0) 1.0)+(num-test (- 0.0 1/1 0) -1.0)+(num-test (* 0.0 1/1 0) 0.0)+(num-test (+ 0.0 1/1 0.0) 1.0)+(num-test (- 0.0 1/1 0.0) -1.0)+(num-test (* 0.0 1/1 0.0) 0.0)+(num-test (+ 0.0 1/1 1234) 1235.0)+(num-test (- 0.0 1/1 1234) -1235.0)+(num-test (* 0.0 1/1 1234) 0.0)+(num-test (/ 0.0 1/1 1234) 0.0)+(num-test (= 0.0 1/1 1234) #f)+(num-test (< 0.0 1/1 1234) #t)+(num-test (<= 0.0 1/1 1234) #t)+(num-test (> 0.0 1/1 1234) #f)+(num-test (>= 0.0 1/1 1234) #f)+(num-test (+ 0.0 1/1 123.4) 124.4)+(num-test (- 0.0 1/1 123.4) -124.4)+(num-test (* 0.0 1/1 123.4) 0.0)+(num-test (/ 0.0 1/1 123.4) 0.0)+(num-test (= 0.0 1/1 123.4) #f)+(num-test (< 0.0 1/1 123.4) #t)+(num-test (<= 0.0 1/1 123.4) #t)+(num-test (> 0.0 1/1 123.4) #f)+(num-test (>= 0.0 1/1 123.4) #f)+(num-test (+ 0.0 1/1 1234/11) 113.18181818181819)+(num-test (- 0.0 1/1 1234/11) -113.18181818181819)+(num-test (* 0.0 1/1 1234/11) 0.0)+(num-test (/ 0.0 1/1 1234/11) 0.0)+(num-test (= 0.0 1/1 1234/11) #f)+(num-test (< 0.0 1/1 1234/11) #t)+(num-test (<= 0.0 1/1 1234/11) #t)+(num-test (> 0.0 1/1 1234/11) #f)+(num-test (>= 0.0 1/1 1234/11) #f)+(num-test (+ 0.0 1/1 1.234+1.234i) 2.234+1.234i)+(num-test (- 0.0 1/1 1.234+1.234i) -2.234-1.234i)+(num-test (* 0.0 1/1 1.234+1.234i) 0.0)+(num-test (/ 0.0 1/1 1.234+1.234i) 0.0)+(num-test (= 0.0 1/1 1.234+1.234i) #f)+(num-test (+ 0.0 1/1 -1.0+1.0i) 0.0+1.0i)+(num-test (- 0.0 1/1 -1.0+1.0i) 0.0-1.0i)+(num-test (* 0.0 1/1 -1.0+1.0i) -0.0)+(num-test (/ 0.0 1/1 -1.0+1.0i) -0.0)+(num-test (= 0.0 1/1 -1.0+1.0i) #f)+(num-test (+ 0.0 1/1 0.0+1.0i) 1.0+1.0i)+(num-test (- 0.0 1/1 0.0+1.0i) -1.0-1.0i)+(num-test (* 0.0 1/1 0.0+1.0i) 0.0)+(num-test (/ 0.0 1/1 0.0+1.0i) 0.0)+(num-test (= 0.0 1/1 0.0+1.0i) #f)+(num-test (+ 0.0 1.0+1.0i 1) 2.0+1.0i)+(num-test (- 0.0 1.0+1.0i 1) -2.0-1.0i)+(num-test (* 0.0 1.0+1.0i 1) 0.0)+(num-test (/ 0.0 1.0+1.0i 1) 0.0)+(num-test (= 0.0 1.0+1.0i 1) #f)+(num-test (+ 0.0 1.0+1.0i 1.0) 2.0+1.0i)+(num-test (- 0.0 1.0+1.0i 1.0) -2.0-1.0i)+(num-test (* 0.0 1.0+1.0i 1.0) 0.0)+(num-test (/ 0.0 1.0+1.0i 1.0) 0.0)+(num-test (= 0.0 1.0+1.0i 1.0) #f)+(num-test (+ 0.0 1.0+1.0i 1/1) 2.0+1.0i)+(num-test (- 0.0 1.0+1.0i 1/1) -2.0-1.0i)+(num-test (* 0.0 1.0+1.0i 1/1) 0.0)+(num-test (/ 0.0 1.0+1.0i 1/1) 0.0)+(num-test (= 0.0 1.0+1.0i 1/1) #f)+(num-test (+ 0.0 1.0+1.0i 1.0+1.0i) 2.0+2.0i)+(num-test (- 0.0 1.0+1.0i 1.0+1.0i) -2.0-2.0i)+(num-test (* 0.0 1.0+1.0i 1.0+1.0i) 0.0)+(num-test (/ 0.0 1.0+1.0i 1.0+1.0i) 0.0)+(num-test (= 0.0 1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 0.0 1.0+1.0i 0) 1.0+1.0i)+(num-test (- 0.0 1.0+1.0i 0) -1.0-1.0i)+(num-test (* 0.0 1.0+1.0i 0) 0.0)+(num-test (+ 0.0 1.0+1.0i 0.0) 1.0+1.0i)+(num-test (- 0.0 1.0+1.0i 0.0) -1.0-1.0i)+(num-test (* 0.0 1.0+1.0i 0.0) 0.0)+(num-test (+ 0.0 1.0+1.0i 1234) 1235.0+1.0i)+(num-test (- 0.0 1.0+1.0i 1234) -1235.0-1.0i)+(num-test (* 0.0 1.0+1.0i 1234) 0.0)+(num-test (/ 0.0 1.0+1.0i 1234) 0.0)+(num-test (= 0.0 1.0+1.0i 1234) #f)+(num-test (+ 0.0 1.0+1.0i 123.4) 124.4+1.0i)+(num-test (- 0.0 1.0+1.0i 123.4) -124.4-1.0i)+(num-test (* 0.0 1.0+1.0i 123.4) 0.0)+(num-test (/ 0.0 1.0+1.0i 123.4) 0.0)+(num-test (= 0.0 1.0+1.0i 123.4) #f)+(num-test (+ 0.0 1.0+1.0i 1234/11) 113.18181818181819+1.0i)+(num-test (- 0.0 1.0+1.0i 1234/11) -113.18181818181819-1.0i)+(num-test (* 0.0 1.0+1.0i 1234/11) 0.0)+(num-test (/ 0.0 1.0+1.0i 1234/11) 0.0)+(num-test (= 0.0 1.0+1.0i 1234/11) #f)+(num-test (+ 0.0 1.0+1.0i 1.234+1.234i) 2.234+2.234i)+(num-test (- 0.0 1.0+1.0i 1.234+1.234i) -2.234-2.234i)+(num-test (* 0.0 1.0+1.0i 1.234+1.234i) 0.0)+(num-test (/ 0.0 1.0+1.0i 1.234+1.234i) 0.0)+(num-test (= 0.0 1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 0.0 1.0+1.0i -1.0+1.0i) 0.0+2.0i)+(num-test (- 0.0 1.0+1.0i -1.0+1.0i) 0.0-2.0i)+(num-test (* 0.0 1.0+1.0i -1.0+1.0i) -0.0)+(num-test (/ 0.0 1.0+1.0i -1.0+1.0i) -0.0)+(num-test (= 0.0 1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 0.0 1.0+1.0i 0.0+1.0i) 1.0+2.0i)+(num-test (- 0.0 1.0+1.0i 0.0+1.0i) -1.0-2.0i)+(num-test (* 0.0 1.0+1.0i 0.0+1.0i) 0.0)+(num-test (/ 0.0 1.0+1.0i 0.0+1.0i) 0.0)+(num-test (= 0.0 1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 0.0 0 1) 1.0)+(num-test (- 0.0 0 1) -1.0)+(num-test (* 0.0 0 1) 0.0)+(num-test (+ 0.0 0 1.0) 1.0)+(num-test (- 0.0 0 1.0) -1.0)+(num-test (* 0.0 0 1.0) 0.0)+(num-test (+ 0.0 0 1/1) 1.0)+(num-test (- 0.0 0 1/1) -1.0)+(num-test (* 0.0 0 1/1) 0.0)+(num-test (+ 0.0 0 1.0+1.0i) 1.0+1.0i)+(num-test (- 0.0 0 1.0+1.0i) -1.0-1.0i)+(num-test (* 0.0 0 1.0+1.0i) 0.0)+(num-test (+ 0.0 0 0) 0.0)+(num-test (- 0.0 0 0) 0.0)+(num-test (* 0.0 0 0) 0.0)+(num-test (+ 0.0 0 0.0) 0.0)+(num-test (- 0.0 0 0.0) 0.0)+(num-test (* 0.0 0 0.0) 0.0)+(num-test (+ 0.0 0 1234) 1234.0)+(num-test (- 0.0 0 1234) -1234.0)+(num-test (* 0.0 0 1234) 0.0)+(num-test (+ 0.0 0 123.4) 123.4)+(num-test (- 0.0 0 123.4) -123.4)+(num-test (* 0.0 0 123.4) 0.0)+(num-test (+ 0.0 0 1234/11) 112.18181818181819)+(num-test (- 0.0 0 1234/11) -112.18181818181819)+(num-test (* 0.0 0 1234/11) 0.0)+(num-test (+ 0.0 0 1.234+1.234i) 1.234+1.234i)+(num-test (- 0.0 0 1.234+1.234i) -1.234-1.234i)+(num-test (* 0.0 0 1.234+1.234i) 0.0)+(num-test (+ 0.0 0 -1.0+1.0i) -1.0+1.0i)+(num-test (- 0.0 0 -1.0+1.0i) 1.0-1.0i)+(num-test (* 0.0 0 -1.0+1.0i) -0.0)+(num-test (+ 0.0 0 0.0+1.0i) 0.0+1.0i)+(num-test (- 0.0 0 0.0+1.0i) 0.0-1.0i)+(num-test (* 0.0 0 0.0+1.0i) 0.0)+(num-test (+ 0.0 0.0 1) 1.0)+(num-test (- 0.0 0.0 1) -1.0)+(num-test (* 0.0 0.0 1) 0.0)+(num-test (+ 0.0 0.0 1.0) 1.0)+(num-test (- 0.0 0.0 1.0) -1.0)+(num-test (* 0.0 0.0 1.0) 0.0)+(num-test (+ 0.0 0.0 1/1) 1.0)+(num-test (- 0.0 0.0 1/1) -1.0)+(num-test (* 0.0 0.0 1/1) 0.0)+(num-test (+ 0.0 0.0 1.0+1.0i) 1.0+1.0i)+(num-test (- 0.0 0.0 1.0+1.0i) -1.0-1.0i)+(num-test (* 0.0 0.0 1.0+1.0i) 0.0)+(num-test (+ 0.0 0.0 0) 0.0)+(num-test (- 0.0 0.0 0) 0.0)+(num-test (* 0.0 0.0 0) 0.0)+(num-test (+ 0.0 0.0 0.0) 0.0)+(num-test (- 0.0 0.0 0.0) 0.0)+(num-test (* 0.0 0.0 0.0) 0.0)+(num-test (+ 0.0 0.0 1234) 1234.0)+(num-test (- 0.0 0.0 1234) -1234.0)+(num-test (* 0.0 0.0 1234) 0.0)+(num-test (+ 0.0 0.0 123.4) 123.4)+(num-test (- 0.0 0.0 123.4) -123.4)+(num-test (* 0.0 0.0 123.4) 0.0)+(num-test (+ 0.0 0.0 1234/11) 112.18181818181819)+(num-test (- 0.0 0.0 1234/11) -112.18181818181819)+(num-test (* 0.0 0.0 1234/11) 0.0)+(num-test (+ 0.0 0.0 1.234+1.234i) 1.234+1.234i)+(num-test (- 0.0 0.0 1.234+1.234i) -1.234-1.234i)+(num-test (* 0.0 0.0 1.234+1.234i) 0.0)+(num-test (+ 0.0 0.0 -1.0+1.0i) -1.0+1.0i)+(num-test (- 0.0 0.0 -1.0+1.0i) 1.0-1.0i)+(num-test (* 0.0 0.0 -1.0+1.0i) -0.0)+(num-test (+ 0.0 0.0 0.0+1.0i) 0.0+1.0i)+(num-test (- 0.0 0.0 0.0+1.0i) 0.0-1.0i)+(num-test (* 0.0 0.0 0.0+1.0i) 0.0)+(num-test (+ 0.0 1234 1) 1235.0)+(num-test (- 0.0 1234 1) -1235.0)+(num-test (* 0.0 1234 1) 0.0)+(num-test (/ 0.0 1234 1) 0.0)+(num-test (= 0.0 1234 1) #f)+(num-test (< 0.0 1234 1) #f)+(num-test (<= 0.0 1234 1) #f)+(num-test (> 0.0 1234 1) #f)+(num-test (>= 0.0 1234 1) #f)+(num-test (+ 0.0 1234 1.0) 1235.0)+(num-test (- 0.0 1234 1.0) -1235.0)+(num-test (* 0.0 1234 1.0) 0.0)+(num-test (/ 0.0 1234 1.0) 0.0)+(num-test (= 0.0 1234 1.0) #f)+(num-test (< 0.0 1234 1.0) #f)+(num-test (<= 0.0 1234 1.0) #f)+(num-test (> 0.0 1234 1.0) #f)+(num-test (>= 0.0 1234 1.0) #f)+(num-test (+ 0.0 1234 1/1) 1235.0)+(num-test (- 0.0 1234 1/1) -1235.0)+(num-test (* 0.0 1234 1/1) 0.0)+(num-test (/ 0.0 1234 1/1) 0.0)+(num-test (= 0.0 1234 1/1) #f)+(num-test (< 0.0 1234 1/1) #f)+(num-test (<= 0.0 1234 1/1) #f)+(num-test (> 0.0 1234 1/1) #f)+(num-test (>= 0.0 1234 1/1) #f)+(num-test (+ 0.0 1234 1.0+1.0i) 1235.0+1.0i)+(num-test (- 0.0 1234 1.0+1.0i) -1235.0-1.0i)+(num-test (* 0.0 1234 1.0+1.0i) 0.0)+(num-test (/ 0.0 1234 1.0+1.0i) 0.0)+(num-test (= 0.0 1234 1.0+1.0i) #f)+(num-test (+ 0.0 1234 0) 1234.0)+(num-test (- 0.0 1234 0) -1234.0)+(num-test (* 0.0 1234 0) 0.0)+(num-test (+ 0.0 1234 0.0) 1234.0)+(num-test (- 0.0 1234 0.0) -1234.0)+(num-test (* 0.0 1234 0.0) 0.0)+(num-test (+ 0.0 1234 1234) 2468.0)+(num-test (- 0.0 1234 1234) -2468.0)+(num-test (* 0.0 1234 1234) 0.0)+(num-test (/ 0.0 1234 1234) 0.0)+(num-test (= 0.0 1234 1234) #f)+(num-test (< 0.0 1234 1234) #f)+(num-test (<= 0.0 1234 1234) #t)+(num-test (> 0.0 1234 1234) #f)+(num-test (>= 0.0 1234 1234) #f)+(num-test (+ 0.0 1234 123.4) 1357.4)+(num-test (- 0.0 1234 123.4) -1357.4)+(num-test (* 0.0 1234 123.4) 0.0)+(num-test (/ 0.0 1234 123.4) 0.0)+(num-test (= 0.0 1234 123.4) #f)+(num-test (< 0.0 1234 123.4) #f)+(num-test (<= 0.0 1234 123.4) #f)+(num-test (> 0.0 1234 123.4) #f)+(num-test (>= 0.0 1234 123.4) #f)+(num-test (+ 0.0 1234 1234/11) 1346.18181818181824)+(num-test (- 0.0 1234 1234/11) -1346.18181818181824)+(num-test (* 0.0 1234 1234/11) 0.0)+(num-test (/ 0.0 1234 1234/11) 0.0)+(num-test (= 0.0 1234 1234/11) #f)+(num-test (< 0.0 1234 1234/11) #f)+(num-test (<= 0.0 1234 1234/11) #f)+(num-test (> 0.0 1234 1234/11) #f)+(num-test (>= 0.0 1234 1234/11) #f)+(num-test (+ 0.0 1234 1.234+1.234i) 1235.23399999999992+1.234i)+(num-test (- 0.0 1234 1.234+1.234i) -1235.23399999999992-1.234i)+(num-test (* 0.0 1234 1.234+1.234i) 0.0)+(num-test (/ 0.0 1234 1.234+1.234i) 0.0)+(num-test (= 0.0 1234 1.234+1.234i) #f)+(num-test (+ 0.0 1234 -1.0+1.0i) 1233.0+1.0i)+(num-test (- 0.0 1234 -1.0+1.0i) -1233.0-1.0i)+(num-test (* 0.0 1234 -1.0+1.0i) -0.0)+(num-test (/ 0.0 1234 -1.0+1.0i) -0.0)+(num-test (= 0.0 1234 -1.0+1.0i) #f)+(num-test (+ 0.0 1234 0.0+1.0i) 1234.0+1.0i)+(num-test (- 0.0 1234 0.0+1.0i) -1234.0-1.0i)+(num-test (* 0.0 1234 0.0+1.0i) 0.0)+(num-test (/ 0.0 1234 0.0+1.0i) 0.0)+(num-test (= 0.0 1234 0.0+1.0i) #f)+(num-test (+ 0.0 123.4 1) 124.4)+(num-test (- 0.0 123.4 1) -124.4)+(num-test (* 0.0 123.4 1) 0.0)+(num-test (/ 0.0 123.4 1) 0.0)+(num-test (= 0.0 123.4 1) #f)+(num-test (< 0.0 123.4 1) #f)+(num-test (<= 0.0 123.4 1) #f)+(num-test (> 0.0 123.4 1) #f)+(num-test (>= 0.0 123.4 1) #f)+(num-test (+ 0.0 123.4 1.0) 124.4)+(num-test (- 0.0 123.4 1.0) -124.4)+(num-test (* 0.0 123.4 1.0) 0.0)+(num-test (/ 0.0 123.4 1.0) 0.0)+(num-test (= 0.0 123.4 1.0) #f)+(num-test (< 0.0 123.4 1.0) #f)+(num-test (<= 0.0 123.4 1.0) #f)+(num-test (> 0.0 123.4 1.0) #f)+(num-test (>= 0.0 123.4 1.0) #f)+(num-test (+ 0.0 123.4 1/1) 124.4)+(num-test (- 0.0 123.4 1/1) -124.4)+(num-test (* 0.0 123.4 1/1) 0.0)+(num-test (/ 0.0 123.4 1/1) 0.0)+(num-test (= 0.0 123.4 1/1) #f)+(num-test (< 0.0 123.4 1/1) #f)+(num-test (<= 0.0 123.4 1/1) #f)+(num-test (> 0.0 123.4 1/1) #f)+(num-test (>= 0.0 123.4 1/1) #f)+(num-test (+ 0.0 123.4 1.0+1.0i) 124.4+1.0i)+(num-test (- 0.0 123.4 1.0+1.0i) -124.4-1.0i)+(num-test (* 0.0 123.4 1.0+1.0i) 0.0)+(num-test (/ 0.0 123.4 1.0+1.0i) 0.0)+(num-test (= 0.0 123.4 1.0+1.0i) #f)+(num-test (+ 0.0 123.4 0) 123.4)+(num-test (- 0.0 123.4 0) -123.4)+(num-test (* 0.0 123.4 0) 0.0)+(num-test (+ 0.0 123.4 0.0) 123.4)+(num-test (- 0.0 123.4 0.0) -123.4)+(num-test (* 0.0 123.4 0.0) 0.0)+(num-test (+ 0.0 123.4 1234) 1357.4)+(num-test (- 0.0 123.4 1234) -1357.4)+(num-test (* 0.0 123.4 1234) 0.0)+(num-test (/ 0.0 123.4 1234) 0.0)+(num-test (= 0.0 123.4 1234) #f)+(num-test (< 0.0 123.4 1234) #t)+(num-test (<= 0.0 123.4 1234) #t)+(num-test (> 0.0 123.4 1234) #f)+(num-test (>= 0.0 123.4 1234) #f)+(num-test (+ 0.0 123.4 123.4) 246.8)+(num-test (- 0.0 123.4 123.4) -246.8)+(num-test (* 0.0 123.4 123.4) 0.0)+(num-test (/ 0.0 123.4 123.4) 0.0)+(num-test (= 0.0 123.4 123.4) #f)+(num-test (< 0.0 123.4 123.4) #f)+(num-test (<= 0.0 123.4 123.4) #t)+(num-test (> 0.0 123.4 123.4) #f)+(num-test (>= 0.0 123.4 123.4) #f)+(num-test (+ 0.0 123.4 1234/11) 235.58181818181819)+(num-test (- 0.0 123.4 1234/11) -235.58181818181819)+(num-test (* 0.0 123.4 1234/11) 0.0)+(num-test (/ 0.0 123.4 1234/11) 0.0)+(num-test (= 0.0 123.4 1234/11) #f)+(num-test (< 0.0 123.4 1234/11) #f)+(num-test (<= 0.0 123.4 1234/11) #f)+(num-test (> 0.0 123.4 1234/11) #f)+(num-test (>= 0.0 123.4 1234/11) #f)+(num-test (+ 0.0 123.4 1.234+1.234i) 124.634+1.234i)+(num-test (- 0.0 123.4 1.234+1.234i) -124.634-1.234i)+(num-test (* 0.0 123.4 1.234+1.234i) 0.0)+(num-test (/ 0.0 123.4 1.234+1.234i) 0.0)+(num-test (= 0.0 123.4 1.234+1.234i) #f)+(num-test (+ 0.0 123.4 -1.0+1.0i) 122.4+1.0i)+(num-test (- 0.0 123.4 -1.0+1.0i) -122.4-1.0i)+(num-test (* 0.0 123.4 -1.0+1.0i) -0.0)+(num-test (/ 0.0 123.4 -1.0+1.0i) -0.0)+(num-test (= 0.0 123.4 -1.0+1.0i) #f)+(num-test (+ 0.0 123.4 0.0+1.0i) 123.4+1.0i)+(num-test (- 0.0 123.4 0.0+1.0i) -123.4-1.0i)+(num-test (* 0.0 123.4 0.0+1.0i) 0.0)+(num-test (/ 0.0 123.4 0.0+1.0i) 0.0)+(num-test (= 0.0 123.4 0.0+1.0i) #f)+(num-test (+ 0.0 1234/11 1) 113.18181818181819)+(num-test (- 0.0 1234/11 1) -113.18181818181819)+(num-test (* 0.0 1234/11 1) 0.0)+(num-test (/ 0.0 1234/11 1) 0.0)+(num-test (= 0.0 1234/11 1) #f)+(num-test (< 0.0 1234/11 1) #f)+(num-test (<= 0.0 1234/11 1) #f)+(num-test (> 0.0 1234/11 1) #f)+(num-test (>= 0.0 1234/11 1) #f)+(num-test (+ 0.0 1234/11 1.0) 113.18181818181819)+(num-test (- 0.0 1234/11 1.0) -113.18181818181819)+(num-test (* 0.0 1234/11 1.0) 0.0)+(num-test (/ 0.0 1234/11 1.0) 0.0)+(num-test (= 0.0 1234/11 1.0) #f)+(num-test (< 0.0 1234/11 1.0) #f)+(num-test (<= 0.0 1234/11 1.0) #f)+(num-test (> 0.0 1234/11 1.0) #f)+(num-test (>= 0.0 1234/11 1.0) #f)+(num-test (+ 0.0 1234/11 1/1) 113.18181818181819)+(num-test (- 0.0 1234/11 1/1) -113.18181818181819)+(num-test (* 0.0 1234/11 1/1) 0.0)+(num-test (/ 0.0 1234/11 1/1) 0.0)+(num-test (= 0.0 1234/11 1/1) #f)+(num-test (< 0.0 1234/11 1/1) #f)+(num-test (<= 0.0 1234/11 1/1) #f)+(num-test (> 0.0 1234/11 1/1) #f)+(num-test (>= 0.0 1234/11 1/1) #f)+(num-test (+ 0.0 1234/11 1.0+1.0i) 113.18181818181819+1.0i)+(num-test (- 0.0 1234/11 1.0+1.0i) -113.18181818181819-1.0i)+(num-test (* 0.0 1234/11 1.0+1.0i) 0.0)+(num-test (/ 0.0 1234/11 1.0+1.0i) 0.0)+(num-test (= 0.0 1234/11 1.0+1.0i) #f)+(num-test (+ 0.0 1234/11 0) 112.18181818181819)+(num-test (- 0.0 1234/11 0) -112.18181818181819)+(num-test (* 0.0 1234/11 0) 0.0)+(num-test (+ 0.0 1234/11 0.0) 112.18181818181819)+(num-test (- 0.0 1234/11 0.0) -112.18181818181819)+(num-test (* 0.0 1234/11 0.0) 0.0)+(num-test (+ 0.0 1234/11 1234) 1346.18181818181824)+(num-test (- 0.0 1234/11 1234) -1346.18181818181824)+(num-test (* 0.0 1234/11 1234) 0.0)+(num-test (/ 0.0 1234/11 1234) 0.0)+(num-test (= 0.0 1234/11 1234) #f)+(num-test (< 0.0 1234/11 1234) #t)+(num-test (<= 0.0 1234/11 1234) #t)+(num-test (> 0.0 1234/11 1234) #f)+(num-test (>= 0.0 1234/11 1234) #f)+(num-test (+ 0.0 1234/11 123.4) 235.58181818181819)+(num-test (- 0.0 1234/11 123.4) -235.58181818181819)+(num-test (* 0.0 1234/11 123.4) 0.0)+(num-test (/ 0.0 1234/11 123.4) 0.0)+(num-test (= 0.0 1234/11 123.4) #f)+(num-test (< 0.0 1234/11 123.4) #t)+(num-test (<= 0.0 1234/11 123.4) #t)+(num-test (> 0.0 1234/11 123.4) #f)+(num-test (>= 0.0 1234/11 123.4) #f)+(num-test (+ 0.0 1234/11 1234/11) 224.36363636363637)+(num-test (- 0.0 1234/11 1234/11) -224.36363636363637)+(num-test (* 0.0 1234/11 1234/11) 0.0)+(num-test (/ 0.0 1234/11 1234/11) 0.0)+(num-test (= 0.0 1234/11 1234/11) #f)+(num-test (< 0.0 1234/11 1234/11) #f)+(num-test (<= 0.0 1234/11 1234/11) #t)+(num-test (> 0.0 1234/11 1234/11) #f)+(num-test (>= 0.0 1234/11 1234/11) #f)+(num-test (+ 0.0 1234/11 1.234+1.234i) 113.41581818181818+1.234i)+(num-test (- 0.0 1234/11 1.234+1.234i) -113.41581818181818-1.234i)+(num-test (* 0.0 1234/11 1.234+1.234i) 0.0)+(num-test (/ 0.0 1234/11 1.234+1.234i) 0.0)+(num-test (= 0.0 1234/11 1.234+1.234i) #f)+(num-test (+ 0.0 1234/11 -1.0+1.0i) 111.18181818181819+1.0i)+(num-test (- 0.0 1234/11 -1.0+1.0i) -111.18181818181819-1.0i)+(num-test (* 0.0 1234/11 -1.0+1.0i) -0.0)+(num-test (/ 0.0 1234/11 -1.0+1.0i) -0.0)+(num-test (= 0.0 1234/11 -1.0+1.0i) #f)+(num-test (+ 0.0 1234/11 0.0+1.0i) 112.18181818181819+1.0i)+(num-test (- 0.0 1234/11 0.0+1.0i) -112.18181818181819-1.0i)+(num-test (* 0.0 1234/11 0.0+1.0i) 0.0)+(num-test (/ 0.0 1234/11 0.0+1.0i) 0.0)+(num-test (= 0.0 1234/11 0.0+1.0i) #f)+(num-test (+ 0.0 1.234+1.234i 1) 2.234+1.234i)+(num-test (- 0.0 1.234+1.234i 1) -2.234-1.234i)+(num-test (* 0.0 1.234+1.234i 1) 0.0)+(num-test (/ 0.0 1.234+1.234i 1) 0.0)+(num-test (= 0.0 1.234+1.234i 1) #f)+(num-test (+ 0.0 1.234+1.234i 1.0) 2.234+1.234i)+(num-test (- 0.0 1.234+1.234i 1.0) -2.234-1.234i)+(num-test (* 0.0 1.234+1.234i 1.0) 0.0)+(num-test (/ 0.0 1.234+1.234i 1.0) 0.0)+(num-test (= 0.0 1.234+1.234i 1.0) #f)+(num-test (+ 0.0 1.234+1.234i 1/1) 2.234+1.234i)+(num-test (- 0.0 1.234+1.234i 1/1) -2.234-1.234i)+(num-test (* 0.0 1.234+1.234i 1/1) 0.0)+(num-test (/ 0.0 1.234+1.234i 1/1) 0.0)+(num-test (= 0.0 1.234+1.234i 1/1) #f)+(num-test (+ 0.0 1.234+1.234i 1.0+1.0i) 2.234+2.234i)+(num-test (- 0.0 1.234+1.234i 1.0+1.0i) -2.234-2.234i)+(num-test (* 0.0 1.234+1.234i 1.0+1.0i) 0.0)+(num-test (/ 0.0 1.234+1.234i 1.0+1.0i) 0.0)+(num-test (= 0.0 1.234+1.234i 1.0+1.0i) #f)+(num-test (+ 0.0 1.234+1.234i 0) 1.234+1.234i)+(num-test (- 0.0 1.234+1.234i 0) -1.234-1.234i)+(num-test (* 0.0 1.234+1.234i 0) 0.0)+(num-test (+ 0.0 1.234+1.234i 0.0) 1.234+1.234i)+(num-test (- 0.0 1.234+1.234i 0.0) -1.234-1.234i)+(num-test (* 0.0 1.234+1.234i 0.0) 0.0)+(num-test (+ 0.0 1.234+1.234i 1234) 1235.23399999999992+1.234i)+(num-test (- 0.0 1.234+1.234i 1234) -1235.23399999999992-1.234i)+(num-test (* 0.0 1.234+1.234i 1234) 0.0)+(num-test (/ 0.0 1.234+1.234i 1234) 0.0)+(num-test (= 0.0 1.234+1.234i 1234) #f)+(num-test (+ 0.0 1.234+1.234i 123.4) 124.634+1.234i)+(num-test (- 0.0 1.234+1.234i 123.4) -124.634-1.234i)+(num-test (* 0.0 1.234+1.234i 123.4) 0.0)+(num-test (/ 0.0 1.234+1.234i 123.4) 0.0)+(num-test (= 0.0 1.234+1.234i 123.4) #f)+(num-test (+ 0.0 1.234+1.234i 1234/11) 113.41581818181818+1.234i)+(num-test (- 0.0 1.234+1.234i 1234/11) -113.41581818181818-1.234i)+(num-test (* 0.0 1.234+1.234i 1234/11) 0.0)+(num-test (/ 0.0 1.234+1.234i 1234/11) 0.0)+(num-test (= 0.0 1.234+1.234i 1234/11) #f)+(num-test (+ 0.0 1.234+1.234i 1.234+1.234i) 2.468+2.468i)+(num-test (- 0.0 1.234+1.234i 1.234+1.234i) -2.468-2.468i)+(num-test (* 0.0 1.234+1.234i 1.234+1.234i) 0.0)+(num-test (/ 0.0 1.234+1.234i 1.234+1.234i) 0.0)+(num-test (= 0.0 1.234+1.234i 1.234+1.234i) #f)+(num-test (+ 0.0 1.234+1.234i -1.0+1.0i) 0.234+2.234i)+(num-test (- 0.0 1.234+1.234i -1.0+1.0i) -0.234-2.234i)+(num-test (* 0.0 1.234+1.234i -1.0+1.0i) -0.0)+(num-test (/ 0.0 1.234+1.234i -1.0+1.0i) -0.0)+(num-test (= 0.0 1.234+1.234i -1.0+1.0i) #f)+(num-test (+ 0.0 1.234+1.234i 0.0+1.0i) 1.234+2.234i)+(num-test (- 0.0 1.234+1.234i 0.0+1.0i) -1.234-2.234i)+(num-test (* 0.0 1.234+1.234i 0.0+1.0i) 0.0)+(num-test (/ 0.0 1.234+1.234i 0.0+1.0i) 0.0)+(num-test (= 0.0 1.234+1.234i 0.0+1.0i) #f)+(num-test (+ 0.0 -1.0+1.0i 1) 0.0+1.0i)+(num-test (- 0.0 -1.0+1.0i 1) 0.0-1.0i)+(num-test (* 0.0 -1.0+1.0i 1) -0.0)+(num-test (/ 0.0 -1.0+1.0i 1) -0.0)+(num-test (= 0.0 -1.0+1.0i 1) #f)+(num-test (+ 0.0 -1.0+1.0i 1.0) 0.0+1.0i)+(num-test (- 0.0 -1.0+1.0i 1.0) 0.0-1.0i)+(num-test (* 0.0 -1.0+1.0i 1.0) -0.0)+(num-test (/ 0.0 -1.0+1.0i 1.0) -0.0)+(num-test (= 0.0 -1.0+1.0i 1.0) #f)+(num-test (+ 0.0 -1.0+1.0i 1/1) 0.0+1.0i)+(num-test (- 0.0 -1.0+1.0i 1/1) 0.0-1.0i)+(num-test (* 0.0 -1.0+1.0i 1/1) -0.0)+(num-test (/ 0.0 -1.0+1.0i 1/1) -0.0)+(num-test (= 0.0 -1.0+1.0i 1/1) #f)+(num-test (+ 0.0 -1.0+1.0i 1.0+1.0i) 0.0+2.0i)+(num-test (- 0.0 -1.0+1.0i 1.0+1.0i) 0.0-2.0i)+(num-test (* 0.0 -1.0+1.0i 1.0+1.0i) -0.0)+(num-test (/ 0.0 -1.0+1.0i 1.0+1.0i) -0.0)+(num-test (= 0.0 -1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 0.0 -1.0+1.0i 0) -1.0+1.0i)+(num-test (- 0.0 -1.0+1.0i 0) 1.0-1.0i)+(num-test (* 0.0 -1.0+1.0i 0) -0.0)+(num-test (+ 0.0 -1.0+1.0i 0.0) -1.0+1.0i)+(num-test (- 0.0 -1.0+1.0i 0.0) 1.0-1.0i)+(num-test (* 0.0 -1.0+1.0i 0.0) -0.0)+(num-test (+ 0.0 -1.0+1.0i 1234) 1233.0+1.0i)+(num-test (- 0.0 -1.0+1.0i 1234) -1233.0-1.0i)+(num-test (* 0.0 -1.0+1.0i 1234) -0.0)+(num-test (/ 0.0 -1.0+1.0i 1234) -0.0)+(num-test (= 0.0 -1.0+1.0i 1234) #f)+(num-test (+ 0.0 -1.0+1.0i 123.4) 122.4+1.0i)+(num-test (- 0.0 -1.0+1.0i 123.4) -122.4-1.0i)+(num-test (* 0.0 -1.0+1.0i 123.4) -0.0)+(num-test (/ 0.0 -1.0+1.0i 123.4) -0.0)+(num-test (= 0.0 -1.0+1.0i 123.4) #f)+(num-test (+ 0.0 -1.0+1.0i 1234/11) 111.18181818181819+1.0i)+(num-test (- 0.0 -1.0+1.0i 1234/11) -111.18181818181819-1.0i)+(num-test (* 0.0 -1.0+1.0i 1234/11) -0.0)+(num-test (/ 0.0 -1.0+1.0i 1234/11) -0.0)+(num-test (= 0.0 -1.0+1.0i 1234/11) #f)+(num-test (+ 0.0 -1.0+1.0i 1.234+1.234i) 0.234+2.234i)+(num-test (- 0.0 -1.0+1.0i 1.234+1.234i) -0.234-2.234i)+(num-test (* 0.0 -1.0+1.0i 1.234+1.234i) -0.0)+(num-test (/ 0.0 -1.0+1.0i 1.234+1.234i) -0.0)+(num-test (= 0.0 -1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 0.0 -1.0+1.0i -1.0+1.0i) -2.0+2.0i)+(num-test (- 0.0 -1.0+1.0i -1.0+1.0i) 2.0-2.0i)+(num-test (* 0.0 -1.0+1.0i -1.0+1.0i) 0.0)+(num-test (/ 0.0 -1.0+1.0i -1.0+1.0i) -0.0)+(num-test (= 0.0 -1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 0.0 -1.0+1.0i 0.0+1.0i) -1.0+2.0i)+(num-test (- 0.0 -1.0+1.0i 0.0+1.0i) 1.0-2.0i)+(num-test (* 0.0 -1.0+1.0i 0.0+1.0i) -0.0)+(num-test (/ 0.0 -1.0+1.0i 0.0+1.0i) -0.0)+(num-test (= 0.0 -1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 0.0 0.0+1.0i 1) 1.0+1.0i)+(num-test (- 0.0 0.0+1.0i 1) -1.0-1.0i)+(num-test (* 0.0 0.0+1.0i 1) 0.0)+(num-test (/ 0.0 0.0+1.0i 1) 0.0)+(num-test (= 0.0 0.0+1.0i 1) #f)+(num-test (+ 0.0 0.0+1.0i 1.0) 1.0+1.0i)+(num-test (- 0.0 0.0+1.0i 1.0) -1.0-1.0i)+(num-test (* 0.0 0.0+1.0i 1.0) 0.0)+(num-test (/ 0.0 0.0+1.0i 1.0) 0.0)+(num-test (= 0.0 0.0+1.0i 1.0) #f)+(num-test (+ 0.0 0.0+1.0i 1/1) 1.0+1.0i)+(num-test (- 0.0 0.0+1.0i 1/1) -1.0-1.0i)+(num-test (* 0.0 0.0+1.0i 1/1) 0.0)+(num-test (/ 0.0 0.0+1.0i 1/1) 0.0)+(num-test (= 0.0 0.0+1.0i 1/1) #f)+(num-test (+ 0.0 0.0+1.0i 1.0+1.0i) 1.0+2.0i)+(num-test (- 0.0 0.0+1.0i 1.0+1.0i) -1.0-2.0i)+(num-test (* 0.0 0.0+1.0i 1.0+1.0i) 0.0)+(num-test (/ 0.0 0.0+1.0i 1.0+1.0i) 0.0)+(num-test (= 0.0 0.0+1.0i 1.0+1.0i) #f)+(num-test (+ 0.0 0.0+1.0i 0) 0.0+1.0i)+(num-test (- 0.0 0.0+1.0i 0) 0.0-1.0i)+(num-test (* 0.0 0.0+1.0i 0) 0.0)+(num-test (+ 0.0 0.0+1.0i 0.0) 0.0+1.0i)+(num-test (- 0.0 0.0+1.0i 0.0) 0.0-1.0i)+(num-test (* 0.0 0.0+1.0i 0.0) 0.0)+(num-test (+ 0.0 0.0+1.0i 1234) 1234.0+1.0i)+(num-test (- 0.0 0.0+1.0i 1234) -1234.0-1.0i)+(num-test (* 0.0 0.0+1.0i 1234) 0.0)+(num-test (/ 0.0 0.0+1.0i 1234) 0.0)+(num-test (= 0.0 0.0+1.0i 1234) #f)+(num-test (+ 0.0 0.0+1.0i 123.4) 123.4+1.0i)+(num-test (- 0.0 0.0+1.0i 123.4) -123.4-1.0i)+(num-test (* 0.0 0.0+1.0i 123.4) 0.0)+(num-test (/ 0.0 0.0+1.0i 123.4) 0.0)+(num-test (= 0.0 0.0+1.0i 123.4) #f)+(num-test (+ 0.0 0.0+1.0i 1234/11) 112.18181818181819+1.0i)+(num-test (- 0.0 0.0+1.0i 1234/11) -112.18181818181819-1.0i)+(num-test (* 0.0 0.0+1.0i 1234/11) 0.0)+(num-test (/ 0.0 0.0+1.0i 1234/11) 0.0)+(num-test (= 0.0 0.0+1.0i 1234/11) #f)+(num-test (+ 0.0 0.0+1.0i 1.234+1.234i) 1.234+2.234i)+(num-test (- 0.0 0.0+1.0i 1.234+1.234i) -1.234-2.234i)+(num-test (* 0.0 0.0+1.0i 1.234+1.234i) 0.0)+(num-test (/ 0.0 0.0+1.0i 1.234+1.234i) 0.0)+(num-test (= 0.0 0.0+1.0i 1.234+1.234i) #f)+(num-test (+ 0.0 0.0+1.0i -1.0+1.0i) -1.0+2.0i)+(num-test (- 0.0 0.0+1.0i -1.0+1.0i) 1.0-2.0i)+(num-test (* 0.0 0.0+1.0i -1.0+1.0i) -0.0)+(num-test (/ 0.0 0.0+1.0i -1.0+1.0i) -0.0)+(num-test (= 0.0 0.0+1.0i -1.0+1.0i) #f)+(num-test (+ 0.0 0.0+1.0i 0.0+1.0i) 0.0+2.0i)+(num-test (- 0.0 0.0+1.0i 0.0+1.0i) 0.0-2.0i)+(num-test (* 0.0 0.0+1.0i 0.0+1.0i) 0.0)+(num-test (/ 0.0 0.0+1.0i 0.0+1.0i) 0.0)+(num-test (= 0.0 0.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1234 1 1) 1236)+(num-test (- 1234 1 1) 1232)+(num-test (* 1234 1 1) 1234)+(num-test (/ 1234 1 1) 1234)+(num-test (= 1234 1 1) #f)+(num-test (< 1234 1 1) #f)+(num-test (<= 1234 1 1) #f)+(num-test (> 1234 1 1) #f)+(num-test (>= 1234 1 1) #t)+(num-test (+ 1234 1 1.0) 1236.0)+(num-test (- 1234 1 1.0) 1232.0)+(num-test (* 1234 1 1.0) 1234.0)+(num-test (/ 1234 1 1.0) 1234.0)+(num-test (= 1234 1 1.0) #f)+(num-test (< 1234 1 1.0) #f)+(num-test (<= 1234 1 1.0) #f)+(num-test (> 1234 1 1.0) #f)+(num-test (>= 1234 1 1.0) #t)+(num-test (+ 1234 1 1/1) 1236)+(num-test (- 1234 1 1/1) 1232)+(num-test (* 1234 1 1/1) 1234)+(num-test (/ 1234 1 1/1) 1234)+(num-test (= 1234 1 1/1) #f)+(num-test (< 1234 1 1/1) #f)+(num-test (<= 1234 1 1/1) #f)+(num-test (> 1234 1 1/1) #f)+(num-test (>= 1234 1 1/1) #t)+(num-test (+ 1234 1 1.0+1.0i) 1236.0+1.0i)+(num-test (- 1234 1 1.0+1.0i) 1232.0-1.0i)+(num-test (* 1234 1 1.0+1.0i) 1234.0+1234.0i)+(num-test (/ 1234 1 1.0+1.0i) 617.0-617.0i)+(num-test (= 1234 1 1.0+1.0i) #f)+(num-test (+ 1234 1 0) 1235)+(num-test (- 1234 1 0) 1233)+(num-test (* 1234 1 0) 0)+(num-test (+ 1234 1 0.0) 1235.0)+(num-test (- 1234 1 0.0) 1233.0)+(num-test (* 1234 1 0.0) 0.0)+(num-test (+ 1234 1 1234) 2469)+(num-test (- 1234 1 1234) -1)+(num-test (* 1234 1 1234) 1522756)+(num-test (/ 1234 1 1234) 1)+(num-test (= 1234 1 1234) #f)+(num-test (< 1234 1 1234) #f)+(num-test (<= 1234 1 1234) #f)+(num-test (> 1234 1 1234) #f)+(num-test (>= 1234 1 1234) #f)+(num-test (+ 1234 1 123.4) 1358.4)+(num-test (- 1234 1 123.4) 1109.59999999999991)+(num-test (* 1234 1 123.4) 152275.60000000000582)+(num-test (/ 1234 1 123.4) 10.0)+(num-test (= 1234 1 123.4) #f)+(num-test (< 1234 1 123.4) #f)+(num-test (<= 1234 1 123.4) #f)+(num-test (> 1234 1 123.4) #f)+(num-test (>= 1234 1 123.4) #f)+(num-test (+ 1234 1 1234/11) 14819/11)+(num-test (- 1234 1 1234/11) 12329/11)+(num-test (* 1234 1 1234/11) 1522756/11)+(num-test (/ 1234 1 1234/11) 11)+(num-test (= 1234 1 1234/11) #f)+(num-test (< 1234 1 1234/11) #f)+(num-test (<= 1234 1 1234/11) #f)+(num-test (> 1234 1 1234/11) #f)+(num-test (>= 1234 1 1234/11) #f)+(num-test (+ 1234 1 1.234+1.234i) 1236.23399999999992+1.234i)+(num-test (- 1234 1 1.234+1.234i) 1231.766-1.234i)+(num-test (* 1234 1 1.234+1.234i) 1522.756+1522.756i)+(num-test (/ 1234 1 1.234+1.234i) 500.0-500.0i)+(num-test (= 1234 1 1.234+1.234i) #f)+(num-test (+ 1234 1 -1.0+1.0i) 1234.0+1.0i)+(num-test (- 1234 1 -1.0+1.0i) 1234.0-1.0i)+(num-test (* 1234 1 -1.0+1.0i) -1234.0+1234.0i)+(num-test (/ 1234 1 -1.0+1.0i) -617.0-617.0i)+(num-test (= 1234 1 -1.0+1.0i) #f)+(num-test (+ 1234 1 0.0+1.0i) 1235.0+1.0i)+(num-test (- 1234 1 0.0+1.0i) 1233.0-1.0i)+(num-test (* 1234 1 0.0+1.0i) 0.0+1234.0i)+(num-test (/ 1234 1 0.0+1.0i) 0.0-1234.0i)+(num-test (= 1234 1 0.0+1.0i) #f)+(num-test (+ 1234 1.0 1) 1236.0)+(num-test (- 1234 1.0 1) 1232.0)+(num-test (* 1234 1.0 1) 1234.0)+(num-test (/ 1234 1.0 1) 1234.0)+(num-test (= 1234 1.0 1) #f)+(num-test (< 1234 1.0 1) #f)+(num-test (<= 1234 1.0 1) #f)+(num-test (> 1234 1.0 1) #f)+(num-test (>= 1234 1.0 1) #t)+(num-test (+ 1234 1.0 1.0) 1236.0)+(num-test (- 1234 1.0 1.0) 1232.0)+(num-test (* 1234 1.0 1.0) 1234.0)+(num-test (/ 1234 1.0 1.0) 1234.0)+(num-test (= 1234 1.0 1.0) #f)+(num-test (< 1234 1.0 1.0) #f)+(num-test (<= 1234 1.0 1.0) #f)+(num-test (> 1234 1.0 1.0) #f)+(num-test (>= 1234 1.0 1.0) #t)+(num-test (+ 1234 1.0 1/1) 1236.0)+(num-test (- 1234 1.0 1/1) 1232.0)+(num-test (* 1234 1.0 1/1) 1234.0)+(num-test (/ 1234 1.0 1/1) 1234.0)+(num-test (= 1234 1.0 1/1) #f)+(num-test (< 1234 1.0 1/1) #f)+(num-test (<= 1234 1.0 1/1) #f)+(num-test (> 1234 1.0 1/1) #f)+(num-test (>= 1234 1.0 1/1) #t)+(num-test (+ 1234 1.0 1.0+1.0i) 1236.0+1.0i)+(num-test (- 1234 1.0 1.0+1.0i) 1232.0-1.0i)+(num-test (* 1234 1.0 1.0+1.0i) 1234.0+1234.0i)+(num-test (/ 1234 1.0 1.0+1.0i) 617.0-617.0i)+(num-test (= 1234 1.0 1.0+1.0i) #f)+(num-test (+ 1234 1.0 0) 1235.0)+(num-test (- 1234 1.0 0) 1233.0)+(num-test (* 1234 1.0 0) 0.0)+(num-test (+ 1234 1.0 0.0) 1235.0)+(num-test (- 1234 1.0 0.0) 1233.0)+(num-test (* 1234 1.0 0.0) 0.0)+(num-test (+ 1234 1.0 1234) 2469.0)+(num-test (- 1234 1.0 1234) -1.0)+(num-test (* 1234 1.0 1234) 1522756.0)+(num-test (/ 1234 1.0 1234) 1.0)+(num-test (= 1234 1.0 1234) #f)+(num-test (< 1234 1.0 1234) #f)+(num-test (<= 1234 1.0 1234) #f)+(num-test (> 1234 1.0 1234) #f)+(num-test (>= 1234 1.0 1234) #f)+(num-test (+ 1234 1.0 123.4) 1358.4)+(num-test (- 1234 1.0 123.4) 1109.59999999999991)+(num-test (* 1234 1.0 123.4) 152275.60000000000582)+(num-test (/ 1234 1.0 123.4) 10.0)+(num-test (= 1234 1.0 123.4) #f)+(num-test (< 1234 1.0 123.4) #f)+(num-test (<= 1234 1.0 123.4) #f)+(num-test (> 1234 1.0 123.4) #f)+(num-test (>= 1234 1.0 123.4) #f)+(num-test (+ 1234 1.0 1234/11) 1347.18181818181824)+(num-test (- 1234 1.0 1234/11) 1120.81818181818176)+(num-test (* 1234 1.0 1234/11) 138432.36363636364695)+(num-test (/ 1234 1.0 1234/11) 11.0)+(num-test (= 1234 1.0 1234/11) #f)+(num-test (< 1234 1.0 1234/11) #f)+(num-test (<= 1234 1.0 1234/11) #f)+(num-test (> 1234 1.0 1234/11) #f)+(num-test (>= 1234 1.0 1234/11) #f)+(num-test (+ 1234 1.0 1.234+1.234i) 1236.23399999999992+1.234i)+(num-test (- 1234 1.0 1.234+1.234i) 1231.766-1.234i)+(num-test (* 1234 1.0 1.234+1.234i) 1522.756+1522.756i)+(num-test (/ 1234 1.0 1.234+1.234i) 500.0-500.0i)+(num-test (= 1234 1.0 1.234+1.234i) #f)+(num-test (+ 1234 1.0 -1.0+1.0i) 1234.0+1.0i)+(num-test (- 1234 1.0 -1.0+1.0i) 1234.0-1.0i)+(num-test (* 1234 1.0 -1.0+1.0i) -1234.0+1234.0i)+(num-test (/ 1234 1.0 -1.0+1.0i) -617.0-617.0i)+(num-test (= 1234 1.0 -1.0+1.0i) #f)+(num-test (+ 1234 1.0 0.0+1.0i) 1235.0+1.0i)+(num-test (- 1234 1.0 0.0+1.0i) 1233.0-1.0i)+(num-test (* 1234 1.0 0.0+1.0i) 0.0+1234.0i)+(num-test (/ 1234 1.0 0.0+1.0i) 0.0-1234.0i)+(num-test (= 1234 1.0 0.0+1.0i) #f)+(num-test (+ 1234 1/1 1) 1236)+(num-test (- 1234 1/1 1) 1232)+(num-test (* 1234 1/1 1) 1234)+(num-test (/ 1234 1/1 1) 1234)+(num-test (= 1234 1/1 1) #f)+(num-test (< 1234 1/1 1) #f)+(num-test (<= 1234 1/1 1) #f)+(num-test (> 1234 1/1 1) #f)+(num-test (>= 1234 1/1 1) #t)+(num-test (+ 1234 1/1 1.0) 1236.0)+(num-test (- 1234 1/1 1.0) 1232.0)+(num-test (* 1234 1/1 1.0) 1234.0)+(num-test (/ 1234 1/1 1.0) 1234.0)+(num-test (= 1234 1/1 1.0) #f)+(num-test (< 1234 1/1 1.0) #f)+(num-test (<= 1234 1/1 1.0) #f)+(num-test (> 1234 1/1 1.0) #f)+(num-test (>= 1234 1/1 1.0) #t)+(num-test (+ 1234 1/1 1/1) 1236)+(num-test (- 1234 1/1 1/1) 1232)+(num-test (* 1234 1/1 1/1) 1234)+(num-test (/ 1234 1/1 1/1) 1234)+(num-test (= 1234 1/1 1/1) #f)+(num-test (< 1234 1/1 1/1) #f)+(num-test (<= 1234 1/1 1/1) #f)+(num-test (> 1234 1/1 1/1) #f)+(num-test (>= 1234 1/1 1/1) #t)+(num-test (+ 1234 1/1 1.0+1.0i) 1236.0+1.0i)+(num-test (- 1234 1/1 1.0+1.0i) 1232.0-1.0i)+(num-test (* 1234 1/1 1.0+1.0i) 1234.0+1234.0i)+(num-test (/ 1234 1/1 1.0+1.0i) 617.0-617.0i)+(num-test (= 1234 1/1 1.0+1.0i) #f)+(num-test (+ 1234 1/1 0) 1235)+(num-test (- 1234 1/1 0) 1233)+(num-test (* 1234 1/1 0) 0)+(num-test (+ 1234 1/1 0.0) 1235.0)+(num-test (- 1234 1/1 0.0) 1233.0)+(num-test (* 1234 1/1 0.0) 0.0)+(num-test (+ 1234 1/1 1234) 2469)+(num-test (- 1234 1/1 1234) -1)+(num-test (* 1234 1/1 1234) 1522756)+(num-test (/ 1234 1/1 1234) 1)+(num-test (= 1234 1/1 1234) #f)+(num-test (< 1234 1/1 1234) #f)+(num-test (<= 1234 1/1 1234) #f)+(num-test (> 1234 1/1 1234) #f)+(num-test (>= 1234 1/1 1234) #f)+(num-test (+ 1234 1/1 123.4) 1358.4)+(num-test (- 1234 1/1 123.4) 1109.59999999999991)+(num-test (* 1234 1/1 123.4) 152275.60000000000582)+(num-test (/ 1234 1/1 123.4) 10.0)+(num-test (= 1234 1/1 123.4) #f)+(num-test (< 1234 1/1 123.4) #f)+(num-test (<= 1234 1/1 123.4) #f)+(num-test (> 1234 1/1 123.4) #f)+(num-test (>= 1234 1/1 123.4) #f)+(num-test (+ 1234 1/1 1234/11) 14819/11)+(num-test (- 1234 1/1 1234/11) 12329/11)+(num-test (* 1234 1/1 1234/11) 1522756/11)+(num-test (/ 1234 1/1 1234/11) 11)+(num-test (= 1234 1/1 1234/11) #f)+(num-test (< 1234 1/1 1234/11) #f)+(num-test (<= 1234 1/1 1234/11) #f)+(num-test (> 1234 1/1 1234/11) #f)+(num-test (>= 1234 1/1 1234/11) #f)+(num-test (+ 1234 1/1 1.234+1.234i) 1236.23399999999992+1.234i)+(num-test (- 1234 1/1 1.234+1.234i) 1231.766-1.234i)+(num-test (* 1234 1/1 1.234+1.234i) 1522.756+1522.756i)+(num-test (/ 1234 1/1 1.234+1.234i) 500.0-500.0i)+(num-test (= 1234 1/1 1.234+1.234i) #f)+(num-test (+ 1234 1/1 -1.0+1.0i) 1234.0+1.0i)+(num-test (- 1234 1/1 -1.0+1.0i) 1234.0-1.0i)+(num-test (* 1234 1/1 -1.0+1.0i) -1234.0+1234.0i)+(num-test (/ 1234 1/1 -1.0+1.0i) -617.0-617.0i)+(num-test (= 1234 1/1 -1.0+1.0i) #f)+(num-test (+ 1234 1/1 0.0+1.0i) 1235.0+1.0i)+(num-test (- 1234 1/1 0.0+1.0i) 1233.0-1.0i)+(num-test (* 1234 1/1 0.0+1.0i) 0.0+1234.0i)+(num-test (/ 1234 1/1 0.0+1.0i) 0.0-1234.0i)+(num-test (= 1234 1/1 0.0+1.0i) #f)+(num-test (+ 1234 1.0+1.0i 1) 1236.0+1.0i)+(num-test (- 1234 1.0+1.0i 1) 1232.0-1.0i)+(num-test (* 1234 1.0+1.0i 1) 1234.0+1234.0i)+(num-test (/ 1234 1.0+1.0i 1) 617.0-617.0i)+(num-test (= 1234 1.0+1.0i 1) #f)+(num-test (+ 1234 1.0+1.0i 1.0) 1236.0+1.0i)+(num-test (- 1234 1.0+1.0i 1.0) 1232.0-1.0i)+(num-test (* 1234 1.0+1.0i 1.0) 1234.0+1234.0i)+(num-test (/ 1234 1.0+1.0i 1.0) 617.0-617.0i)+(num-test (= 1234 1.0+1.0i 1.0) #f)+(num-test (+ 1234 1.0+1.0i 1/1) 1236.0+1.0i)+(num-test (- 1234 1.0+1.0i 1/1) 1232.0-1.0i)+(num-test (* 1234 1.0+1.0i 1/1) 1234.0+1234.0i)+(num-test (/ 1234 1.0+1.0i 1/1) 617.0-617.0i)+(num-test (= 1234 1.0+1.0i 1/1) #f)+(num-test (+ 1234 1.0+1.0i 1.0+1.0i) 1236.0+2.0i)+(num-test (- 1234 1.0+1.0i 1.0+1.0i) 1232.0-2.0i)+(num-test (* 1234 1.0+1.0i 1.0+1.0i) 0.0+2468.0i)+(num-test (/ 1234 1.0+1.0i 1.0+1.0i) 0.0-617.0i)+(num-test (= 1234 1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1234 1.0+1.0i 0) 1235.0+1.0i)+(num-test (- 1234 1.0+1.0i 0) 1233.0-1.0i)+(num-test (* 1234 1.0+1.0i 0) 0.0)+(num-test (+ 1234 1.0+1.0i 0.0) 1235.0+1.0i)+(num-test (- 1234 1.0+1.0i 0.0) 1233.0-1.0i)+(num-test (* 1234 1.0+1.0i 0.0) 0.0)+(num-test (+ 1234 1.0+1.0i 1234) 2469.0+1.0i)+(num-test (- 1234 1.0+1.0i 1234) -1.0-1.0i)+(num-test (* 1234 1.0+1.0i 1234) 1522756.0+1522756.0i)+(num-test (/ 1234 1.0+1.0i 1234) 0.5-0.5i)+(num-test (= 1234 1.0+1.0i 1234) #f)+(num-test (+ 1234 1.0+1.0i 123.4) 1358.4+1.0i)+(num-test (- 1234 1.0+1.0i 123.4) 1109.59999999999991-1.0i)+(num-test (* 1234 1.0+1.0i 123.4) 152275.60000000000582+152275.60000000000582i)+(num-test (/ 1234 1.0+1.0i 123.4) 5.0-5.0i)+(num-test (= 1234 1.0+1.0i 123.4) #f)+(num-test (+ 1234 1.0+1.0i 1234/11) 1347.18181818181824+1.0i)+(num-test (- 1234 1.0+1.0i 1234/11) 1120.81818181818176-1.0i)+(num-test (* 1234 1.0+1.0i 1234/11) 138432.36363636364695+138432.36363636364695i)+(num-test (/ 1234 1.0+1.0i 1234/11) 5.50000000000000-5.50000000000000i)+(num-test (= 1234 1.0+1.0i 1234/11) #f)+(num-test (+ 1234 1.0+1.0i 1.234+1.234i) 1236.23399999999992+2.234i)+(num-test (- 1234 1.0+1.0i 1.234+1.234i) 1231.766-2.234i)+(num-test (* 1234 1.0+1.0i 1.234+1.234i) 0.0+3045.51200000000017i)+(num-test (/ 1234 1.0+1.0i 1.234+1.234i) 0.0-500.0i)+(num-test (= 1234 1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1234 1.0+1.0i -1.0+1.0i) 1234.0+2.0i)+(num-test (- 1234 1.0+1.0i -1.0+1.0i) 1234.0-2.0i)+(num-test (* 1234 1.0+1.0i -1.0+1.0i) -2468.0)+(num-test (/ 1234 1.0+1.0i -1.0+1.0i) -617.0)+(num-test (= 1234 1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1234 1.0+1.0i 0.0+1.0i) 1235.0+2.0i)+(num-test (- 1234 1.0+1.0i 0.0+1.0i) 1233.0-2.0i)+(num-test (* 1234 1.0+1.0i 0.0+1.0i) -1234.0+1234.0i)+(num-test (/ 1234 1.0+1.0i 0.0+1.0i) -617.0-617.0i)+(num-test (= 1234 1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1234 0 1) 1235)+(num-test (- 1234 0 1) 1233)+(num-test (* 1234 0 1) 0)+(num-test (+ 1234 0 1.0) 1235.0)+(num-test (- 1234 0 1.0) 1233.0)+(num-test (* 1234 0 1.0) 0.0)+(num-test (+ 1234 0 1/1) 1235)+(num-test (- 1234 0 1/1) 1233)+(num-test (* 1234 0 1/1) 0)+(num-test (+ 1234 0 1.0+1.0i) 1235.0+1.0i)+(num-test (- 1234 0 1.0+1.0i) 1233.0-1.0i)+(num-test (* 1234 0 1.0+1.0i) 0.0)+(num-test (+ 1234 0 0) 1234)+(num-test (- 1234 0 0) 1234)+(num-test (* 1234 0 0) 0)+(num-test (+ 1234 0 0.0) 1234.0)+(num-test (- 1234 0 0.0) 1234.0)+(num-test (* 1234 0 0.0) 0.0)+(num-test (+ 1234 0 1234) 2468)+(num-test (- 1234 0 1234) 0)+(num-test (* 1234 0 1234) 0)+(num-test (+ 1234 0 123.4) 1357.4)+(num-test (- 1234 0 123.4) 1110.59999999999991)+(num-test (* 1234 0 123.4) 0.0)+(num-test (+ 1234 0 1234/11) 14808/11)+(num-test (- 1234 0 1234/11) 12340/11)+(num-test (* 1234 0 1234/11) 0)+(num-test (+ 1234 0 1.234+1.234i) 1235.23399999999992+1.234i)+(num-test (- 1234 0 1.234+1.234i) 1232.766-1.234i)+(num-test (* 1234 0 1.234+1.234i) 0.0)+(num-test (+ 1234 0 -1.0+1.0i) 1233.0+1.0i)+(num-test (- 1234 0 -1.0+1.0i) 1235.0-1.0i)+(num-test (* 1234 0 -1.0+1.0i) -0.0)+(num-test (+ 1234 0 0.0+1.0i) 1234.0+1.0i)+(num-test (- 1234 0 0.0+1.0i) 1234.0-1.0i)+(num-test (* 1234 0 0.0+1.0i) 0.0)+(num-test (+ 1234 0.0 1) 1235.0)+(num-test (- 1234 0.0 1) 1233.0)+(num-test (* 1234 0.0 1) 0.0)+(num-test (+ 1234 0.0 1.0) 1235.0)+(num-test (- 1234 0.0 1.0) 1233.0)+(num-test (* 1234 0.0 1.0) 0.0)+(num-test (+ 1234 0.0 1/1) 1235.0)+(num-test (- 1234 0.0 1/1) 1233.0)+(num-test (* 1234 0.0 1/1) 0.0)+(num-test (+ 1234 0.0 1.0+1.0i) 1235.0+1.0i)+(num-test (- 1234 0.0 1.0+1.0i) 1233.0-1.0i)+(num-test (* 1234 0.0 1.0+1.0i) 0.0)+(num-test (+ 1234 0.0 0) 1234.0)+(num-test (- 1234 0.0 0) 1234.0)+(num-test (* 1234 0.0 0) 0.0)+(num-test (+ 1234 0.0 0.0) 1234.0)+(num-test (- 1234 0.0 0.0) 1234.0)+(num-test (* 1234 0.0 0.0) 0.0)+(num-test (+ 1234 0.0 1234) 2468.0)+(num-test (- 1234 0.0 1234) 0.0)+(num-test (* 1234 0.0 1234) 0.0)+(num-test (+ 1234 0.0 123.4) 1357.4)+(num-test (- 1234 0.0 123.4) 1110.59999999999991)+(num-test (* 1234 0.0 123.4) 0.0)+(num-test (+ 1234 0.0 1234/11) 1346.18181818181824)+(num-test (- 1234 0.0 1234/11) 1121.81818181818176)+(num-test (* 1234 0.0 1234/11) 0.0)+(num-test (+ 1234 0.0 1.234+1.234i) 1235.23399999999992+1.234i)+(num-test (- 1234 0.0 1.234+1.234i) 1232.766-1.234i)+(num-test (* 1234 0.0 1.234+1.234i) 0.0)+(num-test (+ 1234 0.0 -1.0+1.0i) 1233.0+1.0i)+(num-test (- 1234 0.0 -1.0+1.0i) 1235.0-1.0i)+(num-test (* 1234 0.0 -1.0+1.0i) -0.0)+(num-test (+ 1234 0.0 0.0+1.0i) 1234.0+1.0i)+(num-test (- 1234 0.0 0.0+1.0i) 1234.0-1.0i)+(num-test (* 1234 0.0 0.0+1.0i) 0.0)+(num-test (+ 1234 1234 1) 2469)+(num-test (- 1234 1234 1) -1)+(num-test (* 1234 1234 1) 1522756)+(num-test (/ 1234 1234 1) 1)+(num-test (= 1234 1234 1) #f)+(num-test (< 1234 1234 1) #f)+(num-test (<= 1234 1234 1) #f)+(num-test (> 1234 1234 1) #f)+(num-test (>= 1234 1234 1) #t)+(num-test (+ 1234 1234 1.0) 2469.0)+(num-test (- 1234 1234 1.0) -1.0)+(num-test (* 1234 1234 1.0) 1522756.0)+(num-test (/ 1234 1234 1.0) 1.0)+(num-test (= 1234 1234 1.0) #f)+(num-test (< 1234 1234 1.0) #f)+(num-test (<= 1234 1234 1.0) #f)+(num-test (> 1234 1234 1.0) #f)+(num-test (>= 1234 1234 1.0) #t)+(num-test (+ 1234 1234 1/1) 2469)+(num-test (- 1234 1234 1/1) -1)+(num-test (* 1234 1234 1/1) 1522756)+(num-test (/ 1234 1234 1/1) 1)+(num-test (= 1234 1234 1/1) #f)+(num-test (< 1234 1234 1/1) #f)+(num-test (<= 1234 1234 1/1) #f)+(num-test (> 1234 1234 1/1) #f)+(num-test (>= 1234 1234 1/1) #t)+(num-test (+ 1234 1234 1.0+1.0i) 2469.0+1.0i)+(num-test (- 1234 1234 1.0+1.0i) -1.0-1.0i)+(num-test (* 1234 1234 1.0+1.0i) 1522756.0+1522756.0i)+(num-test (/ 1234 1234 1.0+1.0i) 0.5-0.5i)+(num-test (= 1234 1234 1.0+1.0i) #f)+(num-test (+ 1234 1234 0) 2468)+(num-test (- 1234 1234 0) 0)+(num-test (* 1234 1234 0) 0)+(num-test (+ 1234 1234 0.0) 2468.0)+(num-test (- 1234 1234 0.0) 0.0)+(num-test (* 1234 1234 0.0) 0.0)+(num-test (+ 1234 1234 1234) 3702)+(num-test (- 1234 1234 1234) -1234)+(num-test (* 1234 1234 1234) 1879080904)+(num-test (/ 1234 1234 1234) 1/1234)+(num-test (= 1234 1234 1234) #t)+(num-test (< 1234 1234 1234) #f)+(num-test (<= 1234 1234 1234) #t)+(num-test (> 1234 1234 1234) #f)+(num-test (>= 1234 1234 1234) #t)+(num-test (+ 1234 1234 123.4) 2591.4)+(num-test (- 1234 1234 123.4) -123.4)+(num-test (* 1234 1234 123.4) 187908090.40000000596046)+(num-test (/ 1234 1234 123.4) 0.00810372771475)+(num-test (= 1234 1234 123.4) #f)+(num-test (< 1234 1234 123.4) #f)+(num-test (<= 1234 1234 123.4) #f)+(num-test (> 1234 1234 123.4) #f)+(num-test (>= 1234 1234 123.4) #t)+(num-test (+ 1234 1234 1234/11) 28382/11)+(num-test (- 1234 1234 1234/11) -1234/11)+(if (not with-64-bit-ints)+    (num-test (* 1234 1234 1234/11) 170825536.727273)+    (num-test (* 1234 1234 1234/11) 1879080904/11))+(num-test (/ 1234 1234 1234/11) 11/1234)+(num-test (= 1234 1234 1234/11) #f)+(num-test (< 1234 1234 1234/11) #f)+(num-test (<= 1234 1234 1234/11) #f)+(num-test (> 1234 1234 1234/11) #f)+(num-test (>= 1234 1234 1234/11) #t)+(num-test (+ 1234 1234 1.234+1.234i) 2469.23399999999992+1.234i)+(num-test (- 1234 1234 1.234+1.234i) -1.234-1.234i)+(num-test (* 1234 1234 1.234+1.234i) 1879080.90399999986403+1879080.90399999986403i)+(num-test (/ 1234 1234 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1234 1234 1.234+1.234i) #f)+(num-test (+ 1234 1234 -1.0+1.0i) 2467.0+1.0i)+(num-test (- 1234 1234 -1.0+1.0i) 1.0-1.0i)+(num-test (* 1234 1234 -1.0+1.0i) -1522756.0+1522756.0i)+(num-test (/ 1234 1234 -1.0+1.0i) -0.5-0.5i)+(num-test (= 1234 1234 -1.0+1.0i) #f)+(num-test (+ 1234 1234 0.0+1.0i) 2468.0+1.0i)+(num-test (- 1234 1234 0.0+1.0i) 0.0-1.0i)+(num-test (* 1234 1234 0.0+1.0i) 0.0+1522756.0i)+(num-test (/ 1234 1234 0.0+1.0i) 0.0-1.0i)+(num-test (= 1234 1234 0.0+1.0i) #f)+(num-test (+ 1234 123.4 1) 1358.4)+(num-test (- 1234 123.4 1) 1109.59999999999991)+(num-test (* 1234 123.4 1) 152275.60000000000582)+(num-test (/ 1234 123.4 1) 10.0)+(num-test (= 1234 123.4 1) #f)+(num-test (< 1234 123.4 1) #f)+(num-test (<= 1234 123.4 1) #f)+(num-test (> 1234 123.4 1) #t)+(num-test (>= 1234 123.4 1) #t)+(num-test (+ 1234 123.4 1.0) 1358.4)+(num-test (- 1234 123.4 1.0) 1109.59999999999991)+(num-test (* 1234 123.4 1.0) 152275.60000000000582)+(num-test (/ 1234 123.4 1.0) 10.0)+(num-test (= 1234 123.4 1.0) #f)+(num-test (< 1234 123.4 1.0) #f)+(num-test (<= 1234 123.4 1.0) #f)+(num-test (> 1234 123.4 1.0) #t)+(num-test (>= 1234 123.4 1.0) #t)+(num-test (+ 1234 123.4 1/1) 1358.4)+(num-test (- 1234 123.4 1/1) 1109.59999999999991)+(num-test (* 1234 123.4 1/1) 152275.60000000000582)+(num-test (/ 1234 123.4 1/1) 10.0)+(num-test (= 1234 123.4 1/1) #f)+(num-test (< 1234 123.4 1/1) #f)+(num-test (<= 1234 123.4 1/1) #f)+(num-test (> 1234 123.4 1/1) #t)+(num-test (>= 1234 123.4 1/1) #t)+(num-test (+ 1234 123.4 1.0+1.0i) 1358.4+1.0i)+(num-test (- 1234 123.4 1.0+1.0i) 1109.59999999999991-1.0i)+(num-test (* 1234 123.4 1.0+1.0i) 152275.60000000000582+152275.60000000000582i)+(num-test (/ 1234 123.4 1.0+1.0i) 5.0-5.0i)+(num-test (= 1234 123.4 1.0+1.0i) #f)+(num-test (+ 1234 123.4 0) 1357.4)+(num-test (- 1234 123.4 0) 1110.59999999999991)+(num-test (* 1234 123.4 0) 0.0)+(num-test (+ 1234 123.4 0.0) 1357.4)+(num-test (- 1234 123.4 0.0) 1110.59999999999991)+(num-test (* 1234 123.4 0.0) 0.0)+(num-test (+ 1234 123.4 1234) 2591.4)+(num-test (- 1234 123.4 1234) -123.4)+(num-test (* 1234 123.4 1234) 187908090.40000000596046)+(num-test (/ 1234 123.4 1234) 0.00810372771475)+(num-test (= 1234 123.4 1234) #f)+(num-test (< 1234 123.4 1234) #f)+(num-test (<= 1234 123.4 1234) #f)+(num-test (> 1234 123.4 1234) #f)+(num-test (>= 1234 123.4 1234) #f)+(num-test (+ 1234 123.4 123.4) 1480.80000000000018)+(num-test (- 1234 123.4 123.4) 987.19999999999993)+(num-test (* 1234 123.4 123.4) 18790809.04000000283122)+(num-test (/ 1234 123.4 123.4) 0.08103727714749)+(num-test (= 1234 123.4 123.4) #f)+(num-test (< 1234 123.4 123.4) #f)+(num-test (<= 1234 123.4 123.4) #f)+(num-test (> 1234 123.4 123.4) #f)+(num-test (>= 1234 123.4 123.4) #t)+(num-test (+ 1234 123.4 1234/11) 1469.58181818181833)+(num-test (- 1234 123.4 1234/11) 998.41818181818178)+(num-test (* 1234 123.4 1234/11) 17082553.67272727191448)+(num-test (/ 1234 123.4 1234/11) 0.08914100486224)+(num-test (= 1234 123.4 1234/11) #f)+(num-test (< 1234 123.4 1234/11) #f)+(num-test (<= 1234 123.4 1234/11) #f)+(num-test (> 1234 123.4 1234/11) #t)+(num-test (>= 1234 123.4 1234/11) #t)+(num-test (+ 1234 123.4 1.234+1.234i) 1358.63400000000001+1.234i)+(num-test (- 1234 123.4 1.234+1.234i) 1109.36599999999999-1.234i)+(num-test (* 1234 123.4 1.234+1.234i) 187908.09040000001551+187908.09040000001551i)+(num-test (/ 1234 123.4 1.234+1.234i) 4.05186385737439-4.05186385737439i)+(num-test (= 1234 123.4 1.234+1.234i) #f)+(num-test (+ 1234 123.4 -1.0+1.0i) 1356.4+1.0i)+(num-test (- 1234 123.4 -1.0+1.0i) 1111.59999999999991-1.0i)+(num-test (* 1234 123.4 -1.0+1.0i) -152275.60000000000582+152275.60000000000582i)+(num-test (/ 1234 123.4 -1.0+1.0i) -5.0-5.0i)+(num-test (= 1234 123.4 -1.0+1.0i) #f)+(num-test (+ 1234 123.4 0.0+1.0i) 1357.4+1.0i)+(num-test (- 1234 123.4 0.0+1.0i) 1110.59999999999991-1.0i)+(num-test (* 1234 123.4 0.0+1.0i) 0.0+152275.60000000000582i)+(num-test (/ 1234 123.4 0.0+1.0i) 0.0-10.0i)+(num-test (= 1234 123.4 0.0+1.0i) #f)+(num-test (+ 1234 1234/11 1) 14819/11)+(num-test (- 1234 1234/11 1) 12329/11)+(num-test (* 1234 1234/11 1) 1522756/11)+(num-test (/ 1234 1234/11 1) 11)+(num-test (= 1234 1234/11 1) #f)+(num-test (< 1234 1234/11 1) #f)+(num-test (<= 1234 1234/11 1) #f)+(num-test (> 1234 1234/11 1) #t)+(num-test (>= 1234 1234/11 1) #t)+(num-test (+ 1234 1234/11 1.0) 1347.18181818181824)+(num-test (- 1234 1234/11 1.0) 1120.81818181818176)+(num-test (* 1234 1234/11 1.0) 138432.36363636364695)+(num-test (/ 1234 1234/11 1.0) 11.0)+(num-test (= 1234 1234/11 1.0) #f)+(num-test (< 1234 1234/11 1.0) #f)+(num-test (<= 1234 1234/11 1.0) #f)+(num-test (> 1234 1234/11 1.0) #t)+(num-test (>= 1234 1234/11 1.0) #t)+(num-test (+ 1234 1234/11 1/1) 14819/11)+(num-test (- 1234 1234/11 1/1) 12329/11)+(num-test (* 1234 1234/11 1/1) 1522756/11)+(num-test (/ 1234 1234/11 1/1) 11)+(num-test (= 1234 1234/11 1/1) #f)+(num-test (< 1234 1234/11 1/1) #f)+(num-test (<= 1234 1234/11 1/1) #f)+(num-test (> 1234 1234/11 1/1) #t)+(num-test (>= 1234 1234/11 1/1) #t)+(num-test (+ 1234 1234/11 1.0+1.0i) 1347.18181818181824+1.0i)+(num-test (- 1234 1234/11 1.0+1.0i) 1120.81818181818176-1.0i)+(num-test (* 1234 1234/11 1.0+1.0i) 138432.36363636364695+138432.36363636364695i)+(num-test (/ 1234 1234/11 1.0+1.0i) 5.50000000000000-5.50000000000000i)+(num-test (= 1234 1234/11 1.0+1.0i) #f)+(num-test (+ 1234 1234/11 0) 14808/11)+(num-test (- 1234 1234/11 0) 12340/11)+(num-test (* 1234 1234/11 0) 0)+(num-test (+ 1234 1234/11 0.0) 1346.18181818181824)+(num-test (- 1234 1234/11 0.0) 1121.81818181818176)+(num-test (* 1234 1234/11 0.0) 0.0)+(num-test (+ 1234 1234/11 1234) 28382/11)+(num-test (- 1234 1234/11 1234) -1234/11)+(if (not with-64-bit-ints)+    (num-test (* 1234 1234/11 1234) 170825536.727273)+    (num-test (* 1234 1234/11 1234) 1879080904/11))+(num-test (/ 1234 1234/11 1234) 11/1234)+(num-test (= 1234 1234/11 1234) #f)+(num-test (< 1234 1234/11 1234) #f)+(num-test (<= 1234 1234/11 1234) #f)+(num-test (> 1234 1234/11 1234) #f)+(num-test (>= 1234 1234/11 1234) #f)+(num-test (+ 1234 1234/11 123.4) 1469.58181818181833)+(num-test (- 1234 1234/11 123.4) 998.41818181818178)+(num-test (* 1234 1234/11 123.4) 17082553.67272727563977)+(num-test (/ 1234 1234/11 123.4) 0.08914100486224)+(num-test (= 1234 1234/11 123.4) #f)+(num-test (< 1234 1234/11 123.4) #f)+(num-test (<= 1234 1234/11 123.4) #f)+(num-test (> 1234 1234/11 123.4) #f)+(num-test (>= 1234 1234/11 123.4) #f)+(num-test (+ 1234 1234/11 1234/11) 16042/11)+(num-test (- 1234 1234/11 1234/11) 11106/11)+(if (not with-64-bit-ints)+    (num-test (* 1234 1234/11 1234/11) 15529594.2479339)+    (num-test (* 1234 1234/11 1234/11) 1879080904/121))+(num-test (/ 1234 1234/11 1234/11) 121/1234)+(num-test (= 1234 1234/11 1234/11) #f)+(num-test (< 1234 1234/11 1234/11) #f)+(num-test (<= 1234 1234/11 1234/11) #f)+(num-test (> 1234 1234/11 1234/11) #f)+(num-test (>= 1234 1234/11 1234/11) #t)+(num-test (+ 1234 1234/11 1.234+1.234i) 1347.41581818181817+1.234i)+(num-test (- 1234 1234/11 1.234+1.234i) 1120.58418181818183-1.234i)+(num-test (* 1234 1234/11 1.234+1.234i) 170825.53672727273079+170825.53672727273079i)+(num-test (/ 1234 1234/11 1.234+1.234i) 4.45705024311183-4.45705024311183i)+(num-test (= 1234 1234/11 1.234+1.234i) #f)+(num-test (+ 1234 1234/11 -1.0+1.0i) 1345.18181818181824+1.0i)+(num-test (- 1234 1234/11 -1.0+1.0i) 1122.81818181818176-1.0i)+(num-test (* 1234 1234/11 -1.0+1.0i) -138432.36363636364695+138432.36363636364695i)+(num-test (/ 1234 1234/11 -1.0+1.0i) -5.50000000000000-5.50000000000000i)+(num-test (= 1234 1234/11 -1.0+1.0i) #f)+(num-test (+ 1234 1234/11 0.0+1.0i) 1346.18181818181824+1.0i)+(num-test (- 1234 1234/11 0.0+1.0i) 1121.81818181818176-1.0i)+(num-test (* 1234 1234/11 0.0+1.0i) 0.0+138432.36363636364695i)+(num-test (/ 1234 1234/11 0.0+1.0i) 0.0-11.0i)+(num-test (= 1234 1234/11 0.0+1.0i) #f)+(num-test (+ 1234 1.234+1.234i 1) 1236.23399999999992+1.234i)+(num-test (- 1234 1.234+1.234i 1) 1231.766-1.234i)+(num-test (* 1234 1.234+1.234i 1) 1522.756+1522.756i)+(num-test (/ 1234 1.234+1.234i 1) 500.0-500.0i)+(num-test (= 1234 1.234+1.234i 1) #f)+(num-test (+ 1234 1.234+1.234i 1.0) 1236.23399999999992+1.234i)+(num-test (- 1234 1.234+1.234i 1.0) 1231.766-1.234i)+(num-test (* 1234 1.234+1.234i 1.0) 1522.756+1522.756i)+(num-test (/ 1234 1.234+1.234i 1.0) 500.0-500.0i)+(num-test (= 1234 1.234+1.234i 1.0) #f)+(num-test (+ 1234 1.234+1.234i 1/1) 1236.23399999999992+1.234i)+(num-test (- 1234 1.234+1.234i 1/1) 1231.766-1.234i)+(num-test (* 1234 1.234+1.234i 1/1) 1522.756+1522.756i)+(num-test (/ 1234 1.234+1.234i 1/1) 500.0-500.0i)+(num-test (= 1234 1.234+1.234i 1/1) #f)+(num-test (+ 1234 1.234+1.234i 1.0+1.0i) 1236.23399999999992+2.234i)+(num-test (- 1234 1.234+1.234i 1.0+1.0i) 1231.766-2.234i)+(num-test (* 1234 1.234+1.234i 1.0+1.0i) 0.0+3045.51200000000017i)+(num-test (/ 1234 1.234+1.234i 1.0+1.0i) 0.0-500.0i)+(num-test (= 1234 1.234+1.234i 1.0+1.0i) #f)+(num-test (+ 1234 1.234+1.234i 0) 1235.23399999999992+1.234i)+(num-test (- 1234 1.234+1.234i 0) 1232.766-1.234i)+(num-test (* 1234 1.234+1.234i 0) 0.0)+(num-test (+ 1234 1.234+1.234i 0.0) 1235.23399999999992+1.234i)+(num-test (- 1234 1.234+1.234i 0.0) 1232.766-1.234i)+(num-test (* 1234 1.234+1.234i 0.0) 0.0)+(num-test (+ 1234 1.234+1.234i 1234) 2469.23399999999992+1.234i)+(num-test (- 1234 1.234+1.234i 1234) -1.23399999999992-1.234i)+(num-test (* 1234 1.234+1.234i 1234) 1879080.90400000009686+1879080.90400000009686i)+(num-test (/ 1234 1.234+1.234i 1234) 0.40518638573744-0.40518638573744i)+(num-test (= 1234 1.234+1.234i 1234) #f)+(num-test (+ 1234 1.234+1.234i 123.4) 1358.63400000000001+1.234i)+(num-test (- 1234 1.234+1.234i 123.4) 1109.36599999999999-1.234i)+(num-test (* 1234 1.234+1.234i 123.4) 187908.09040000001551+187908.09040000001551i)+(num-test (/ 1234 1.234+1.234i 123.4) 4.05186385737439-4.05186385737439i)+(num-test (= 1234 1.234+1.234i 123.4) #f)+(num-test (+ 1234 1.234+1.234i 1234/11) 1347.41581818181817+1.234i)+(num-test (- 1234 1.234+1.234i 1234/11) 1120.58418181818183-1.234i)+(num-test (* 1234 1.234+1.234i 1234/11) 170825.53672727273079+170825.53672727273079i)+(num-test (/ 1234 1.234+1.234i 1234/11) 4.45705024311183-4.45705024311183i)+(num-test (= 1234 1.234+1.234i 1234/11) #f)+(num-test (+ 1234 1.234+1.234i 1.234+1.234i) 1236.46799999999985+2.468i)+(num-test (- 1234 1.234+1.234i 1.234+1.234i) 1231.53200000000015-2.468i)+(num-test (* 1234 1.234+1.234i 1.234+1.234i) 0.0+3758.16180800000029i)+(num-test (/ 1234 1.234+1.234i 1.234+1.234i) 0.0-405.18638573743925i)+(num-test (= 1234 1.234+1.234i 1.234+1.234i) #f)+(num-test (+ 1234 1.234+1.234i -1.0+1.0i) 1234.23399999999992+2.234i)+(num-test (- 1234 1.234+1.234i -1.0+1.0i) 1233.766-2.234i)+(num-test (* 1234 1.234+1.234i -1.0+1.0i) -3045.51200000000017)+(num-test (/ 1234 1.234+1.234i -1.0+1.0i) -500.0)+(num-test (= 1234 1.234+1.234i -1.0+1.0i) #f)+(num-test (+ 1234 1.234+1.234i 0.0+1.0i) 1235.23399999999992+2.234i)+(num-test (- 1234 1.234+1.234i 0.0+1.0i) 1232.766-2.234i)+(num-test (* 1234 1.234+1.234i 0.0+1.0i) -1522.756+1522.756i)+(num-test (/ 1234 1.234+1.234i 0.0+1.0i) -500.0-500.0i)+(num-test (= 1234 1.234+1.234i 0.0+1.0i) #f)+(num-test (+ 1234 -1.0+1.0i 1) 1234.0+1.0i)+(num-test (- 1234 -1.0+1.0i 1) 1234.0-1.0i)+(num-test (* 1234 -1.0+1.0i 1) -1234.0+1234.0i)+(num-test (/ 1234 -1.0+1.0i 1) -617.0-617.0i)+(num-test (= 1234 -1.0+1.0i 1) #f)+(num-test (+ 1234 -1.0+1.0i 1.0) 1234.0+1.0i)+(num-test (- 1234 -1.0+1.0i 1.0) 1234.0-1.0i)+(num-test (* 1234 -1.0+1.0i 1.0) -1234.0+1234.0i)+(num-test (/ 1234 -1.0+1.0i 1.0) -617.0-617.0i)+(num-test (= 1234 -1.0+1.0i 1.0) #f)+(num-test (+ 1234 -1.0+1.0i 1/1) 1234.0+1.0i)+(num-test (- 1234 -1.0+1.0i 1/1) 1234.0-1.0i)+(num-test (* 1234 -1.0+1.0i 1/1) -1234.0+1234.0i)+(num-test (/ 1234 -1.0+1.0i 1/1) -617.0-617.0i)+(num-test (= 1234 -1.0+1.0i 1/1) #f)+(num-test (+ 1234 -1.0+1.0i 1.0+1.0i) 1234.0+2.0i)+(num-test (- 1234 -1.0+1.0i 1.0+1.0i) 1234.0-2.0i)+(num-test (* 1234 -1.0+1.0i 1.0+1.0i) -2468.0)+(num-test (/ 1234 -1.0+1.0i 1.0+1.0i) -617.0)+(num-test (= 1234 -1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1234 -1.0+1.0i 0) 1233.0+1.0i)+(num-test (- 1234 -1.0+1.0i 0) 1235.0-1.0i)+(num-test (* 1234 -1.0+1.0i 0) -0.0)+(num-test (+ 1234 -1.0+1.0i 0.0) 1233.0+1.0i)+(num-test (- 1234 -1.0+1.0i 0.0) 1235.0-1.0i)+(num-test (* 1234 -1.0+1.0i 0.0) -0.0)+(num-test (+ 1234 -1.0+1.0i 1234) 2467.0+1.0i)+(num-test (- 1234 -1.0+1.0i 1234) 1.0-1.0i)+(num-test (* 1234 -1.0+1.0i 1234) -1522756.0+1522756.0i)+(num-test (/ 1234 -1.0+1.0i 1234) -0.5-0.5i)+(num-test (= 1234 -1.0+1.0i 1234) #f)+(num-test (+ 1234 -1.0+1.0i 123.4) 1356.4+1.0i)+(num-test (- 1234 -1.0+1.0i 123.4) 1111.59999999999991-1.0i)+(num-test (* 1234 -1.0+1.0i 123.4) -152275.60000000000582+152275.60000000000582i)+(num-test (/ 1234 -1.0+1.0i 123.4) -5.0-5.0i)+(num-test (= 1234 -1.0+1.0i 123.4) #f)+(num-test (+ 1234 -1.0+1.0i 1234/11) 1345.18181818181824+1.0i)+(num-test (- 1234 -1.0+1.0i 1234/11) 1122.81818181818176-1.0i)+(num-test (* 1234 -1.0+1.0i 1234/11) -138432.36363636364695+138432.36363636364695i)+(num-test (/ 1234 -1.0+1.0i 1234/11) -5.50000000000000-5.50000000000000i)+(num-test (= 1234 -1.0+1.0i 1234/11) #f)+(num-test (+ 1234 -1.0+1.0i 1.234+1.234i) 1234.23399999999992+2.234i)+(num-test (- 1234 -1.0+1.0i 1.234+1.234i) 1233.766-2.234i)+(num-test (* 1234 -1.0+1.0i 1.234+1.234i) -3045.51200000000017)+(num-test (/ 1234 -1.0+1.0i 1.234+1.234i) -500.0)+(num-test (= 1234 -1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1234 -1.0+1.0i -1.0+1.0i) 1232.0+2.0i)+(num-test (- 1234 -1.0+1.0i -1.0+1.0i) 1236.0-2.0i)+(num-test (* 1234 -1.0+1.0i -1.0+1.0i) 0.0-2468.0i)+(num-test (/ 1234 -1.0+1.0i -1.0+1.0i) -0.0+617.0i)+(num-test (= 1234 -1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1234 -1.0+1.0i 0.0+1.0i) 1233.0+2.0i)+(num-test (- 1234 -1.0+1.0i 0.0+1.0i) 1235.0-2.0i)+(num-test (* 1234 -1.0+1.0i 0.0+1.0i) -1234.0-1234.0i)+(num-test (/ 1234 -1.0+1.0i 0.0+1.0i) -617.0+617.0i)+(num-test (= 1234 -1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1234 0.0+1.0i 1) 1235.0+1.0i)+(num-test (- 1234 0.0+1.0i 1) 1233.0-1.0i)+(num-test (* 1234 0.0+1.0i 1) 0.0+1234.0i)+(num-test (/ 1234 0.0+1.0i 1) 0.0-1234.0i)+(num-test (= 1234 0.0+1.0i 1) #f)+(num-test (+ 1234 0.0+1.0i 1.0) 1235.0+1.0i)+(num-test (- 1234 0.0+1.0i 1.0) 1233.0-1.0i)+(num-test (* 1234 0.0+1.0i 1.0) 0.0+1234.0i)+(num-test (/ 1234 0.0+1.0i 1.0) 0.0-1234.0i)+(num-test (= 1234 0.0+1.0i 1.0) #f)+(num-test (+ 1234 0.0+1.0i 1/1) 1235.0+1.0i)+(num-test (- 1234 0.0+1.0i 1/1) 1233.0-1.0i)+(num-test (* 1234 0.0+1.0i 1/1) 0.0+1234.0i)+(num-test (/ 1234 0.0+1.0i 1/1) 0.0-1234.0i)+(num-test (= 1234 0.0+1.0i 1/1) #f)+(num-test (+ 1234 0.0+1.0i 1.0+1.0i) 1235.0+2.0i)+(num-test (- 1234 0.0+1.0i 1.0+1.0i) 1233.0-2.0i)+(num-test (* 1234 0.0+1.0i 1.0+1.0i) -1234.0+1234.0i)+(num-test (/ 1234 0.0+1.0i 1.0+1.0i) -617.0-617.0i)+(num-test (= 1234 0.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1234 0.0+1.0i 0) 1234.0+1.0i)+(num-test (- 1234 0.0+1.0i 0) 1234.0-1.0i)+(num-test (* 1234 0.0+1.0i 0) 0.0)+(num-test (+ 1234 0.0+1.0i 0.0) 1234.0+1.0i)+(num-test (- 1234 0.0+1.0i 0.0) 1234.0-1.0i)+(num-test (* 1234 0.0+1.0i 0.0) 0.0)+(num-test (+ 1234 0.0+1.0i 1234) 2468.0+1.0i)+(num-test (- 1234 0.0+1.0i 1234) 0.0-1.0i)+(num-test (* 1234 0.0+1.0i 1234) 0.0+1522756.0i)+(num-test (/ 1234 0.0+1.0i 1234) 0.0-1.0i)+(num-test (= 1234 0.0+1.0i 1234) #f)+(num-test (+ 1234 0.0+1.0i 123.4) 1357.4+1.0i)+(num-test (- 1234 0.0+1.0i 123.4) 1110.59999999999991-1.0i)+(num-test (* 1234 0.0+1.0i 123.4) 0.0+152275.60000000000582i)+(num-test (/ 1234 0.0+1.0i 123.4) 0.0-10.0i)+(num-test (= 1234 0.0+1.0i 123.4) #f)+(num-test (+ 1234 0.0+1.0i 1234/11) 1346.18181818181824+1.0i)+(num-test (- 1234 0.0+1.0i 1234/11) 1121.81818181818176-1.0i)+(num-test (* 1234 0.0+1.0i 1234/11) 0.0+138432.36363636364695i)+(num-test (/ 1234 0.0+1.0i 1234/11) 0.0-11.0i)+(num-test (= 1234 0.0+1.0i 1234/11) #f)+(num-test (+ 1234 0.0+1.0i 1.234+1.234i) 1235.23399999999992+2.234i)+(num-test (- 1234 0.0+1.0i 1.234+1.234i) 1232.766-2.234i)+(num-test (* 1234 0.0+1.0i 1.234+1.234i) -1522.756+1522.756i)+(num-test (/ 1234 0.0+1.0i 1.234+1.234i) -500.0-500.0i)+(num-test (= 1234 0.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1234 0.0+1.0i -1.0+1.0i) 1233.0+2.0i)+(num-test (- 1234 0.0+1.0i -1.0+1.0i) 1235.0-2.0i)+(num-test (* 1234 0.0+1.0i -1.0+1.0i) -1234.0-1234.0i)+(num-test (/ 1234 0.0+1.0i -1.0+1.0i) -617.0+617.0i)+(num-test (= 1234 0.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1234 0.0+1.0i 0.0+1.0i) 1234.0+2.0i)+(num-test (- 1234 0.0+1.0i 0.0+1.0i) 1234.0-2.0i)+(num-test (* 1234 0.0+1.0i 0.0+1.0i) -1234.0)+(num-test (/ 1234 0.0+1.0i 0.0+1.0i) -1234.0)+(num-test (= 1234 0.0+1.0i 0.0+1.0i) #f)+(num-test (+ 123.4 1 1) 125.4)+(num-test (- 123.4 1 1) 121.4)+(num-test (* 123.4 1 1) 123.4)+(num-test (/ 123.4 1 1) 123.4)+(num-test (= 123.4 1 1) #f)+(num-test (< 123.4 1 1) #f)+(num-test (<= 123.4 1 1) #f)+(num-test (> 123.4 1 1) #f)+(num-test (>= 123.4 1 1) #t)+(num-test (+ 123.4 1 1.0) 125.4)+(num-test (- 123.4 1 1.0) 121.4)+(num-test (* 123.4 1 1.0) 123.4)+(num-test (/ 123.4 1 1.0) 123.4)+(num-test (= 123.4 1 1.0) #f)+(num-test (< 123.4 1 1.0) #f)+(num-test (<= 123.4 1 1.0) #f)+(num-test (> 123.4 1 1.0) #f)+(num-test (>= 123.4 1 1.0) #t)+(num-test (+ 123.4 1 1/1) 125.4)+(num-test (- 123.4 1 1/1) 121.4)+(num-test (* 123.4 1 1/1) 123.4)+(num-test (/ 123.4 1 1/1) 123.4)+(num-test (= 123.4 1 1/1) #f)+(num-test (< 123.4 1 1/1) #f)+(num-test (<= 123.4 1 1/1) #f)+(num-test (> 123.4 1 1/1) #f)+(num-test (>= 123.4 1 1/1) #t)+(num-test (+ 123.4 1 1.0+1.0i) 125.4+1.0i)+(num-test (- 123.4 1 1.0+1.0i) 121.4-1.0i)+(num-test (* 123.4 1 1.0+1.0i) 123.4+123.4i)+(num-test (/ 123.4 1 1.0+1.0i) 61.7-61.7i)+(num-test (= 123.4 1 1.0+1.0i) #f)+(num-test (+ 123.4 1 0) 124.4)+(num-test (- 123.4 1 0) 122.4)+(num-test (* 123.4 1 0) 0.0)+(num-test (+ 123.4 1 0.0) 124.4)+(num-test (- 123.4 1 0.0) 122.4)+(num-test (* 123.4 1 0.0) 0.0)+(num-test (+ 123.4 1 1234) 1358.4)+(num-test (- 123.4 1 1234) -1111.59999999999991)+(num-test (* 123.4 1 1234) 152275.60000000000582)+(num-test (/ 123.4 1 1234) 0.1)+(num-test (= 123.4 1 1234) #f)+(num-test (< 123.4 1 1234) #f)+(num-test (<= 123.4 1 1234) #f)+(num-test (> 123.4 1 1234) #f)+(num-test (>= 123.4 1 1234) #f)+(num-test (+ 123.4 1 123.4) 247.8)+(num-test (- 123.4 1 123.4) -1.0)+(num-test (* 123.4 1 123.4) 15227.56000000000131)+(num-test (/ 123.4 1 123.4) 1.0)+(num-test (= 123.4 1 123.4) #f)+(num-test (< 123.4 1 123.4) #f)+(num-test (<= 123.4 1 123.4) #f)+(num-test (> 123.4 1 123.4) #f)+(num-test (>= 123.4 1 123.4) #f)+(num-test (+ 123.4 1 1234/11) 236.58181818181819)+(num-test (- 123.4 1 1234/11) 10.21818181818182)+(num-test (* 123.4 1 1234/11) 13843.23636363636433)+(num-test (/ 123.4 1 1234/11) 1.10000000000000)+(num-test (= 123.4 1 1234/11) #f)+(num-test (< 123.4 1 1234/11) #f)+(num-test (<= 123.4 1 1234/11) #f)+(num-test (> 123.4 1 1234/11) #f)+(num-test (>= 123.4 1 1234/11) #f)+(num-test (+ 123.4 1 1.234+1.234i) 125.634+1.234i)+(num-test (- 123.4 1 1.234+1.234i) 121.16600000000001-1.234i)+(num-test (* 123.4 1 1.234+1.234i) 152.2756+152.2756i)+(num-test (/ 123.4 1 1.234+1.234i) 50.0-50.0i)+(num-test (= 123.4 1 1.234+1.234i) #f)+(num-test (+ 123.4 1 -1.0+1.0i) 123.4+1.0i)+(num-test (- 123.4 1 -1.0+1.0i) 123.4-1.0i)+(num-test (* 123.4 1 -1.0+1.0i) -123.4+123.4i)+(num-test (/ 123.4 1 -1.0+1.0i) -61.7-61.7i)+(num-test (= 123.4 1 -1.0+1.0i) #f)+(num-test (+ 123.4 1 0.0+1.0i) 124.4+1.0i)+(num-test (- 123.4 1 0.0+1.0i) 122.4-1.0i)+(num-test (* 123.4 1 0.0+1.0i) 0.0+123.4i)+(num-test (/ 123.4 1 0.0+1.0i) 0.0-123.4i)+(num-test (= 123.4 1 0.0+1.0i) #f)+(num-test (+ 123.4 1.0 1) 125.4)+(num-test (- 123.4 1.0 1) 121.4)+(num-test (* 123.4 1.0 1) 123.4)+(num-test (/ 123.4 1.0 1) 123.4)+(num-test (= 123.4 1.0 1) #f)+(num-test (< 123.4 1.0 1) #f)+(num-test (<= 123.4 1.0 1) #f)+(num-test (> 123.4 1.0 1) #f)+(num-test (>= 123.4 1.0 1) #t)+(num-test (+ 123.4 1.0 1.0) 125.4)+(num-test (- 123.4 1.0 1.0) 121.4)+(num-test (* 123.4 1.0 1.0) 123.4)+(num-test (/ 123.4 1.0 1.0) 123.4)+(num-test (= 123.4 1.0 1.0) #f)+(num-test (< 123.4 1.0 1.0) #f)+(num-test (<= 123.4 1.0 1.0) #f)+(num-test (> 123.4 1.0 1.0) #f)+(num-test (>= 123.4 1.0 1.0) #t)+(num-test (+ 123.4 1.0 1/1) 125.4)+(num-test (- 123.4 1.0 1/1) 121.4)+(num-test (* 123.4 1.0 1/1) 123.4)+(num-test (/ 123.4 1.0 1/1) 123.4)+(num-test (= 123.4 1.0 1/1) #f)+(num-test (< 123.4 1.0 1/1) #f)+(num-test (<= 123.4 1.0 1/1) #f)+(num-test (> 123.4 1.0 1/1) #f)+(num-test (>= 123.4 1.0 1/1) #t)+(num-test (+ 123.4 1.0 1.0+1.0i) 125.4+1.0i)+(num-test (- 123.4 1.0 1.0+1.0i) 121.4-1.0i)+(num-test (* 123.4 1.0 1.0+1.0i) 123.4+123.4i)+(num-test (/ 123.4 1.0 1.0+1.0i) 61.7-61.7i)+(num-test (= 123.4 1.0 1.0+1.0i) #f)+(num-test (+ 123.4 1.0 0) 124.4)+(num-test (- 123.4 1.0 0) 122.4)+(num-test (* 123.4 1.0 0) 0.0)+(num-test (+ 123.4 1.0 0.0) 124.4)+(num-test (- 123.4 1.0 0.0) 122.4)+(num-test (* 123.4 1.0 0.0) 0.0)+(num-test (+ 123.4 1.0 1234) 1358.4)+(num-test (- 123.4 1.0 1234) -1111.59999999999991)+(num-test (* 123.4 1.0 1234) 152275.60000000000582)+(num-test (/ 123.4 1.0 1234) 0.1)+(num-test (= 123.4 1.0 1234) #f)+(num-test (< 123.4 1.0 1234) #f)+(num-test (<= 123.4 1.0 1234) #f)+(num-test (> 123.4 1.0 1234) #f)+(num-test (>= 123.4 1.0 1234) #f)+(num-test (+ 123.4 1.0 123.4) 247.8)+(num-test (- 123.4 1.0 123.4) -1.0)+(num-test (* 123.4 1.0 123.4) 15227.56000000000131)+(num-test (/ 123.4 1.0 123.4) 1.0)+(num-test (= 123.4 1.0 123.4) #f)+(num-test (< 123.4 1.0 123.4) #f)+(num-test (<= 123.4 1.0 123.4) #f)+(num-test (> 123.4 1.0 123.4) #f)+(num-test (>= 123.4 1.0 123.4) #f)+(num-test (+ 123.4 1.0 1234/11) 236.58181818181819)+(num-test (- 123.4 1.0 1234/11) 10.21818181818182)+(num-test (* 123.4 1.0 1234/11) 13843.23636363636433)+(num-test (/ 123.4 1.0 1234/11) 1.10000000000000)+(num-test (= 123.4 1.0 1234/11) #f)+(num-test (< 123.4 1.0 1234/11) #f)+(num-test (<= 123.4 1.0 1234/11) #f)+(num-test (> 123.4 1.0 1234/11) #f)+(num-test (>= 123.4 1.0 1234/11) #f)+(num-test (+ 123.4 1.0 1.234+1.234i) 125.634+1.234i)+(num-test (- 123.4 1.0 1.234+1.234i) 121.16600000000001-1.234i)+(num-test (* 123.4 1.0 1.234+1.234i) 152.2756+152.2756i)+(num-test (/ 123.4 1.0 1.234+1.234i) 50.0-50.0i)+(num-test (= 123.4 1.0 1.234+1.234i) #f)+(num-test (+ 123.4 1.0 -1.0+1.0i) 123.4+1.0i)+(num-test (- 123.4 1.0 -1.0+1.0i) 123.4-1.0i)+(num-test (* 123.4 1.0 -1.0+1.0i) -123.4+123.4i)+(num-test (/ 123.4 1.0 -1.0+1.0i) -61.7-61.7i)+(num-test (= 123.4 1.0 -1.0+1.0i) #f)+(num-test (+ 123.4 1.0 0.0+1.0i) 124.4+1.0i)+(num-test (- 123.4 1.0 0.0+1.0i) 122.4-1.0i)+(num-test (* 123.4 1.0 0.0+1.0i) 0.0+123.4i)+(num-test (/ 123.4 1.0 0.0+1.0i) 0.0-123.4i)+(num-test (= 123.4 1.0 0.0+1.0i) #f)+(num-test (+ 123.4 1/1 1) 125.4)+(num-test (- 123.4 1/1 1) 121.4)+(num-test (* 123.4 1/1 1) 123.4)+(num-test (/ 123.4 1/1 1) 123.4)+(num-test (= 123.4 1/1 1) #f)+(num-test (< 123.4 1/1 1) #f)+(num-test (<= 123.4 1/1 1) #f)+(num-test (> 123.4 1/1 1) #f)+(num-test (>= 123.4 1/1 1) #t)+(num-test (+ 123.4 1/1 1.0) 125.4)+(num-test (- 123.4 1/1 1.0) 121.4)+(num-test (* 123.4 1/1 1.0) 123.4)+(num-test (/ 123.4 1/1 1.0) 123.4)+(num-test (= 123.4 1/1 1.0) #f)+(num-test (< 123.4 1/1 1.0) #f)+(num-test (<= 123.4 1/1 1.0) #f)+(num-test (> 123.4 1/1 1.0) #f)+(num-test (>= 123.4 1/1 1.0) #t)+(num-test (+ 123.4 1/1 1/1) 125.4)+(num-test (- 123.4 1/1 1/1) 121.4)+(num-test (* 123.4 1/1 1/1) 123.4)+(num-test (/ 123.4 1/1 1/1) 123.4)+(num-test (= 123.4 1/1 1/1) #f)+(num-test (< 123.4 1/1 1/1) #f)+(num-test (<= 123.4 1/1 1/1) #f)+(num-test (> 123.4 1/1 1/1) #f)+(num-test (>= 123.4 1/1 1/1) #t)+(num-test (+ 123.4 1/1 1.0+1.0i) 125.4+1.0i)+(num-test (- 123.4 1/1 1.0+1.0i) 121.4-1.0i)+(num-test (* 123.4 1/1 1.0+1.0i) 123.4+123.4i)+(num-test (/ 123.4 1/1 1.0+1.0i) 61.7-61.7i)+(num-test (= 123.4 1/1 1.0+1.0i) #f)+(num-test (+ 123.4 1/1 0) 124.4)+(num-test (- 123.4 1/1 0) 122.4)+(num-test (* 123.4 1/1 0) 0.0)+(num-test (+ 123.4 1/1 0.0) 124.4)+(num-test (- 123.4 1/1 0.0) 122.4)+(num-test (* 123.4 1/1 0.0) 0.0)+(num-test (+ 123.4 1/1 1234) 1358.4)+(num-test (- 123.4 1/1 1234) -1111.59999999999991)+(num-test (* 123.4 1/1 1234) 152275.60000000000582)+(num-test (/ 123.4 1/1 1234) 0.1)+(num-test (= 123.4 1/1 1234) #f)+(num-test (< 123.4 1/1 1234) #f)+(num-test (<= 123.4 1/1 1234) #f)+(num-test (> 123.4 1/1 1234) #f)+(num-test (>= 123.4 1/1 1234) #f)+(num-test (+ 123.4 1/1 123.4) 247.8)+(num-test (- 123.4 1/1 123.4) -1.0)+(num-test (* 123.4 1/1 123.4) 15227.56000000000131)+(num-test (/ 123.4 1/1 123.4) 1.0)+(num-test (= 123.4 1/1 123.4) #f)+(num-test (< 123.4 1/1 123.4) #f)+(num-test (<= 123.4 1/1 123.4) #f)+(num-test (> 123.4 1/1 123.4) #f)+(num-test (>= 123.4 1/1 123.4) #f)+(num-test (+ 123.4 1/1 1234/11) 236.58181818181819)+(num-test (- 123.4 1/1 1234/11) 10.21818181818182)+(num-test (* 123.4 1/1 1234/11) 13843.23636363636433)+(num-test (/ 123.4 1/1 1234/11) 1.10000000000000)+(num-test (= 123.4 1/1 1234/11) #f)+(num-test (< 123.4 1/1 1234/11) #f)+(num-test (<= 123.4 1/1 1234/11) #f)+(num-test (> 123.4 1/1 1234/11) #f)+(num-test (>= 123.4 1/1 1234/11) #f)+(num-test (+ 123.4 1/1 1.234+1.234i) 125.634+1.234i)+(num-test (- 123.4 1/1 1.234+1.234i) 121.16600000000001-1.234i)+(num-test (* 123.4 1/1 1.234+1.234i) 152.2756+152.2756i)+(num-test (/ 123.4 1/1 1.234+1.234i) 50.0-50.0i)+(num-test (= 123.4 1/1 1.234+1.234i) #f)+(num-test (+ 123.4 1/1 -1.0+1.0i) 123.4+1.0i)+(num-test (- 123.4 1/1 -1.0+1.0i) 123.4-1.0i)+(num-test (* 123.4 1/1 -1.0+1.0i) -123.4+123.4i)+(num-test (/ 123.4 1/1 -1.0+1.0i) -61.7-61.7i)+(num-test (= 123.4 1/1 -1.0+1.0i) #f)+(num-test (+ 123.4 1/1 0.0+1.0i) 124.4+1.0i)+(num-test (- 123.4 1/1 0.0+1.0i) 122.4-1.0i)+(num-test (* 123.4 1/1 0.0+1.0i) 0.0+123.4i)+(num-test (/ 123.4 1/1 0.0+1.0i) 0.0-123.4i)+(num-test (= 123.4 1/1 0.0+1.0i) #f)+(num-test (+ 123.4 1.0+1.0i 1) 125.4+1.0i)+(num-test (- 123.4 1.0+1.0i 1) 121.4-1.0i)+(num-test (* 123.4 1.0+1.0i 1) 123.4+123.4i)+(num-test (/ 123.4 1.0+1.0i 1) 61.7-61.7i)+(num-test (= 123.4 1.0+1.0i 1) #f)+(num-test (+ 123.4 1.0+1.0i 1.0) 125.4+1.0i)+(num-test (- 123.4 1.0+1.0i 1.0) 121.4-1.0i)+(num-test (* 123.4 1.0+1.0i 1.0) 123.4+123.4i)+(num-test (/ 123.4 1.0+1.0i 1.0) 61.7-61.7i)+(num-test (= 123.4 1.0+1.0i 1.0) #f)+(num-test (+ 123.4 1.0+1.0i 1/1) 125.4+1.0i)+(num-test (- 123.4 1.0+1.0i 1/1) 121.4-1.0i)+(num-test (* 123.4 1.0+1.0i 1/1) 123.4+123.4i)+(num-test (/ 123.4 1.0+1.0i 1/1) 61.7-61.7i)+(num-test (= 123.4 1.0+1.0i 1/1) #f)+(num-test (+ 123.4 1.0+1.0i 1.0+1.0i) 125.4+2.0i)+(num-test (- 123.4 1.0+1.0i 1.0+1.0i) 121.4-2.0i)+(num-test (* 123.4 1.0+1.0i 1.0+1.0i) 0.0+246.8i)+(num-test (/ 123.4 1.0+1.0i 1.0+1.0i) 0.0-61.7i)+(num-test (= 123.4 1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 123.4 1.0+1.0i 0) 124.4+1.0i)+(num-test (- 123.4 1.0+1.0i 0) 122.4-1.0i)+(num-test (* 123.4 1.0+1.0i 0) 0.0)+(num-test (+ 123.4 1.0+1.0i 0.0) 124.4+1.0i)+(num-test (- 123.4 1.0+1.0i 0.0) 122.4-1.0i)+(num-test (* 123.4 1.0+1.0i 0.0) 0.0)+(num-test (+ 123.4 1.0+1.0i 1234) 1358.4+1.0i)+(num-test (- 123.4 1.0+1.0i 1234) -1111.59999999999991-1.0i)+(num-test (* 123.4 1.0+1.0i 1234) 152275.60000000000582+152275.60000000000582i)+(num-test (/ 123.4 1.0+1.0i 1234) 0.05000000000000-0.05000000000000i)+(num-test (= 123.4 1.0+1.0i 1234) #f)+(num-test (+ 123.4 1.0+1.0i 123.4) 247.8+1.0i)+(num-test (- 123.4 1.0+1.0i 123.4) -1.0-1.0i)+(num-test (* 123.4 1.0+1.0i 123.4) 15227.56000000000131+15227.56000000000131i)+(num-test (/ 123.4 1.0+1.0i 123.4) 0.5-0.5i)+(num-test (= 123.4 1.0+1.0i 123.4) #f)+(num-test (+ 123.4 1.0+1.0i 1234/11) 236.58181818181819+1.0i)+(num-test (- 123.4 1.0+1.0i 1234/11) 10.21818181818182-1.0i)+(num-test (* 123.4 1.0+1.0i 1234/11) 13843.23636363636433+13843.23636363636433i)+(num-test (/ 123.4 1.0+1.0i 1234/11) 0.55000000000000-0.55000000000000i)+(num-test (= 123.4 1.0+1.0i 1234/11) #f)+(num-test (+ 123.4 1.0+1.0i 1.234+1.234i) 125.634+2.234i)+(num-test (- 123.4 1.0+1.0i 1.234+1.234i) 121.16600000000001-2.234i)+(num-test (* 123.4 1.0+1.0i 1.234+1.234i) 0.0+304.55119999999999i)+(num-test (/ 123.4 1.0+1.0i 1.234+1.234i) 0.0-50.0i)+(num-test (= 123.4 1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 123.4 1.0+1.0i -1.0+1.0i) 123.4+2.0i)+(num-test (- 123.4 1.0+1.0i -1.0+1.0i) 123.4-2.0i)+(num-test (* 123.4 1.0+1.0i -1.0+1.0i) -246.8)+(num-test (/ 123.4 1.0+1.0i -1.0+1.0i) -61.7)+(num-test (= 123.4 1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 123.4 1.0+1.0i 0.0+1.0i) 124.4+2.0i)+(num-test (- 123.4 1.0+1.0i 0.0+1.0i) 122.4-2.0i)+(num-test (* 123.4 1.0+1.0i 0.0+1.0i) -123.4+123.4i)+(num-test (/ 123.4 1.0+1.0i 0.0+1.0i) -61.7-61.7i)+(num-test (= 123.4 1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 123.4 0 1) 124.4)+(num-test (- 123.4 0 1) 122.4)+(num-test (* 123.4 0 1) 0.0)+(num-test (+ 123.4 0 1.0) 124.4)+(num-test (- 123.4 0 1.0) 122.4)+(num-test (* 123.4 0 1.0) 0.0)+(num-test (+ 123.4 0 1/1) 124.4)+(num-test (- 123.4 0 1/1) 122.4)+(num-test (* 123.4 0 1/1) 0.0)+(num-test (+ 123.4 0 1.0+1.0i) 124.4+1.0i)+(num-test (- 123.4 0 1.0+1.0i) 122.4-1.0i)+(num-test (* 123.4 0 1.0+1.0i) 0.0)+(num-test (+ 123.4 0 0) 123.4)+(num-test (- 123.4 0 0) 123.4)+(num-test (* 123.4 0 0) 0.0)+(num-test (+ 123.4 0 0.0) 123.4)+(num-test (- 123.4 0 0.0) 123.4)+(num-test (* 123.4 0 0.0) 0.0)+(num-test (+ 123.4 0 1234) 1357.4)+(num-test (- 123.4 0 1234) -1110.59999999999991)+(num-test (* 123.4 0 1234) 0.0)+(num-test (+ 123.4 0 123.4) 246.8)+(num-test (- 123.4 0 123.4) 0.0)+(num-test (* 123.4 0 123.4) 0.0)+(num-test (+ 123.4 0 1234/11) 235.58181818181819)+(num-test (- 123.4 0 1234/11) 11.21818181818182)+(num-test (* 123.4 0 1234/11) 0.0)+(num-test (+ 123.4 0 1.234+1.234i) 124.634+1.234i)+(num-test (- 123.4 0 1.234+1.234i) 122.16600000000001-1.234i)+(num-test (* 123.4 0 1.234+1.234i) 0.0)+(num-test (+ 123.4 0 -1.0+1.0i) 122.4+1.0i)+(num-test (- 123.4 0 -1.0+1.0i) 124.4-1.0i)+(num-test (* 123.4 0 -1.0+1.0i) -0.0)+(num-test (+ 123.4 0 0.0+1.0i) 123.4+1.0i)+(num-test (- 123.4 0 0.0+1.0i) 123.4-1.0i)+(num-test (* 123.4 0 0.0+1.0i) 0.0)+(num-test (+ 123.4 0.0 1) 124.4)+(num-test (- 123.4 0.0 1) 122.4)+(num-test (* 123.4 0.0 1) 0.0)+(num-test (+ 123.4 0.0 1.0) 124.4)+(num-test (- 123.4 0.0 1.0) 122.4)+(num-test (* 123.4 0.0 1.0) 0.0)+(num-test (+ 123.4 0.0 1/1) 124.4)+(num-test (- 123.4 0.0 1/1) 122.4)+(num-test (* 123.4 0.0 1/1) 0.0)+(num-test (+ 123.4 0.0 1.0+1.0i) 124.4+1.0i)+(num-test (- 123.4 0.0 1.0+1.0i) 122.4-1.0i)+(num-test (* 123.4 0.0 1.0+1.0i) 0.0)+(num-test (+ 123.4 0.0 0) 123.4)+(num-test (- 123.4 0.0 0) 123.4)+(num-test (* 123.4 0.0 0) 0.0)+(num-test (+ 123.4 0.0 0.0) 123.4)+(num-test (- 123.4 0.0 0.0) 123.4)+(num-test (* 123.4 0.0 0.0) 0.0)+(num-test (+ 123.4 0.0 1234) 1357.4)+(num-test (- 123.4 0.0 1234) -1110.59999999999991)+(num-test (* 123.4 0.0 1234) 0.0)+(num-test (+ 123.4 0.0 123.4) 246.8)+(num-test (- 123.4 0.0 123.4) 0.0)+(num-test (* 123.4 0.0 123.4) 0.0)+(num-test (+ 123.4 0.0 1234/11) 235.58181818181819)+(num-test (- 123.4 0.0 1234/11) 11.21818181818182)+(num-test (* 123.4 0.0 1234/11) 0.0)+(num-test (+ 123.4 0.0 1.234+1.234i) 124.634+1.234i)+(num-test (- 123.4 0.0 1.234+1.234i) 122.16600000000001-1.234i)+(num-test (* 123.4 0.0 1.234+1.234i) 0.0)+(num-test (+ 123.4 0.0 -1.0+1.0i) 122.4+1.0i)+(num-test (- 123.4 0.0 -1.0+1.0i) 124.4-1.0i)+(num-test (* 123.4 0.0 -1.0+1.0i) -0.0)+(num-test (+ 123.4 0.0 0.0+1.0i) 123.4+1.0i)+(num-test (- 123.4 0.0 0.0+1.0i) 123.4-1.0i)+(num-test (* 123.4 0.0 0.0+1.0i) 0.0)+(num-test (+ 123.4 1234 1) 1358.4)+(num-test (- 123.4 1234 1) -1111.59999999999991)+(num-test (* 123.4 1234 1) 152275.60000000000582)+(num-test (/ 123.4 1234 1) 0.1)+(num-test (= 123.4 1234 1) #f)+(num-test (< 123.4 1234 1) #f)+(num-test (<= 123.4 1234 1) #f)+(num-test (> 123.4 1234 1) #f)+(num-test (>= 123.4 1234 1) #f)+(num-test (+ 123.4 1234 1.0) 1358.4)+(num-test (- 123.4 1234 1.0) -1111.59999999999991)+(num-test (* 123.4 1234 1.0) 152275.60000000000582)+(num-test (/ 123.4 1234 1.0) 0.1)+(num-test (= 123.4 1234 1.0) #f)+(num-test (< 123.4 1234 1.0) #f)+(num-test (<= 123.4 1234 1.0) #f)+(num-test (> 123.4 1234 1.0) #f)+(num-test (>= 123.4 1234 1.0) #f)+(num-test (+ 123.4 1234 1/1) 1358.4)+(num-test (- 123.4 1234 1/1) -1111.59999999999991)+(num-test (* 123.4 1234 1/1) 152275.60000000000582)+(num-test (/ 123.4 1234 1/1) 0.1)+(num-test (= 123.4 1234 1/1) #f)+(num-test (< 123.4 1234 1/1) #f)+(num-test (<= 123.4 1234 1/1) #f)+(num-test (> 123.4 1234 1/1) #f)+(num-test (>= 123.4 1234 1/1) #f)+(num-test (+ 123.4 1234 1.0+1.0i) 1358.4+1.0i)+(num-test (- 123.4 1234 1.0+1.0i) -1111.59999999999991-1.0i)+(num-test (* 123.4 1234 1.0+1.0i) 152275.60000000000582+152275.60000000000582i)+(num-test (/ 123.4 1234 1.0+1.0i) 0.05000000000000-0.05000000000000i)+(num-test (= 123.4 1234 1.0+1.0i) #f)+(num-test (+ 123.4 1234 0) 1357.4)+(num-test (- 123.4 1234 0) -1110.59999999999991)+(num-test (* 123.4 1234 0) 0.0)+(num-test (+ 123.4 1234 0.0) 1357.4)+(num-test (- 123.4 1234 0.0) -1110.59999999999991)+(num-test (* 123.4 1234 0.0) 0.0)+(num-test (+ 123.4 1234 1234) 2591.4)+(num-test (- 123.4 1234 1234) -2344.59999999999991)+(num-test (* 123.4 1234 1234) 187908090.40000000596046)+(num-test (/ 123.4 1234 1234) 0.00008103727715)+(num-test (= 123.4 1234 1234) #f)+(num-test (< 123.4 1234 1234) #f)+(num-test (<= 123.4 1234 1234) #t)+(num-test (> 123.4 1234 1234) #f)+(num-test (>= 123.4 1234 1234) #f)+(num-test (+ 123.4 1234 123.4) 1480.80000000000018)+(num-test (- 123.4 1234 123.4) -1234.0)+(num-test (* 123.4 1234 123.4) 18790809.04000000283122)+(num-test (/ 123.4 1234 123.4) 0.00081037277147)+(num-test (= 123.4 1234 123.4) #f)+(num-test (< 123.4 1234 123.4) #f)+(num-test (<= 123.4 1234 123.4) #f)+(num-test (> 123.4 1234 123.4) #f)+(num-test (>= 123.4 1234 123.4) #f)+(num-test (+ 123.4 1234 1234/11) 1469.58181818181833)+(num-test (- 123.4 1234 1234/11) -1222.78181818181815)+(num-test (* 123.4 1234 1234/11) 17082553.67272727191448)+(num-test (/ 123.4 1234 1234/11) 0.00089141004862)+(num-test (= 123.4 1234 1234/11) #f)+(num-test (< 123.4 1234 1234/11) #f)+(num-test (<= 123.4 1234 1234/11) #f)+(num-test (> 123.4 1234 1234/11) #f)+(num-test (>= 123.4 1234 1234/11) #f)+(num-test (+ 123.4 1234 1.234+1.234i) 1358.63400000000001+1.234i)+(num-test (- 123.4 1234 1.234+1.234i) -1111.83399999999983-1.234i)+(num-test (* 123.4 1234 1.234+1.234i) 187908.09040000001551+187908.09040000001551i)+(num-test (/ 123.4 1234 1.234+1.234i) 0.04051863857374-0.04051863857374i)+(num-test (= 123.4 1234 1.234+1.234i) #f)+(num-test (+ 123.4 1234 -1.0+1.0i) 1356.4+1.0i)+(num-test (- 123.4 1234 -1.0+1.0i) -1109.59999999999991-1.0i)+(num-test (* 123.4 1234 -1.0+1.0i) -152275.60000000000582+152275.60000000000582i)+(num-test (/ 123.4 1234 -1.0+1.0i) -0.05000000000000-0.05000000000000i)+(num-test (= 123.4 1234 -1.0+1.0i) #f)+(num-test (+ 123.4 1234 0.0+1.0i) 1357.4+1.0i)+(num-test (- 123.4 1234 0.0+1.0i) -1110.59999999999991-1.0i)+(num-test (* 123.4 1234 0.0+1.0i) 0.0+152275.60000000000582i)+(num-test (/ 123.4 1234 0.0+1.0i) 0.0-0.1i)+(num-test (= 123.4 1234 0.0+1.0i) #f)+(num-test (+ 123.4 123.4 1) 247.8)+(num-test (- 123.4 123.4 1) -1.0)+(num-test (* 123.4 123.4 1) 15227.56000000000131)+(num-test (/ 123.4 123.4 1) 1.0)+(num-test (= 123.4 123.4 1) #f)+(num-test (< 123.4 123.4 1) #f)+(num-test (<= 123.4 123.4 1) #f)+(num-test (> 123.4 123.4 1) #f)+(num-test (>= 123.4 123.4 1) #t)+(num-test (+ 123.4 123.4 1.0) 247.8)+(num-test (- 123.4 123.4 1.0) -1.0)+(num-test (* 123.4 123.4 1.0) 15227.56000000000131)+(num-test (/ 123.4 123.4 1.0) 1.0)+(num-test (= 123.4 123.4 1.0) #f)+(num-test (< 123.4 123.4 1.0) #f)+(num-test (<= 123.4 123.4 1.0) #f)+(num-test (> 123.4 123.4 1.0) #f)+(num-test (>= 123.4 123.4 1.0) #t)+(num-test (+ 123.4 123.4 1/1) 247.8)+(num-test (- 123.4 123.4 1/1) -1.0)+(num-test (* 123.4 123.4 1/1) 15227.56000000000131)+(num-test (/ 123.4 123.4 1/1) 1.0)+(num-test (= 123.4 123.4 1/1) #f)+(num-test (< 123.4 123.4 1/1) #f)+(num-test (<= 123.4 123.4 1/1) #f)+(num-test (> 123.4 123.4 1/1) #f)+(num-test (>= 123.4 123.4 1/1) #t)+(num-test (+ 123.4 123.4 1.0+1.0i) 247.8+1.0i)+(num-test (- 123.4 123.4 1.0+1.0i) -1.0-1.0i)+(num-test (* 123.4 123.4 1.0+1.0i) 15227.56000000000131+15227.56000000000131i)+(num-test (/ 123.4 123.4 1.0+1.0i) 0.5-0.5i)+(num-test (= 123.4 123.4 1.0+1.0i) #f)+(num-test (+ 123.4 123.4 0) 246.8)+(num-test (- 123.4 123.4 0) 0.0)+(num-test (* 123.4 123.4 0) 0.0)+(num-test (+ 123.4 123.4 0.0) 246.8)+(num-test (- 123.4 123.4 0.0) 0.0)+(num-test (* 123.4 123.4 0.0) 0.0)+(num-test (+ 123.4 123.4 1234) 1480.79999999999995)+(num-test (- 123.4 123.4 1234) -1234.0)+(num-test (* 123.4 123.4 1234) 18790809.04000000283122)+(num-test (/ 123.4 123.4 1234) 0.00081037277147)+(num-test (= 123.4 123.4 1234) #f)+(num-test (< 123.4 123.4 1234) #f)+(num-test (<= 123.4 123.4 1234) #t)+(num-test (> 123.4 123.4 1234) #f)+(num-test (>= 123.4 123.4 1234) #f)+(num-test (+ 123.4 123.4 123.4) 370.20000000000005)+(num-test (- 123.4 123.4 123.4) -123.4)+(num-test (* 123.4 123.4 123.4) 1879080.90400000032969)+(num-test (/ 123.4 123.4 123.4) 0.00810372771475)+(num-test (= 123.4 123.4 123.4) #t)+(num-test (< 123.4 123.4 123.4) #f)+(num-test (<= 123.4 123.4 123.4) #t)+(num-test (> 123.4 123.4 123.4) #f)+(num-test (>= 123.4 123.4 123.4) #t)+(num-test (+ 123.4 123.4 1234/11) 358.98181818181820)+(num-test (- 123.4 123.4 1234/11) -112.18181818181819)+(num-test (* 123.4 123.4 1234/11) 1708255.36727272742428)+(num-test (/ 123.4 123.4 1234/11) 0.00891410048622)+(num-test (= 123.4 123.4 1234/11) #f)+(num-test (< 123.4 123.4 1234/11) #f)+(num-test (<= 123.4 123.4 1234/11) #f)+(num-test (> 123.4 123.4 1234/11) #f)+(num-test (>= 123.4 123.4 1234/11) #t)+(num-test (+ 123.4 123.4 1.234+1.234i) 248.03400000000002+1.234i)+(num-test (- 123.4 123.4 1.234+1.234i) -1.234-1.234i)+(num-test (* 123.4 123.4 1.234+1.234i) 18790.80904000000010+18790.80904000000010i)+(num-test (/ 123.4 123.4 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 123.4 123.4 1.234+1.234i) #f)+(num-test (+ 123.4 123.4 -1.0+1.0i) 245.8+1.0i)+(num-test (- 123.4 123.4 -1.0+1.0i) 1.0-1.0i)+(num-test (* 123.4 123.4 -1.0+1.0i) -15227.56000000000131+15227.56000000000131i)+(num-test (/ 123.4 123.4 -1.0+1.0i) -0.5-0.5i)+(num-test (= 123.4 123.4 -1.0+1.0i) #f)+(num-test (+ 123.4 123.4 0.0+1.0i) 246.8+1.0i)+(num-test (- 123.4 123.4 0.0+1.0i) 0.0-1.0i)+(num-test (* 123.4 123.4 0.0+1.0i) 0.0+15227.56000000000131i)+(num-test (/ 123.4 123.4 0.0+1.0i) 0.0-1.0i)+(num-test (= 123.4 123.4 0.0+1.0i) #f)+(num-test (+ 123.4 1234/11 1) 236.58181818181819)+(num-test (- 123.4 1234/11 1) 10.21818181818182)+(num-test (* 123.4 1234/11 1) 13843.23636363636433)+(num-test (/ 123.4 1234/11 1) 1.10000000000000)+(num-test (= 123.4 1234/11 1) #f)+(num-test (< 123.4 1234/11 1) #f)+(num-test (<= 123.4 1234/11 1) #f)+(num-test (> 123.4 1234/11 1) #t)+(num-test (>= 123.4 1234/11 1) #t)+(num-test (+ 123.4 1234/11 1.0) 236.58181818181819)+(num-test (- 123.4 1234/11 1.0) 10.21818181818182)+(num-test (* 123.4 1234/11 1.0) 13843.23636363636433)+(num-test (/ 123.4 1234/11 1.0) 1.10000000000000)+(num-test (= 123.4 1234/11 1.0) #f)+(num-test (< 123.4 1234/11 1.0) #f)+(num-test (<= 123.4 1234/11 1.0) #f)+(num-test (> 123.4 1234/11 1.0) #t)+(num-test (>= 123.4 1234/11 1.0) #t)+(num-test (+ 123.4 1234/11 1/1) 236.58181818181819)+(num-test (- 123.4 1234/11 1/1) 10.21818181818182)+(num-test (* 123.4 1234/11 1/1) 13843.23636363636433)+(num-test (/ 123.4 1234/11 1/1) 1.10000000000000)+(num-test (= 123.4 1234/11 1/1) #f)+(num-test (< 123.4 1234/11 1/1) #f)+(num-test (<= 123.4 1234/11 1/1) #f)+(num-test (> 123.4 1234/11 1/1) #t)+(num-test (>= 123.4 1234/11 1/1) #t)+(num-test (+ 123.4 1234/11 1.0+1.0i) 236.58181818181819+1.0i)+(num-test (- 123.4 1234/11 1.0+1.0i) 10.21818181818182-1.0i)+(num-test (* 123.4 1234/11 1.0+1.0i) 13843.23636363636433+13843.23636363636433i)+(num-test (/ 123.4 1234/11 1.0+1.0i) 0.55000000000000-0.55000000000000i)+(num-test (= 123.4 1234/11 1.0+1.0i) #f)+(num-test (+ 123.4 1234/11 0) 235.58181818181819)+(num-test (- 123.4 1234/11 0) 11.21818181818182)+(num-test (* 123.4 1234/11 0) 0.0)+(num-test (+ 123.4 1234/11 0.0) 235.58181818181819)+(num-test (- 123.4 1234/11 0.0) 11.21818181818182)+(num-test (* 123.4 1234/11 0.0) 0.0)+(num-test (+ 123.4 1234/11 1234) 1469.58181818181811)+(num-test (- 123.4 1234/11 1234) -1222.78181818181815)+(num-test (* 123.4 1234/11 1234) 17082553.67272727191448)+(num-test (/ 123.4 1234/11 1234) 0.00089141004862)+(num-test (= 123.4 1234/11 1234) #f)+(num-test (< 123.4 1234/11 1234) #f)+(num-test (<= 123.4 1234/11 1234) #f)+(num-test (> 123.4 1234/11 1234) #f)+(num-test (>= 123.4 1234/11 1234) #f)+(num-test (+ 123.4 1234/11 123.4) 358.98181818181820)+(num-test (- 123.4 1234/11 123.4) -112.18181818181819)+(num-test (* 123.4 1234/11 123.4) 1708255.36727272742428)+(num-test (/ 123.4 1234/11 123.4) 0.00891410048622)+(num-test (= 123.4 1234/11 123.4) #f)+(num-test (< 123.4 1234/11 123.4) #f)+(num-test (<= 123.4 1234/11 123.4) #f)+(num-test (> 123.4 1234/11 123.4) #f)+(num-test (>= 123.4 1234/11 123.4) #f)+(num-test (+ 123.4 1234/11 1234/11) 347.76363636363635)+(num-test (- 123.4 1234/11 1234/11) -100.96363636363635)+(num-test (* 123.4 1234/11 1234/11) 1552959.42479338846169)+(num-test (/ 123.4 1234/11 1234/11) 0.00980551053485)+(num-test (= 123.4 1234/11 1234/11) #f)+(num-test (< 123.4 1234/11 1234/11) #f)+(num-test (<= 123.4 1234/11 1234/11) #f)+(num-test (> 123.4 1234/11 1234/11) #f)+(num-test (>= 123.4 1234/11 1234/11) #t)+(num-test (+ 123.4 1234/11 1.234+1.234i) 236.81581818181820+1.234i)+(num-test (- 123.4 1234/11 1.234+1.234i) 9.98418181818182-1.234i)+(num-test (* 123.4 1234/11 1.234+1.234i) 17082.55367272727381+17082.55367272727381i)+(num-test (/ 123.4 1234/11 1.234+1.234i) 0.44570502431118-0.44570502431118i)+(num-test (= 123.4 1234/11 1.234+1.234i) #f)+(num-test (+ 123.4 1234/11 -1.0+1.0i) 234.58181818181819+1.0i)+(num-test (- 123.4 1234/11 -1.0+1.0i) 12.21818181818182-1.0i)+(num-test (* 123.4 1234/11 -1.0+1.0i) -13843.23636363636433+13843.23636363636433i)+(num-test (/ 123.4 1234/11 -1.0+1.0i) -0.55000000000000-0.55000000000000i)+(num-test (= 123.4 1234/11 -1.0+1.0i) #f)+(num-test (+ 123.4 1234/11 0.0+1.0i) 235.58181818181819+1.0i)+(num-test (- 123.4 1234/11 0.0+1.0i) 11.21818181818182-1.0i)+(num-test (* 123.4 1234/11 0.0+1.0i) 0.0+13843.23636363636433i)+(num-test (/ 123.4 1234/11 0.0+1.0i) 0.0-1.10000000000000i)+(num-test (= 123.4 1234/11 0.0+1.0i) #f)+(num-test (+ 123.4 1.234+1.234i 1) 125.634+1.234i)+(num-test (- 123.4 1.234+1.234i 1) 121.16600000000001-1.234i)+(num-test (* 123.4 1.234+1.234i 1) 152.2756+152.2756i)+(num-test (/ 123.4 1.234+1.234i 1) 50.0-50.0i)+(num-test (= 123.4 1.234+1.234i 1) #f)+(num-test (+ 123.4 1.234+1.234i 1.0) 125.634+1.234i)+(num-test (- 123.4 1.234+1.234i 1.0) 121.16600000000001-1.234i)+(num-test (* 123.4 1.234+1.234i 1.0) 152.2756+152.2756i)+(num-test (/ 123.4 1.234+1.234i 1.0) 50.0-50.0i)+(num-test (= 123.4 1.234+1.234i 1.0) #f)+(num-test (+ 123.4 1.234+1.234i 1/1) 125.634+1.234i)+(num-test (- 123.4 1.234+1.234i 1/1) 121.16600000000001-1.234i)+(num-test (* 123.4 1.234+1.234i 1/1) 152.2756+152.2756i)+(num-test (/ 123.4 1.234+1.234i 1/1) 50.0-50.0i)+(num-test (= 123.4 1.234+1.234i 1/1) #f)+(num-test (+ 123.4 1.234+1.234i 1.0+1.0i) 125.634+2.234i)+(num-test (- 123.4 1.234+1.234i 1.0+1.0i) 121.16600000000001-2.234i)+(num-test (* 123.4 1.234+1.234i 1.0+1.0i) 0.0+304.55119999999999i)+(num-test (/ 123.4 1.234+1.234i 1.0+1.0i) 0.0-50.0i)+(num-test (= 123.4 1.234+1.234i 1.0+1.0i) #f)+(num-test (+ 123.4 1.234+1.234i 0) 124.634+1.234i)+(num-test (- 123.4 1.234+1.234i 0) 122.16600000000001-1.234i)+(num-test (* 123.4 1.234+1.234i 0) 0.0)+(num-test (+ 123.4 1.234+1.234i 0.0) 124.634+1.234i)+(num-test (- 123.4 1.234+1.234i 0.0) 122.16600000000001-1.234i)+(num-test (* 123.4 1.234+1.234i 0.0) 0.0)+(num-test (+ 123.4 1.234+1.234i 1234) 1358.63400000000001+1.234i)+(num-test (- 123.4 1.234+1.234i 1234) -1111.83400000000006-1.234i)+(num-test (* 123.4 1.234+1.234i 1234) 187908.09039999998640+187908.09039999998640i)+(num-test (/ 123.4 1.234+1.234i 1234) 0.04051863857374-0.04051863857374i)+(num-test (= 123.4 1.234+1.234i 1234) #f)+(num-test (+ 123.4 1.234+1.234i 123.4) 248.03399999999999+1.234i)+(num-test (- 123.4 1.234+1.234i 123.4) -1.23399999999999-1.234i)+(num-test (* 123.4 1.234+1.234i 123.4) 18790.80904000000010+18790.80904000000010i)+(num-test (/ 123.4 1.234+1.234i 123.4) 0.40518638573744-0.40518638573744i)+(num-test (= 123.4 1.234+1.234i 123.4) #f)+(num-test (+ 123.4 1.234+1.234i 1234/11) 236.81581818181817+1.234i)+(num-test (- 123.4 1.234+1.234i 1234/11) 9.98418181818183-1.234i)+(num-test (* 123.4 1.234+1.234i 1234/11) 17082.55367272727381+17082.55367272727381i)+(num-test (/ 123.4 1.234+1.234i 1234/11) 0.44570502431118-0.44570502431118i)+(num-test (= 123.4 1.234+1.234i 1234/11) #f)+(num-test (+ 123.4 1.234+1.234i 1.234+1.234i) 125.86799999999999+2.468i)+(num-test (- 123.4 1.234+1.234i 1.234+1.234i) 120.93200000000002-2.468i)+(num-test (* 123.4 1.234+1.234i 1.234+1.234i) 0.0+375.81618079999998i)+(num-test (/ 123.4 1.234+1.234i 1.234+1.234i) 0.0-40.51863857374392i)+(num-test (= 123.4 1.234+1.234i 1.234+1.234i) #f)+(num-test (+ 123.4 1.234+1.234i -1.0+1.0i) 123.634+2.234i)+(num-test (- 123.4 1.234+1.234i -1.0+1.0i) 123.16600000000001-2.234i)+(num-test (* 123.4 1.234+1.234i -1.0+1.0i) -304.55119999999999)+(num-test (/ 123.4 1.234+1.234i -1.0+1.0i) -50.0)+(num-test (= 123.4 1.234+1.234i -1.0+1.0i) #f)+(num-test (+ 123.4 1.234+1.234i 0.0+1.0i) 124.634+2.234i)+(num-test (- 123.4 1.234+1.234i 0.0+1.0i) 122.16600000000001-2.234i)+(num-test (* 123.4 1.234+1.234i 0.0+1.0i) -152.2756+152.2756i)+(num-test (/ 123.4 1.234+1.234i 0.0+1.0i) -50.0-50.0i)+(num-test (= 123.4 1.234+1.234i 0.0+1.0i) #f)+(num-test (+ 123.4 -1.0+1.0i 1) 123.4+1.0i)+(num-test (- 123.4 -1.0+1.0i 1) 123.4-1.0i)+(num-test (* 123.4 -1.0+1.0i 1) -123.4+123.4i)+(num-test (/ 123.4 -1.0+1.0i 1) -61.7-61.7i)+(num-test (= 123.4 -1.0+1.0i 1) #f)+(num-test (+ 123.4 -1.0+1.0i 1.0) 123.4+1.0i)+(num-test (- 123.4 -1.0+1.0i 1.0) 123.4-1.0i)+(num-test (* 123.4 -1.0+1.0i 1.0) -123.4+123.4i)+(num-test (/ 123.4 -1.0+1.0i 1.0) -61.7-61.7i)+(num-test (= 123.4 -1.0+1.0i 1.0) #f)+(num-test (+ 123.4 -1.0+1.0i 1/1) 123.4+1.0i)+(num-test (- 123.4 -1.0+1.0i 1/1) 123.4-1.0i)+(num-test (* 123.4 -1.0+1.0i 1/1) -123.4+123.4i)+(num-test (/ 123.4 -1.0+1.0i 1/1) -61.7-61.7i)+(num-test (= 123.4 -1.0+1.0i 1/1) #f)+(num-test (+ 123.4 -1.0+1.0i 1.0+1.0i) 123.4+2.0i)+(num-test (- 123.4 -1.0+1.0i 1.0+1.0i) 123.4-2.0i)+(num-test (* 123.4 -1.0+1.0i 1.0+1.0i) -246.8)+(num-test (/ 123.4 -1.0+1.0i 1.0+1.0i) -61.7)+(num-test (= 123.4 -1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 123.4 -1.0+1.0i 0) 122.4+1.0i)+(num-test (- 123.4 -1.0+1.0i 0) 124.4-1.0i)+(num-test (* 123.4 -1.0+1.0i 0) -0.0)+(num-test (+ 123.4 -1.0+1.0i 0.0) 122.4+1.0i)+(num-test (- 123.4 -1.0+1.0i 0.0) 124.4-1.0i)+(num-test (* 123.4 -1.0+1.0i 0.0) -0.0)+(num-test (+ 123.4 -1.0+1.0i 1234) 1356.4+1.0i)+(num-test (- 123.4 -1.0+1.0i 1234) -1109.59999999999991-1.0i)+(num-test (* 123.4 -1.0+1.0i 1234) -152275.60000000000582+152275.60000000000582i)+(num-test (/ 123.4 -1.0+1.0i 1234) -0.05000000000000-0.05000000000000i)+(num-test (= 123.4 -1.0+1.0i 1234) #f)+(num-test (+ 123.4 -1.0+1.0i 123.4) 245.8+1.0i)+(num-test (- 123.4 -1.0+1.0i 123.4) 1.0-1.0i)+(num-test (* 123.4 -1.0+1.0i 123.4) -15227.56000000000131+15227.56000000000131i)+(num-test (/ 123.4 -1.0+1.0i 123.4) -0.5-0.5i)+(num-test (= 123.4 -1.0+1.0i 123.4) #f)+(num-test (+ 123.4 -1.0+1.0i 1234/11) 234.58181818181819+1.0i)+(num-test (- 123.4 -1.0+1.0i 1234/11) 12.21818181818182-1.0i)+(num-test (* 123.4 -1.0+1.0i 1234/11) -13843.23636363636433+13843.23636363636433i)+(num-test (/ 123.4 -1.0+1.0i 1234/11) -0.55000000000000-0.55000000000000i)+(num-test (= 123.4 -1.0+1.0i 1234/11) #f)+(num-test (+ 123.4 -1.0+1.0i 1.234+1.234i) 123.634+2.234i)+(num-test (- 123.4 -1.0+1.0i 1.234+1.234i) 123.16600000000001-2.234i)+(num-test (* 123.4 -1.0+1.0i 1.234+1.234i) -304.55119999999999)+(num-test (/ 123.4 -1.0+1.0i 1.234+1.234i) -50.0)+(num-test (= 123.4 -1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 123.4 -1.0+1.0i -1.0+1.0i) 121.4+2.0i)+(num-test (- 123.4 -1.0+1.0i -1.0+1.0i) 125.4-2.0i)+(num-test (* 123.4 -1.0+1.0i -1.0+1.0i) 0.0-246.8i)+(num-test (/ 123.4 -1.0+1.0i -1.0+1.0i) -0.0+61.7i)+(num-test (= 123.4 -1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 123.4 -1.0+1.0i 0.0+1.0i) 122.4+2.0i)+(num-test (- 123.4 -1.0+1.0i 0.0+1.0i) 124.4-2.0i)+(num-test (* 123.4 -1.0+1.0i 0.0+1.0i) -123.4-123.4i)+(num-test (/ 123.4 -1.0+1.0i 0.0+1.0i) -61.7+61.7i)+(num-test (= 123.4 -1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 123.4 0.0+1.0i 1) 124.4+1.0i)+(num-test (- 123.4 0.0+1.0i 1) 122.4-1.0i)+(num-test (* 123.4 0.0+1.0i 1) 0.0+123.4i)+(num-test (/ 123.4 0.0+1.0i 1) 0.0-123.4i)+(num-test (= 123.4 0.0+1.0i 1) #f)+(num-test (+ 123.4 0.0+1.0i 1.0) 124.4+1.0i)+(num-test (- 123.4 0.0+1.0i 1.0) 122.4-1.0i)+(num-test (* 123.4 0.0+1.0i 1.0) 0.0+123.4i)+(num-test (/ 123.4 0.0+1.0i 1.0) 0.0-123.4i)+(num-test (= 123.4 0.0+1.0i 1.0) #f)+(num-test (+ 123.4 0.0+1.0i 1/1) 124.4+1.0i)+(num-test (- 123.4 0.0+1.0i 1/1) 122.4-1.0i)+(num-test (* 123.4 0.0+1.0i 1/1) 0.0+123.4i)+(num-test (/ 123.4 0.0+1.0i 1/1) 0.0-123.4i)+(num-test (= 123.4 0.0+1.0i 1/1) #f)+(num-test (+ 123.4 0.0+1.0i 1.0+1.0i) 124.4+2.0i)+(num-test (- 123.4 0.0+1.0i 1.0+1.0i) 122.4-2.0i)+(num-test (* 123.4 0.0+1.0i 1.0+1.0i) -123.4+123.4i)+(num-test (/ 123.4 0.0+1.0i 1.0+1.0i) -61.7-61.7i)+(num-test (= 123.4 0.0+1.0i 1.0+1.0i) #f)+(num-test (+ 123.4 0.0+1.0i 0) 123.4+1.0i)+(num-test (- 123.4 0.0+1.0i 0) 123.4-1.0i)+(num-test (* 123.4 0.0+1.0i 0) 0.0)+(num-test (+ 123.4 0.0+1.0i 0.0) 123.4+1.0i)+(num-test (- 123.4 0.0+1.0i 0.0) 123.4-1.0i)+(num-test (* 123.4 0.0+1.0i 0.0) 0.0)+(num-test (+ 123.4 0.0+1.0i 1234) 1357.4+1.0i)+(num-test (- 123.4 0.0+1.0i 1234) -1110.59999999999991-1.0i)+(num-test (* 123.4 0.0+1.0i 1234) 0.0+152275.60000000000582i)+(num-test (/ 123.4 0.0+1.0i 1234) 0.0-0.1i)+(num-test (= 123.4 0.0+1.0i 1234) #f)+(num-test (+ 123.4 0.0+1.0i 123.4) 246.8+1.0i)+(num-test (- 123.4 0.0+1.0i 123.4) 0.0-1.0i)+(num-test (* 123.4 0.0+1.0i 123.4) 0.0+15227.56000000000131i)+(num-test (/ 123.4 0.0+1.0i 123.4) 0.0-1.0i)+(num-test (= 123.4 0.0+1.0i 123.4) #f)+(num-test (+ 123.4 0.0+1.0i 1234/11) 235.58181818181819+1.0i)+(num-test (- 123.4 0.0+1.0i 1234/11) 11.21818181818182-1.0i)+(num-test (* 123.4 0.0+1.0i 1234/11) 0.0+13843.23636363636433i)+(num-test (/ 123.4 0.0+1.0i 1234/11) 0.0-1.10000000000000i)+(num-test (= 123.4 0.0+1.0i 1234/11) #f)+(num-test (+ 123.4 0.0+1.0i 1.234+1.234i) 124.634+2.234i)+(num-test (- 123.4 0.0+1.0i 1.234+1.234i) 122.16600000000001-2.234i)+(num-test (* 123.4 0.0+1.0i 1.234+1.234i) -152.2756+152.2756i)+(num-test (/ 123.4 0.0+1.0i 1.234+1.234i) -50.0-50.0i)+(num-test (= 123.4 0.0+1.0i 1.234+1.234i) #f)+(num-test (+ 123.4 0.0+1.0i -1.0+1.0i) 122.4+2.0i)+(num-test (- 123.4 0.0+1.0i -1.0+1.0i) 124.4-2.0i)+(num-test (* 123.4 0.0+1.0i -1.0+1.0i) -123.4-123.4i)+(num-test (/ 123.4 0.0+1.0i -1.0+1.0i) -61.7+61.7i)+(num-test (= 123.4 0.0+1.0i -1.0+1.0i) #f)+(num-test (+ 123.4 0.0+1.0i 0.0+1.0i) 123.4+2.0i)+(num-test (- 123.4 0.0+1.0i 0.0+1.0i) 123.4-2.0i)+(num-test (* 123.4 0.0+1.0i 0.0+1.0i) -123.4)+(num-test (/ 123.4 0.0+1.0i 0.0+1.0i) -123.4)+(num-test (= 123.4 0.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1234/11 1 1) 1256/11)+(num-test (- 1234/11 1 1) 1212/11)+(num-test (* 1234/11 1 1) 1234/11)+(num-test (/ 1234/11 1 1) 1234/11)+(num-test (= 1234/11 1 1) #f)+(num-test (< 1234/11 1 1) #f)+(num-test (<= 1234/11 1 1) #f)+(num-test (> 1234/11 1 1) #f)+(num-test (>= 1234/11 1 1) #t)+(num-test (+ 1234/11 1 1.0) 114.18181818181819)+(num-test (- 1234/11 1 1.0) 110.18181818181819)+(num-test (* 1234/11 1 1.0) 112.18181818181819)+(num-test (/ 1234/11 1 1.0) 112.18181818181819)+(num-test (= 1234/11 1 1.0) #f)+(num-test (< 1234/11 1 1.0) #f)+(num-test (<= 1234/11 1 1.0) #f)+(num-test (> 1234/11 1 1.0) #f)+(num-test (>= 1234/11 1 1.0) #t)+(num-test (+ 1234/11 1 1/1) 1256/11)+(num-test (- 1234/11 1 1/1) 1212/11)+(num-test (* 1234/11 1 1/1) 1234/11)+(num-test (/ 1234/11 1 1/1) 1234/11)+(num-test (= 1234/11 1 1/1) #f)+(num-test (< 1234/11 1 1/1) #f)+(num-test (<= 1234/11 1 1/1) #f)+(num-test (> 1234/11 1 1/1) #f)+(num-test (>= 1234/11 1 1/1) #t)+(num-test (+ 1234/11 1 1.0+1.0i) 114.18181818181819+1.0i)+(num-test (- 1234/11 1 1.0+1.0i) 110.18181818181819-1.0i)+(num-test (* 1234/11 1 1.0+1.0i) 112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 1 1.0+1.0i) 56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 1 1.0+1.0i) #f)+(num-test (+ 1234/11 1 0) 1245/11)+(num-test (- 1234/11 1 0) 1223/11)+(num-test (* 1234/11 1 0) 0)+(num-test (+ 1234/11 1 0.0) 113.18181818181819)+(num-test (- 1234/11 1 0.0) 111.18181818181819)+(num-test (* 1234/11 1 0.0) 0.0)+(num-test (+ 1234/11 1 1234) 14819/11)+(num-test (- 1234/11 1 1234) -12351/11)+(num-test (* 1234/11 1 1234) 1522756/11)+(num-test (/ 1234/11 1 1234) 1/11)+(num-test (= 1234/11 1 1234) #f)+(num-test (< 1234/11 1 1234) #f)+(num-test (<= 1234/11 1 1234) #f)+(num-test (> 1234/11 1 1234) #f)+(num-test (>= 1234/11 1 1234) #f)+(num-test (+ 1234/11 1 123.4) 236.58181818181819)+(num-test (- 1234/11 1 123.4) -12.21818181818182)+(num-test (* 1234/11 1 123.4) 13843.23636363636433)+(num-test (/ 1234/11 1 123.4) 0.90909090909091)+(num-test (= 1234/11 1 123.4) #f)+(num-test (< 1234/11 1 123.4) #f)+(num-test (<= 1234/11 1 123.4) #f)+(num-test (> 1234/11 1 123.4) #f)+(num-test (>= 1234/11 1 123.4) #f)+(num-test (+ 1234/11 1 1234/11) 2479/11)+(num-test (- 1234/11 1 1234/11) -1)+(num-test (* 1234/11 1 1234/11) 1522756/121)+(num-test (/ 1234/11 1 1234/11) 1)+(num-test (= 1234/11 1 1234/11) #f)+(num-test (< 1234/11 1 1234/11) #f)+(num-test (<= 1234/11 1 1234/11) #f)+(num-test (> 1234/11 1 1234/11) #f)+(num-test (>= 1234/11 1 1234/11) #f)+(num-test (+ 1234/11 1 1.234+1.234i) 114.41581818181818+1.234i)+(num-test (- 1234/11 1 1.234+1.234i) 109.94781818181819-1.234i)+(num-test (* 1234/11 1 1.234+1.234i) 138.43236363636365+138.43236363636365i)+(num-test (/ 1234/11 1 1.234+1.234i) 45.45454545454546-45.45454545454546i)+(num-test (= 1234/11 1 1.234+1.234i) #f)+(num-test (+ 1234/11 1 -1.0+1.0i) 112.18181818181819+1.0i)+(num-test (- 1234/11 1 -1.0+1.0i) 112.18181818181819-1.0i)+(num-test (* 1234/11 1 -1.0+1.0i) -112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 1 -1.0+1.0i) -56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 1 -1.0+1.0i) #f)+(num-test (+ 1234/11 1 0.0+1.0i) 113.18181818181819+1.0i)+(num-test (- 1234/11 1 0.0+1.0i) 111.18181818181819-1.0i)+(num-test (* 1234/11 1 0.0+1.0i) 0.0+112.18181818181819i)+(num-test (/ 1234/11 1 0.0+1.0i) 0.0-112.18181818181819i)+(num-test (= 1234/11 1 0.0+1.0i) #f)+(num-test (+ 1234/11 1.0 1) 114.18181818181819)+(num-test (- 1234/11 1.0 1) 110.18181818181819)+(num-test (* 1234/11 1.0 1) 112.18181818181819)+(num-test (/ 1234/11 1.0 1) 112.18181818181819)+(num-test (= 1234/11 1.0 1) #f)+(num-test (< 1234/11 1.0 1) #f)+(num-test (<= 1234/11 1.0 1) #f)+(num-test (> 1234/11 1.0 1) #f)+(num-test (>= 1234/11 1.0 1) #t)+(num-test (+ 1234/11 1.0 1.0) 114.18181818181819)+(num-test (- 1234/11 1.0 1.0) 110.18181818181819)+(num-test (* 1234/11 1.0 1.0) 112.18181818181819)+(num-test (/ 1234/11 1.0 1.0) 112.18181818181819)+(num-test (= 1234/11 1.0 1.0) #f)+(num-test (< 1234/11 1.0 1.0) #f)+(num-test (<= 1234/11 1.0 1.0) #f)+(num-test (> 1234/11 1.0 1.0) #f)+(num-test (>= 1234/11 1.0 1.0) #t)+(num-test (+ 1234/11 1.0 1/1) 114.18181818181819)+(num-test (- 1234/11 1.0 1/1) 110.18181818181819)+(num-test (* 1234/11 1.0 1/1) 112.18181818181819)+(num-test (/ 1234/11 1.0 1/1) 112.18181818181819)+(num-test (= 1234/11 1.0 1/1) #f)+(num-test (< 1234/11 1.0 1/1) #f)+(num-test (<= 1234/11 1.0 1/1) #f)+(num-test (> 1234/11 1.0 1/1) #f)+(num-test (>= 1234/11 1.0 1/1) #t)+(num-test (+ 1234/11 1.0 1.0+1.0i) 114.18181818181819+1.0i)+(num-test (- 1234/11 1.0 1.0+1.0i) 110.18181818181819-1.0i)+(num-test (* 1234/11 1.0 1.0+1.0i) 112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 1.0 1.0+1.0i) 56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 1.0 1.0+1.0i) #f)+(num-test (+ 1234/11 1.0 0) 113.18181818181819)+(num-test (- 1234/11 1.0 0) 111.18181818181819)+(num-test (* 1234/11 1.0 0) 0.0)+(num-test (+ 1234/11 1.0 0.0) 113.18181818181819)+(num-test (- 1234/11 1.0 0.0) 111.18181818181819)+(num-test (* 1234/11 1.0 0.0) 0.0)+(num-test (+ 1234/11 1.0 1234) 1347.18181818181824)+(num-test (- 1234/11 1.0 1234) -1122.81818181818176)+(num-test (* 1234/11 1.0 1234) 138432.36363636364695)+(num-test (/ 1234/11 1.0 1234) 0.09090909090909)+(num-test (= 1234/11 1.0 1234) #f)+(num-test (< 1234/11 1.0 1234) #f)+(num-test (<= 1234/11 1.0 1234) #f)+(num-test (> 1234/11 1.0 1234) #f)+(num-test (>= 1234/11 1.0 1234) #f)+(num-test (+ 1234/11 1.0 123.4) 236.58181818181819)+(num-test (- 1234/11 1.0 123.4) -12.21818181818182)+(num-test (* 1234/11 1.0 123.4) 13843.23636363636433)+(num-test (/ 1234/11 1.0 123.4) 0.90909090909091)+(num-test (= 1234/11 1.0 123.4) #f)+(num-test (< 1234/11 1.0 123.4) #f)+(num-test (<= 1234/11 1.0 123.4) #f)+(num-test (> 1234/11 1.0 123.4) #f)+(num-test (>= 1234/11 1.0 123.4) #f)+(num-test (+ 1234/11 1.0 1234/11) 225.36363636363637)+(num-test (- 1234/11 1.0 1234/11) -1.0)+(num-test (* 1234/11 1.0 1234/11) 12584.76033057851237)+(num-test (/ 1234/11 1.0 1234/11) 1.0)+(num-test (= 1234/11 1.0 1234/11) #f)+(num-test (< 1234/11 1.0 1234/11) #f)+(num-test (<= 1234/11 1.0 1234/11) #f)+(num-test (> 1234/11 1.0 1234/11) #f)+(num-test (>= 1234/11 1.0 1234/11) #f)+(num-test (+ 1234/11 1.0 1.234+1.234i) 114.41581818181818+1.234i)+(num-test (- 1234/11 1.0 1.234+1.234i) 109.94781818181819-1.234i)+(num-test (* 1234/11 1.0 1.234+1.234i) 138.43236363636365+138.43236363636365i)+(num-test (/ 1234/11 1.0 1.234+1.234i) 45.45454545454546-45.45454545454546i)+(num-test (= 1234/11 1.0 1.234+1.234i) #f)+(num-test (+ 1234/11 1.0 -1.0+1.0i) 112.18181818181819+1.0i)+(num-test (- 1234/11 1.0 -1.0+1.0i) 112.18181818181819-1.0i)+(num-test (* 1234/11 1.0 -1.0+1.0i) -112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 1.0 -1.0+1.0i) -56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 1.0 -1.0+1.0i) #f)+(num-test (+ 1234/11 1.0 0.0+1.0i) 113.18181818181819+1.0i)+(num-test (- 1234/11 1.0 0.0+1.0i) 111.18181818181819-1.0i)+(num-test (* 1234/11 1.0 0.0+1.0i) 0.0+112.18181818181819i)+(num-test (/ 1234/11 1.0 0.0+1.0i) 0.0-112.18181818181819i)+(num-test (= 1234/11 1.0 0.0+1.0i) #f)+(num-test (+ 1234/11 1/1 1) 1256/11)+(num-test (- 1234/11 1/1 1) 1212/11)+(num-test (* 1234/11 1/1 1) 1234/11)+(num-test (/ 1234/11 1/1 1) 1234/11)+(num-test (= 1234/11 1/1 1) #f)+(num-test (< 1234/11 1/1 1) #f)+(num-test (<= 1234/11 1/1 1) #f)+(num-test (> 1234/11 1/1 1) #f)+(num-test (>= 1234/11 1/1 1) #t)+(num-test (+ 1234/11 1/1 1.0) 114.18181818181819)+(num-test (- 1234/11 1/1 1.0) 110.18181818181819)+(num-test (* 1234/11 1/1 1.0) 112.18181818181819)+(num-test (/ 1234/11 1/1 1.0) 112.18181818181819)+(num-test (= 1234/11 1/1 1.0) #f)+(num-test (< 1234/11 1/1 1.0) #f)+(num-test (<= 1234/11 1/1 1.0) #f)+(num-test (> 1234/11 1/1 1.0) #f)+(num-test (>= 1234/11 1/1 1.0) #t)+(num-test (+ 1234/11 1/1 1/1) 1256/11)+(num-test (- 1234/11 1/1 1/1) 1212/11)+(num-test (* 1234/11 1/1 1/1) 1234/11)+(num-test (/ 1234/11 1/1 1/1) 1234/11)+(num-test (= 1234/11 1/1 1/1) #f)+(num-test (< 1234/11 1/1 1/1) #f)+(num-test (<= 1234/11 1/1 1/1) #f)+(num-test (> 1234/11 1/1 1/1) #f)+(num-test (>= 1234/11 1/1 1/1) #t)+(num-test (+ 1234/11 1/1 1.0+1.0i) 114.18181818181819+1.0i)+(num-test (- 1234/11 1/1 1.0+1.0i) 110.18181818181819-1.0i)+(num-test (* 1234/11 1/1 1.0+1.0i) 112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 1/1 1.0+1.0i) 56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 1/1 1.0+1.0i) #f)+(num-test (+ 1234/11 1/1 0) 1245/11)+(num-test (- 1234/11 1/1 0) 1223/11)+(num-test (* 1234/11 1/1 0) 0)+(num-test (+ 1234/11 1/1 0.0) 113.18181818181819)+(num-test (- 1234/11 1/1 0.0) 111.18181818181819)+(num-test (* 1234/11 1/1 0.0) 0.0)+(num-test (+ 1234/11 1/1 1234) 14819/11)+(num-test (- 1234/11 1/1 1234) -12351/11)+(num-test (* 1234/11 1/1 1234) 1522756/11)+(num-test (/ 1234/11 1/1 1234) 1/11)+(num-test (= 1234/11 1/1 1234) #f)+(num-test (< 1234/11 1/1 1234) #f)+(num-test (<= 1234/11 1/1 1234) #f)+(num-test (> 1234/11 1/1 1234) #f)+(num-test (>= 1234/11 1/1 1234) #f)+(num-test (+ 1234/11 1/1 123.4) 236.58181818181819)+(num-test (- 1234/11 1/1 123.4) -12.21818181818182)+(num-test (* 1234/11 1/1 123.4) 13843.23636363636433)+(num-test (/ 1234/11 1/1 123.4) 0.90909090909091)+(num-test (= 1234/11 1/1 123.4) #f)+(num-test (< 1234/11 1/1 123.4) #f)+(num-test (<= 1234/11 1/1 123.4) #f)+(num-test (> 1234/11 1/1 123.4) #f)+(num-test (>= 1234/11 1/1 123.4) #f)+(num-test (+ 1234/11 1/1 1234/11) 2479/11)+(num-test (- 1234/11 1/1 1234/11) -1)+(num-test (* 1234/11 1/1 1234/11) 1522756/121)+(num-test (/ 1234/11 1/1 1234/11) 1)+(num-test (= 1234/11 1/1 1234/11) #f)+(num-test (< 1234/11 1/1 1234/11) #f)+(num-test (<= 1234/11 1/1 1234/11) #f)+(num-test (> 1234/11 1/1 1234/11) #f)+(num-test (>= 1234/11 1/1 1234/11) #f)+(num-test (+ 1234/11 1/1 1.234+1.234i) 114.41581818181818+1.234i)+(num-test (- 1234/11 1/1 1.234+1.234i) 109.94781818181819-1.234i)+(num-test (* 1234/11 1/1 1.234+1.234i) 138.43236363636365+138.43236363636365i)+(num-test (/ 1234/11 1/1 1.234+1.234i) 45.45454545454546-45.45454545454546i)+(num-test (= 1234/11 1/1 1.234+1.234i) #f)+(num-test (+ 1234/11 1/1 -1.0+1.0i) 112.18181818181819+1.0i)+(num-test (- 1234/11 1/1 -1.0+1.0i) 112.18181818181819-1.0i)+(num-test (* 1234/11 1/1 -1.0+1.0i) -112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 1/1 -1.0+1.0i) -56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 1/1 -1.0+1.0i) #f)+(num-test (+ 1234/11 1/1 0.0+1.0i) 113.18181818181819+1.0i)+(num-test (- 1234/11 1/1 0.0+1.0i) 111.18181818181819-1.0i)+(num-test (* 1234/11 1/1 0.0+1.0i) 0.0+112.18181818181819i)+(num-test (/ 1234/11 1/1 0.0+1.0i) 0.0-112.18181818181819i)+(num-test (= 1234/11 1/1 0.0+1.0i) #f)+(num-test (+ 1234/11 1.0+1.0i 1) 114.18181818181819+1.0i)+(num-test (- 1234/11 1.0+1.0i 1) 110.18181818181819-1.0i)+(num-test (* 1234/11 1.0+1.0i 1) 112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 1.0+1.0i 1) 56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 1.0+1.0i 1) #f)+(num-test (+ 1234/11 1.0+1.0i 1.0) 114.18181818181819+1.0i)+(num-test (- 1234/11 1.0+1.0i 1.0) 110.18181818181819-1.0i)+(num-test (* 1234/11 1.0+1.0i 1.0) 112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 1.0+1.0i 1.0) 56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 1.0+1.0i 1.0) #f)+(num-test (+ 1234/11 1.0+1.0i 1/1) 114.18181818181819+1.0i)+(num-test (- 1234/11 1.0+1.0i 1/1) 110.18181818181819-1.0i)+(num-test (* 1234/11 1.0+1.0i 1/1) 112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 1.0+1.0i 1/1) 56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 1.0+1.0i 1/1) #f)+(num-test (+ 1234/11 1.0+1.0i 1.0+1.0i) 114.18181818181819+2.0i)+(num-test (- 1234/11 1.0+1.0i 1.0+1.0i) 110.18181818181819-2.0i)+(num-test (* 1234/11 1.0+1.0i 1.0+1.0i) 0.0+224.36363636363637i)+(num-test (/ 1234/11 1.0+1.0i 1.0+1.0i) 0.0-56.09090909090909i)+(num-test (= 1234/11 1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1234/11 1.0+1.0i 0) 113.18181818181819+1.0i)+(num-test (- 1234/11 1.0+1.0i 0) 111.18181818181819-1.0i)+(num-test (* 1234/11 1.0+1.0i 0) 0.0)+(num-test (+ 1234/11 1.0+1.0i 0.0) 113.18181818181819+1.0i)+(num-test (- 1234/11 1.0+1.0i 0.0) 111.18181818181819-1.0i)+(num-test (* 1234/11 1.0+1.0i 0.0) 0.0)+(num-test (+ 1234/11 1.0+1.0i 1234) 1347.18181818181824+1.0i)+(num-test (- 1234/11 1.0+1.0i 1234) -1122.81818181818176-1.0i)+(num-test (* 1234/11 1.0+1.0i 1234) 138432.36363636364695+138432.36363636364695i)+(num-test (/ 1234/11 1.0+1.0i 1234) 0.04545454545455-0.04545454545455i)+(num-test (= 1234/11 1.0+1.0i 1234) #f)+(num-test (+ 1234/11 1.0+1.0i 123.4) 236.58181818181819+1.0i)+(num-test (- 1234/11 1.0+1.0i 123.4) -12.21818181818182-1.0i)+(num-test (* 1234/11 1.0+1.0i 123.4) 13843.23636363636433+13843.23636363636433i)+(num-test (/ 1234/11 1.0+1.0i 123.4) 0.45454545454545-0.45454545454545i)+(num-test (= 1234/11 1.0+1.0i 123.4) #f)+(num-test (+ 1234/11 1.0+1.0i 1234/11) 225.36363636363637+1.0i)+(num-test (- 1234/11 1.0+1.0i 1234/11) -1.0-1.0i)+(num-test (* 1234/11 1.0+1.0i 1234/11) 12584.76033057851419+12584.76033057851419i)+(num-test (/ 1234/11 1.0+1.0i 1234/11) 0.5-0.5i)+(num-test (= 1234/11 1.0+1.0i 1234/11) #f)+(num-test (+ 1234/11 1.0+1.0i 1.234+1.234i) 114.41581818181818+2.234i)+(num-test (- 1234/11 1.0+1.0i 1.234+1.234i) 109.94781818181819-2.234i)+(num-test (* 1234/11 1.0+1.0i 1.234+1.234i) 0.0+276.86472727272729i)+(num-test (/ 1234/11 1.0+1.0i 1.234+1.234i) 0.0-45.45454545454546i)+(num-test (= 1234/11 1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1234/11 1.0+1.0i -1.0+1.0i) 112.18181818181819+2.0i)+(num-test (- 1234/11 1.0+1.0i -1.0+1.0i) 112.18181818181819-2.0i)+(num-test (* 1234/11 1.0+1.0i -1.0+1.0i) -224.36363636363637)+(num-test (/ 1234/11 1.0+1.0i -1.0+1.0i) -56.09090909090909)+(num-test (= 1234/11 1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1234/11 1.0+1.0i 0.0+1.0i) 113.18181818181819+2.0i)+(num-test (- 1234/11 1.0+1.0i 0.0+1.0i) 111.18181818181819-2.0i)+(num-test (* 1234/11 1.0+1.0i 0.0+1.0i) -112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 1.0+1.0i 0.0+1.0i) -56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1234/11 0 1) 1245/11)+(num-test (- 1234/11 0 1) 1223/11)+(num-test (* 1234/11 0 1) 0)+(num-test (+ 1234/11 0 1.0) 113.18181818181819)+(num-test (- 1234/11 0 1.0) 111.18181818181819)+(num-test (* 1234/11 0 1.0) 0.0)+(num-test (+ 1234/11 0 1/1) 1245/11)+(num-test (- 1234/11 0 1/1) 1223/11)+(num-test (* 1234/11 0 1/1) 0)+(num-test (+ 1234/11 0 1.0+1.0i) 113.18181818181819+1.0i)+(num-test (- 1234/11 0 1.0+1.0i) 111.18181818181819-1.0i)+(num-test (* 1234/11 0 1.0+1.0i) 0.0)+(num-test (+ 1234/11 0 0) 1234/11)+(num-test (- 1234/11 0 0) 1234/11)+(num-test (* 1234/11 0 0) 0)+(num-test (+ 1234/11 0 0.0) 112.18181818181819)+(num-test (- 1234/11 0 0.0) 112.18181818181819)+(num-test (* 1234/11 0 0.0) 0.0)+(num-test (+ 1234/11 0 1234) 14808/11)+(num-test (- 1234/11 0 1234) -12340/11)+(num-test (* 1234/11 0 1234) 0)+(num-test (+ 1234/11 0 123.4) 235.58181818181819)+(num-test (- 1234/11 0 123.4) -11.21818181818182)+(num-test (* 1234/11 0 123.4) 0.0)+(num-test (+ 1234/11 0 1234/11) 2468/11)+(num-test (- 1234/11 0 1234/11) 0)+(num-test (* 1234/11 0 1234/11) 0)+(num-test (+ 1234/11 0 1.234+1.234i) 113.41581818181818+1.234i)+(num-test (- 1234/11 0 1.234+1.234i) 110.94781818181819-1.234i)+(num-test (* 1234/11 0 1.234+1.234i) 0.0)+(num-test (+ 1234/11 0 -1.0+1.0i) 111.18181818181819+1.0i)+(num-test (- 1234/11 0 -1.0+1.0i) 113.18181818181819-1.0i)+(num-test (* 1234/11 0 -1.0+1.0i) -0.0)+(num-test (+ 1234/11 0 0.0+1.0i) 112.18181818181819+1.0i)+(num-test (- 1234/11 0 0.0+1.0i) 112.18181818181819-1.0i)+(num-test (* 1234/11 0 0.0+1.0i) 0.0)+(num-test (+ 1234/11 0.0 1) 113.18181818181819)+(num-test (- 1234/11 0.0 1) 111.18181818181819)+(num-test (* 1234/11 0.0 1) 0.0)+(num-test (+ 1234/11 0.0 1.0) 113.18181818181819)+(num-test (- 1234/11 0.0 1.0) 111.18181818181819)+(num-test (* 1234/11 0.0 1.0) 0.0)+(num-test (+ 1234/11 0.0 1/1) 113.18181818181819)+(num-test (- 1234/11 0.0 1/1) 111.18181818181819)+(num-test (* 1234/11 0.0 1/1) 0.0)+(num-test (+ 1234/11 0.0 1.0+1.0i) 113.18181818181819+1.0i)+(num-test (- 1234/11 0.0 1.0+1.0i) 111.18181818181819-1.0i)+(num-test (* 1234/11 0.0 1.0+1.0i) 0.0)+(num-test (+ 1234/11 0.0 0) 112.18181818181819)+(num-test (- 1234/11 0.0 0) 112.18181818181819)+(num-test (* 1234/11 0.0 0) 0.0)+(num-test (+ 1234/11 0.0 0.0) 112.18181818181819)+(num-test (- 1234/11 0.0 0.0) 112.18181818181819)+(num-test (* 1234/11 0.0 0.0) 0.0)+(num-test (+ 1234/11 0.0 1234) 1346.18181818181824)+(num-test (- 1234/11 0.0 1234) -1121.81818181818176)+(num-test (* 1234/11 0.0 1234) 0.0)+(num-test (+ 1234/11 0.0 123.4) 235.58181818181819)+(num-test (- 1234/11 0.0 123.4) -11.21818181818182)+(num-test (* 1234/11 0.0 123.4) 0.0)+(num-test (+ 1234/11 0.0 1234/11) 224.36363636363637)+(num-test (- 1234/11 0.0 1234/11) 0.00000000000001)+(num-test (* 1234/11 0.0 1234/11) 0.0)+(num-test (+ 1234/11 0.0 1.234+1.234i) 113.41581818181818+1.234i)+(num-test (- 1234/11 0.0 1.234+1.234i) 110.94781818181819-1.234i)+(num-test (* 1234/11 0.0 1.234+1.234i) 0.0)+(num-test (+ 1234/11 0.0 -1.0+1.0i) 111.18181818181819+1.0i)+(num-test (- 1234/11 0.0 -1.0+1.0i) 113.18181818181819-1.0i)+(num-test (* 1234/11 0.0 -1.0+1.0i) -0.0)+(num-test (+ 1234/11 0.0 0.0+1.0i) 112.18181818181819+1.0i)+(num-test (- 1234/11 0.0 0.0+1.0i) 112.18181818181819-1.0i)+(num-test (* 1234/11 0.0 0.0+1.0i) 0.0)+(num-test (+ 1234/11 1234 1) 14819/11)+(num-test (- 1234/11 1234 1) -12351/11)+(num-test (* 1234/11 1234 1) 1522756/11)+(num-test (/ 1234/11 1234 1) 1/11)+(num-test (= 1234/11 1234 1) #f)+(num-test (< 1234/11 1234 1) #f)+(num-test (<= 1234/11 1234 1) #f)+(num-test (> 1234/11 1234 1) #f)+(num-test (>= 1234/11 1234 1) #f)+(num-test (+ 1234/11 1234 1.0) 1347.18181818181824)+(num-test (- 1234/11 1234 1.0) -1122.81818181818176)+(num-test (* 1234/11 1234 1.0) 138432.36363636364695)+(num-test (/ 1234/11 1234 1.0) 0.09090909090909)+(num-test (= 1234/11 1234 1.0) #f)+(num-test (< 1234/11 1234 1.0) #f)+(num-test (<= 1234/11 1234 1.0) #f)+(num-test (> 1234/11 1234 1.0) #f)+(num-test (>= 1234/11 1234 1.0) #f)+(num-test (+ 1234/11 1234 1/1) 14819/11)+(num-test (- 1234/11 1234 1/1) -12351/11)+(num-test (* 1234/11 1234 1/1) 1522756/11)+(num-test (/ 1234/11 1234 1/1) 1/11)+(num-test (= 1234/11 1234 1/1) #f)+(num-test (< 1234/11 1234 1/1) #f)+(num-test (<= 1234/11 1234 1/1) #f)+(num-test (> 1234/11 1234 1/1) #f)+(num-test (>= 1234/11 1234 1/1) #f)+(num-test (+ 1234/11 1234 1.0+1.0i) 1347.18181818181824+1.0i)+(num-test (- 1234/11 1234 1.0+1.0i) -1122.81818181818176-1.0i)+(num-test (* 1234/11 1234 1.0+1.0i) 138432.36363636364695+138432.36363636364695i)+(num-test (/ 1234/11 1234 1.0+1.0i) 0.04545454545455-0.04545454545455i)+(num-test (= 1234/11 1234 1.0+1.0i) #f)+(num-test (+ 1234/11 1234 0) 14808/11)+(num-test (- 1234/11 1234 0) -12340/11)+(num-test (* 1234/11 1234 0) 0)+(num-test (+ 1234/11 1234 0.0) 1346.18181818181824)+(num-test (- 1234/11 1234 0.0) -1121.81818181818176)+(num-test (* 1234/11 1234 0.0) 0.0)+(num-test (+ 1234/11 1234 1234) 28382/11)+(num-test (- 1234/11 1234 1234) -25914/11)+(if (not with-64-bit-ints)+    (num-test (* 1234/11 1234 1234) 170825536.727273)+    (num-test (* 1234/11 1234 1234) 1879080904/11))+(num-test (/ 1234/11 1234 1234) 1/13574)+(num-test (= 1234/11 1234 1234) #f)+(num-test (< 1234/11 1234 1234) #f)+(num-test (<= 1234/11 1234 1234) #t)+(num-test (> 1234/11 1234 1234) #f)+(num-test (>= 1234/11 1234 1234) #f)+(num-test (+ 1234/11 1234 123.4) 1469.58181818181833)+(num-test (- 1234/11 1234 123.4) -1245.21818181818185)+(num-test (* 1234/11 1234 123.4) 17082553.67272727563977)+(num-test (/ 1234/11 1234 123.4) 0.00073670251952)+(num-test (= 1234/11 1234 123.4) #f)+(num-test (< 1234/11 1234 123.4) #f)+(num-test (<= 1234/11 1234 123.4) #f)+(num-test (> 1234/11 1234 123.4) #f)+(num-test (>= 1234/11 1234 123.4) #f)+(num-test (+ 1234/11 1234 1234/11) 16042/11)+(num-test (- 1234/11 1234 1234/11) -1234)+(if (not with-64-bit-ints)+    (num-test (* 1234/11 1234 1234/11) 15529594.2479339)+    (num-test (* 1234/11 1234 1234/11) 1879080904/121))+(num-test (/ 1234/11 1234 1234/11) 1/1234)+(num-test (= 1234/11 1234 1234/11) #f)+(num-test (< 1234/11 1234 1234/11) #f)+(num-test (<= 1234/11 1234 1234/11) #f)+(num-test (> 1234/11 1234 1234/11) #f)+(num-test (>= 1234/11 1234 1234/11) #f)+(num-test (+ 1234/11 1234 1.234+1.234i) 1347.41581818181817+1.234i)+(num-test (- 1234/11 1234 1.234+1.234i) -1123.05218181818168-1.234i)+(num-test (* 1234/11 1234 1.234+1.234i) 170825.53672727273079+170825.53672727273079i)+(num-test (/ 1234/11 1234 1.234+1.234i) 0.03683512597613-0.03683512597613i)+(num-test (= 1234/11 1234 1.234+1.234i) #f)+(num-test (+ 1234/11 1234 -1.0+1.0i) 1345.18181818181824+1.0i)+(num-test (- 1234/11 1234 -1.0+1.0i) -1120.81818181818176-1.0i)+(num-test (* 1234/11 1234 -1.0+1.0i) -138432.36363636364695+138432.36363636364695i)+(num-test (/ 1234/11 1234 -1.0+1.0i) -0.04545454545455-0.04545454545455i)+(num-test (= 1234/11 1234 -1.0+1.0i) #f)+(num-test (+ 1234/11 1234 0.0+1.0i) 1346.18181818181824+1.0i)+(num-test (- 1234/11 1234 0.0+1.0i) -1121.81818181818176-1.0i)+(num-test (* 1234/11 1234 0.0+1.0i) 0.0+138432.36363636364695i)+(num-test (/ 1234/11 1234 0.0+1.0i) 0.0-0.09090909090909i)+(num-test (= 1234/11 1234 0.0+1.0i) #f)+(num-test (+ 1234/11 123.4 1) 236.58181818181819)+(num-test (- 1234/11 123.4 1) -12.21818181818182)+(num-test (* 1234/11 123.4 1) 13843.23636363636433)+(num-test (/ 1234/11 123.4 1) 0.90909090909091)+(num-test (= 1234/11 123.4 1) #f)+(num-test (< 1234/11 123.4 1) #f)+(num-test (<= 1234/11 123.4 1) #f)+(num-test (> 1234/11 123.4 1) #f)+(num-test (>= 1234/11 123.4 1) #f)+(num-test (+ 1234/11 123.4 1.0) 236.58181818181819)+(num-test (- 1234/11 123.4 1.0) -12.21818181818182)+(num-test (* 1234/11 123.4 1.0) 13843.23636363636433)+(num-test (/ 1234/11 123.4 1.0) 0.90909090909091)+(num-test (= 1234/11 123.4 1.0) #f)+(num-test (< 1234/11 123.4 1.0) #f)+(num-test (<= 1234/11 123.4 1.0) #f)+(num-test (> 1234/11 123.4 1.0) #f)+(num-test (>= 1234/11 123.4 1.0) #f)+(num-test (+ 1234/11 123.4 1/1) 236.58181818181819)+(num-test (- 1234/11 123.4 1/1) -12.21818181818182)+(num-test (* 1234/11 123.4 1/1) 13843.23636363636433)+(num-test (/ 1234/11 123.4 1/1) 0.90909090909091)+(num-test (= 1234/11 123.4 1/1) #f)+(num-test (< 1234/11 123.4 1/1) #f)+(num-test (<= 1234/11 123.4 1/1) #f)+(num-test (> 1234/11 123.4 1/1) #f)+(num-test (>= 1234/11 123.4 1/1) #f)+(num-test (+ 1234/11 123.4 1.0+1.0i) 236.58181818181819+1.0i)+(num-test (- 1234/11 123.4 1.0+1.0i) -12.21818181818182-1.0i)+(num-test (* 1234/11 123.4 1.0+1.0i) 13843.23636363636433+13843.23636363636433i)+(num-test (/ 1234/11 123.4 1.0+1.0i) 0.45454545454545-0.45454545454545i)+(num-test (= 1234/11 123.4 1.0+1.0i) #f)+(num-test (+ 1234/11 123.4 0) 235.58181818181819)+(num-test (- 1234/11 123.4 0) -11.21818181818182)+(num-test (* 1234/11 123.4 0) 0.0)+(num-test (+ 1234/11 123.4 0.0) 235.58181818181819)+(num-test (- 1234/11 123.4 0.0) -11.21818181818182)+(num-test (* 1234/11 123.4 0.0) 0.0)+(num-test (+ 1234/11 123.4 1234) 1469.58181818181811)+(num-test (- 1234/11 123.4 1234) -1245.21818181818185)+(num-test (* 1234/11 123.4 1234) 17082553.67272727191448)+(num-test (/ 1234/11 123.4 1234) 0.00073670251952)+(num-test (= 1234/11 123.4 1234) #f)+(num-test (< 1234/11 123.4 1234) #t)+(num-test (<= 1234/11 123.4 1234) #t)+(num-test (> 1234/11 123.4 1234) #f)+(num-test (>= 1234/11 123.4 1234) #f)+(num-test (+ 1234/11 123.4 123.4) 358.98181818181820)+(num-test (- 1234/11 123.4 123.4) -134.61818181818182)+(num-test (* 1234/11 123.4 123.4) 1708255.36727272742428)+(num-test (/ 1234/11 123.4 123.4) 0.00736702519523)+(num-test (= 1234/11 123.4 123.4) #f)+(num-test (< 1234/11 123.4 123.4) #f)+(num-test (<= 1234/11 123.4 123.4) #t)+(num-test (> 1234/11 123.4 123.4) #f)+(num-test (>= 1234/11 123.4 123.4) #f)+(num-test (+ 1234/11 123.4 1234/11) 347.76363636363635)+(num-test (- 1234/11 123.4 1234/11) -123.4)+(num-test (* 1234/11 123.4 1234/11) 1552959.42479338846169)+(num-test (/ 1234/11 123.4 1234/11) 0.00810372771475)+(num-test (= 1234/11 123.4 1234/11) #f)+(num-test (< 1234/11 123.4 1234/11) #f)+(num-test (<= 1234/11 123.4 1234/11) #f)+(num-test (> 1234/11 123.4 1234/11) #f)+(num-test (>= 1234/11 123.4 1234/11) #f)+(num-test (+ 1234/11 123.4 1.234+1.234i) 236.81581818181820+1.234i)+(num-test (- 1234/11 123.4 1.234+1.234i) -12.45218181818182-1.234i)+(num-test (* 1234/11 123.4 1.234+1.234i) 17082.55367272727381+17082.55367272727381i)+(num-test (/ 1234/11 123.4 1.234+1.234i) 0.36835125976131-0.36835125976131i)+(num-test (= 1234/11 123.4 1.234+1.234i) #f)+(num-test (+ 1234/11 123.4 -1.0+1.0i) 234.58181818181819+1.0i)+(num-test (- 1234/11 123.4 -1.0+1.0i) -10.21818181818182-1.0i)+(num-test (* 1234/11 123.4 -1.0+1.0i) -13843.23636363636433+13843.23636363636433i)+(num-test (/ 1234/11 123.4 -1.0+1.0i) -0.45454545454545-0.45454545454545i)+(num-test (= 1234/11 123.4 -1.0+1.0i) #f)+(num-test (+ 1234/11 123.4 0.0+1.0i) 235.58181818181819+1.0i)+(num-test (- 1234/11 123.4 0.0+1.0i) -11.21818181818182-1.0i)+(num-test (* 1234/11 123.4 0.0+1.0i) 0.0+13843.23636363636433i)+(num-test (/ 1234/11 123.4 0.0+1.0i) 0.0-0.90909090909091i)+(num-test (= 1234/11 123.4 0.0+1.0i) #f)+(num-test (+ 1234/11 1234/11 1) 2479/11)+(num-test (- 1234/11 1234/11 1) -1)+(num-test (* 1234/11 1234/11 1) 1522756/121)+(num-test (/ 1234/11 1234/11 1) 1)+(num-test (= 1234/11 1234/11 1) #f)+(num-test (< 1234/11 1234/11 1) #f)+(num-test (<= 1234/11 1234/11 1) #f)+(num-test (> 1234/11 1234/11 1) #f)+(num-test (>= 1234/11 1234/11 1) #t)+(num-test (+ 1234/11 1234/11 1.0) 225.36363636363637)+(num-test (- 1234/11 1234/11 1.0) -1.0)+(num-test (* 1234/11 1234/11 1.0) 12584.76033057851237)+(num-test (/ 1234/11 1234/11 1.0) 1.0)+(num-test (= 1234/11 1234/11 1.0) #f)+(num-test (< 1234/11 1234/11 1.0) #f)+(num-test (<= 1234/11 1234/11 1.0) #f)+(num-test (> 1234/11 1234/11 1.0) #f)+(num-test (>= 1234/11 1234/11 1.0) #t)+(num-test (+ 1234/11 1234/11 1/1) 2479/11)+(num-test (- 1234/11 1234/11 1/1) -1)+(num-test (* 1234/11 1234/11 1/1) 1522756/121)+(num-test (/ 1234/11 1234/11 1/1) 1)+(num-test (= 1234/11 1234/11 1/1) #f)+(num-test (< 1234/11 1234/11 1/1) #f)+(num-test (<= 1234/11 1234/11 1/1) #f)+(num-test (> 1234/11 1234/11 1/1) #f)+(num-test (>= 1234/11 1234/11 1/1) #t)+(num-test (+ 1234/11 1234/11 1.0+1.0i) 225.36363636363637+1.0i)+(num-test (- 1234/11 1234/11 1.0+1.0i) -1.0-1.0i)+(num-test (* 1234/11 1234/11 1.0+1.0i) 12584.76033057851419+12584.76033057851419i)+(num-test (/ 1234/11 1234/11 1.0+1.0i) 0.5-0.5i)+(num-test (= 1234/11 1234/11 1.0+1.0i) #f)+(num-test (+ 1234/11 1234/11 0) 2468/11)+(num-test (- 1234/11 1234/11 0) 0)+(num-test (* 1234/11 1234/11 0) 0)+(num-test (+ 1234/11 1234/11 0.0) 224.36363636363637)+(num-test (- 1234/11 1234/11 0.0) 0.0)+(num-test (* 1234/11 1234/11 0.0) 0.0)+(num-test (+ 1234/11 1234/11 1234) 16042/11)+(num-test (- 1234/11 1234/11 1234) -1234)+(if (not with-64-bit-ints)+    (num-test (* 1234/11 1234/11 1234) 15529594.2479339)+    (num-test (* 1234/11 1234/11 1234) 1879080904/121))+(num-test (/ 1234/11 1234/11 1234) 1/1234)+(num-test (= 1234/11 1234/11 1234) #f)+(num-test (< 1234/11 1234/11 1234) #f)+(num-test (<= 1234/11 1234/11 1234) #t)+(num-test (> 1234/11 1234/11 1234) #f)+(num-test (>= 1234/11 1234/11 1234) #f)+(num-test (+ 1234/11 1234/11 123.4) 347.76363636363635)+(num-test (- 1234/11 1234/11 123.4) -123.4)+(num-test (* 1234/11 1234/11 123.4) 1552959.42479338846169)+(num-test (/ 1234/11 1234/11 123.4) 0.00810372771475)+(num-test (= 1234/11 1234/11 123.4) #f)+(num-test (< 1234/11 1234/11 123.4) #f)+(num-test (<= 1234/11 1234/11 123.4) #t)+(num-test (> 1234/11 1234/11 123.4) #f)+(num-test (>= 1234/11 1234/11 123.4) #f)+(num-test (+ 1234/11 1234/11 1234/11) 3702/11)+(num-test (- 1234/11 1234/11 1234/11) -1234/11)+(if (not with-64-bit-ints)+    (num-test (* 1234/11 1234/11 1234/11) 1411781.29526672)+    (num-test (* 1234/11 1234/11 1234/11) 1879080904/1331))+(num-test (/ 1234/11 1234/11 1234/11) 11/1234)+(num-test (= 1234/11 1234/11 1234/11) #t)+(num-test (< 1234/11 1234/11 1234/11) #f)+(num-test (<= 1234/11 1234/11 1234/11) #t)+(num-test (> 1234/11 1234/11 1234/11) #f)+(num-test (>= 1234/11 1234/11 1234/11) #t)+(num-test (+ 1234/11 1234/11 1.234+1.234i) 225.59763636363638+1.234i)+(num-test (- 1234/11 1234/11 1.234+1.234i) -1.23399999999999-1.234i)+(num-test (* 1234/11 1234/11 1.234+1.234i) 15529.59424793388644+15529.59424793388644i)+(num-test (/ 1234/11 1234/11 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1234/11 1234/11 1.234+1.234i) #f)+(num-test (+ 1234/11 1234/11 -1.0+1.0i) 223.36363636363637+1.0i)+(num-test (- 1234/11 1234/11 -1.0+1.0i) 1.00000000000001-1.0i)+(num-test (* 1234/11 1234/11 -1.0+1.0i) -12584.76033057851419+12584.76033057851419i)+(num-test (/ 1234/11 1234/11 -1.0+1.0i) -0.5-0.5i)+(num-test (= 1234/11 1234/11 -1.0+1.0i) #f)+(num-test (+ 1234/11 1234/11 0.0+1.0i) 224.36363636363637+1.0i)+(num-test (- 1234/11 1234/11 0.0+1.0i) 0.0-1.0i)+(num-test (* 1234/11 1234/11 0.0+1.0i) 0.0+12584.76033057851419i)+(num-test (/ 1234/11 1234/11 0.0+1.0i) 0.0-1.0i)+(num-test (= 1234/11 1234/11 0.0+1.0i) #f)+(num-test (+ 1234/11 1.234+1.234i 1) 114.41581818181818+1.234i)+(num-test (- 1234/11 1.234+1.234i 1) 109.94781818181819-1.234i)+(num-test (* 1234/11 1.234+1.234i 1) 138.43236363636365+138.43236363636365i)+(num-test (/ 1234/11 1.234+1.234i 1) 45.45454545454546-45.45454545454546i)+(num-test (= 1234/11 1.234+1.234i 1) #f)+(num-test (+ 1234/11 1.234+1.234i 1.0) 114.41581818181818+1.234i)+(num-test (- 1234/11 1.234+1.234i 1.0) 109.94781818181819-1.234i)+(num-test (* 1234/11 1.234+1.234i 1.0) 138.43236363636365+138.43236363636365i)+(num-test (/ 1234/11 1.234+1.234i 1.0) 45.45454545454546-45.45454545454546i)+(num-test (= 1234/11 1.234+1.234i 1.0) #f)+(num-test (+ 1234/11 1.234+1.234i 1/1) 114.41581818181818+1.234i)+(num-test (- 1234/11 1.234+1.234i 1/1) 109.94781818181819-1.234i)+(num-test (* 1234/11 1.234+1.234i 1/1) 138.43236363636365+138.43236363636365i)+(num-test (/ 1234/11 1.234+1.234i 1/1) 45.45454545454546-45.45454545454546i)+(num-test (= 1234/11 1.234+1.234i 1/1) #f)+(num-test (+ 1234/11 1.234+1.234i 1.0+1.0i) 114.41581818181818+2.234i)+(num-test (- 1234/11 1.234+1.234i 1.0+1.0i) 109.94781818181819-2.234i)+(num-test (* 1234/11 1.234+1.234i 1.0+1.0i) 0.0+276.86472727272729i)+(num-test (/ 1234/11 1.234+1.234i 1.0+1.0i) 0.0-45.45454545454546i)+(num-test (= 1234/11 1.234+1.234i 1.0+1.0i) #f)+(num-test (+ 1234/11 1.234+1.234i 0) 113.41581818181818+1.234i)+(num-test (- 1234/11 1.234+1.234i 0) 110.94781818181819-1.234i)+(num-test (* 1234/11 1.234+1.234i 0) 0.0)+(num-test (+ 1234/11 1.234+1.234i 0.0) 113.41581818181818+1.234i)+(num-test (- 1234/11 1.234+1.234i 0.0) 110.94781818181819-1.234i)+(num-test (* 1234/11 1.234+1.234i 0.0) 0.0)+(num-test (+ 1234/11 1.234+1.234i 1234) 1347.41581818181817+1.234i)+(num-test (- 1234/11 1.234+1.234i 1234) -1123.05218181818191-1.234i)+(num-test (* 1234/11 1.234+1.234i 1234) 170825.53672727273079+170825.53672727273079i)+(num-test (/ 1234/11 1.234+1.234i 1234) 0.03683512597613-0.03683512597613i)+(num-test (= 1234/11 1.234+1.234i 1234) #f)+(num-test (+ 1234/11 1.234+1.234i 123.4) 236.81581818181820+1.234i)+(num-test (- 1234/11 1.234+1.234i 123.4) -12.45218181818181-1.234i)+(num-test (* 1234/11 1.234+1.234i 123.4) 17082.55367272727381+17082.55367272727381i)+(num-test (/ 1234/11 1.234+1.234i 123.4) 0.36835125976131-0.36835125976131i)+(num-test (= 1234/11 1.234+1.234i 123.4) #f)+(num-test (+ 1234/11 1.234+1.234i 1234/11) 225.59763636363635+1.234i)+(num-test (- 1234/11 1.234+1.234i 1234/11) -1.23399999999999-1.234i)+(num-test (* 1234/11 1.234+1.234i 1234/11) 15529.59424793388644+15529.59424793388644i)+(num-test (/ 1234/11 1.234+1.234i 1234/11) 0.40518638573744-0.40518638573744i)+(num-test (= 1234/11 1.234+1.234i 1234/11) #f)+(num-test (+ 1234/11 1.234+1.234i 1.234+1.234i) 114.64981818181818+2.468i)+(num-test (- 1234/11 1.234+1.234i 1.234+1.234i) 109.71381818181820-2.468i)+(num-test (* 1234/11 1.234+1.234i 1.234+1.234i) 0.0+341.65107345454550i)+(num-test (/ 1234/11 1.234+1.234i 1.234+1.234i) 0.0-36.83512597613085i)+(num-test (= 1234/11 1.234+1.234i 1.234+1.234i) #f)+(num-test (+ 1234/11 1.234+1.234i -1.0+1.0i) 112.41581818181818+2.234i)+(num-test (- 1234/11 1.234+1.234i -1.0+1.0i) 111.94781818181819-2.234i)+(num-test (* 1234/11 1.234+1.234i -1.0+1.0i) -276.86472727272729)+(num-test (/ 1234/11 1.234+1.234i -1.0+1.0i) -45.45454545454546)+(num-test (= 1234/11 1.234+1.234i -1.0+1.0i) #f)+(num-test (+ 1234/11 1.234+1.234i 0.0+1.0i) 113.41581818181818+2.234i)+(num-test (- 1234/11 1.234+1.234i 0.0+1.0i) 110.94781818181819-2.234i)+(num-test (* 1234/11 1.234+1.234i 0.0+1.0i) -138.43236363636365+138.43236363636365i)+(num-test (/ 1234/11 1.234+1.234i 0.0+1.0i) -45.45454545454546-45.45454545454546i)+(num-test (= 1234/11 1.234+1.234i 0.0+1.0i) #f)+(num-test (+ 1234/11 -1.0+1.0i 1) 112.18181818181819+1.0i)+(num-test (- 1234/11 -1.0+1.0i 1) 112.18181818181819-1.0i)+(num-test (* 1234/11 -1.0+1.0i 1) -112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 -1.0+1.0i 1) -56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 -1.0+1.0i 1) #f)+(num-test (+ 1234/11 -1.0+1.0i 1.0) 112.18181818181819+1.0i)+(num-test (- 1234/11 -1.0+1.0i 1.0) 112.18181818181819-1.0i)+(num-test (* 1234/11 -1.0+1.0i 1.0) -112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 -1.0+1.0i 1.0) -56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 -1.0+1.0i 1.0) #f)+(num-test (+ 1234/11 -1.0+1.0i 1/1) 112.18181818181819+1.0i)+(num-test (- 1234/11 -1.0+1.0i 1/1) 112.18181818181819-1.0i)+(num-test (* 1234/11 -1.0+1.0i 1/1) -112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 -1.0+1.0i 1/1) -56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 -1.0+1.0i 1/1) #f)+(num-test (+ 1234/11 -1.0+1.0i 1.0+1.0i) 112.18181818181819+2.0i)+(num-test (- 1234/11 -1.0+1.0i 1.0+1.0i) 112.18181818181819-2.0i)+(num-test (* 1234/11 -1.0+1.0i 1.0+1.0i) -224.36363636363637)+(num-test (/ 1234/11 -1.0+1.0i 1.0+1.0i) -56.09090909090909)+(num-test (= 1234/11 -1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1234/11 -1.0+1.0i 0) 111.18181818181819+1.0i)+(num-test (- 1234/11 -1.0+1.0i 0) 113.18181818181819-1.0i)+(num-test (* 1234/11 -1.0+1.0i 0) -0.0)+(num-test (+ 1234/11 -1.0+1.0i 0.0) 111.18181818181819+1.0i)+(num-test (- 1234/11 -1.0+1.0i 0.0) 113.18181818181819-1.0i)+(num-test (* 1234/11 -1.0+1.0i 0.0) -0.0)+(num-test (+ 1234/11 -1.0+1.0i 1234) 1345.18181818181824+1.0i)+(num-test (- 1234/11 -1.0+1.0i 1234) -1120.81818181818176-1.0i)+(num-test (* 1234/11 -1.0+1.0i 1234) -138432.36363636364695+138432.36363636364695i)+(num-test (/ 1234/11 -1.0+1.0i 1234) -0.04545454545455-0.04545454545455i)+(num-test (= 1234/11 -1.0+1.0i 1234) #f)+(num-test (+ 1234/11 -1.0+1.0i 123.4) 234.58181818181819+1.0i)+(num-test (- 1234/11 -1.0+1.0i 123.4) -10.21818181818182-1.0i)+(num-test (* 1234/11 -1.0+1.0i 123.4) -13843.23636363636433+13843.23636363636433i)+(num-test (/ 1234/11 -1.0+1.0i 123.4) -0.45454545454545-0.45454545454545i)+(num-test (= 1234/11 -1.0+1.0i 123.4) #f)+(num-test (+ 1234/11 -1.0+1.0i 1234/11) 223.36363636363637+1.0i)+(num-test (- 1234/11 -1.0+1.0i 1234/11) 1.00000000000001-1.0i)+(num-test (* 1234/11 -1.0+1.0i 1234/11) -12584.76033057851419+12584.76033057851419i)+(num-test (/ 1234/11 -1.0+1.0i 1234/11) -0.5-0.5i)+(num-test (= 1234/11 -1.0+1.0i 1234/11) #f)+(num-test (+ 1234/11 -1.0+1.0i 1.234+1.234i) 112.41581818181818+2.234i)+(num-test (- 1234/11 -1.0+1.0i 1.234+1.234i) 111.94781818181819-2.234i)+(num-test (* 1234/11 -1.0+1.0i 1.234+1.234i) -276.86472727272729)+(num-test (/ 1234/11 -1.0+1.0i 1.234+1.234i) -45.45454545454546)+(num-test (= 1234/11 -1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1234/11 -1.0+1.0i -1.0+1.0i) 110.18181818181819+2.0i)+(num-test (- 1234/11 -1.0+1.0i -1.0+1.0i) 114.18181818181819-2.0i)+(num-test (* 1234/11 -1.0+1.0i -1.0+1.0i) 0.0-224.36363636363637i)+(num-test (/ 1234/11 -1.0+1.0i -1.0+1.0i) -0.0+56.09090909090909i)+(num-test (= 1234/11 -1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1234/11 -1.0+1.0i 0.0+1.0i) 111.18181818181819+2.0i)+(num-test (- 1234/11 -1.0+1.0i 0.0+1.0i) 113.18181818181819-2.0i)+(num-test (* 1234/11 -1.0+1.0i 0.0+1.0i) -112.18181818181819-112.18181818181819i)+(num-test (/ 1234/11 -1.0+1.0i 0.0+1.0i) -56.09090909090909+56.09090909090909i)+(num-test (= 1234/11 -1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1234/11 0.0+1.0i 1) 113.18181818181819+1.0i)+(num-test (- 1234/11 0.0+1.0i 1) 111.18181818181819-1.0i)+(num-test (* 1234/11 0.0+1.0i 1) 0.0+112.18181818181819i)+(num-test (/ 1234/11 0.0+1.0i 1) 0.0-112.18181818181819i)+(num-test (= 1234/11 0.0+1.0i 1) #f)+(num-test (+ 1234/11 0.0+1.0i 1.0) 113.18181818181819+1.0i)+(num-test (- 1234/11 0.0+1.0i 1.0) 111.18181818181819-1.0i)+(num-test (* 1234/11 0.0+1.0i 1.0) 0.0+112.18181818181819i)+(num-test (/ 1234/11 0.0+1.0i 1.0) 0.0-112.18181818181819i)+(num-test (= 1234/11 0.0+1.0i 1.0) #f)+(num-test (+ 1234/11 0.0+1.0i 1/1) 113.18181818181819+1.0i)+(num-test (- 1234/11 0.0+1.0i 1/1) 111.18181818181819-1.0i)+(num-test (* 1234/11 0.0+1.0i 1/1) 0.0+112.18181818181819i)+(num-test (/ 1234/11 0.0+1.0i 1/1) 0.0-112.18181818181819i)+(num-test (= 1234/11 0.0+1.0i 1/1) #f)+(num-test (+ 1234/11 0.0+1.0i 1.0+1.0i) 113.18181818181819+2.0i)+(num-test (- 1234/11 0.0+1.0i 1.0+1.0i) 111.18181818181819-2.0i)+(num-test (* 1234/11 0.0+1.0i 1.0+1.0i) -112.18181818181819+112.18181818181819i)+(num-test (/ 1234/11 0.0+1.0i 1.0+1.0i) -56.09090909090909-56.09090909090909i)+(num-test (= 1234/11 0.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1234/11 0.0+1.0i 0) 112.18181818181819+1.0i)+(num-test (- 1234/11 0.0+1.0i 0) 112.18181818181819-1.0i)+(num-test (* 1234/11 0.0+1.0i 0) 0.0)+(num-test (+ 1234/11 0.0+1.0i 0.0) 112.18181818181819+1.0i)+(num-test (- 1234/11 0.0+1.0i 0.0) 112.18181818181819-1.0i)+(num-test (* 1234/11 0.0+1.0i 0.0) 0.0)+(num-test (+ 1234/11 0.0+1.0i 1234) 1346.18181818181824+1.0i)+(num-test (- 1234/11 0.0+1.0i 1234) -1121.81818181818176-1.0i)+(num-test (* 1234/11 0.0+1.0i 1234) 0.0+138432.36363636364695i)+(num-test (/ 1234/11 0.0+1.0i 1234) 0.0-0.09090909090909i)+(num-test (= 1234/11 0.0+1.0i 1234) #f)+(num-test (+ 1234/11 0.0+1.0i 123.4) 235.58181818181819+1.0i)+(num-test (- 1234/11 0.0+1.0i 123.4) -11.21818181818182-1.0i)+(num-test (* 1234/11 0.0+1.0i 123.4) 0.0+13843.23636363636433i)+(num-test (/ 1234/11 0.0+1.0i 123.4) 0.0-0.90909090909091i)+(num-test (= 1234/11 0.0+1.0i 123.4) #f)+(num-test (+ 1234/11 0.0+1.0i 1234/11) 224.36363636363637+1.0i)+(num-test (- 1234/11 0.0+1.0i 1234/11) 0.00000000000001-1.0i)+(num-test (* 1234/11 0.0+1.0i 1234/11) 0.0+12584.76033057851419i)+(num-test (/ 1234/11 0.0+1.0i 1234/11) 0.0-1.0i)+(num-test (= 1234/11 0.0+1.0i 1234/11) #f)+(num-test (+ 1234/11 0.0+1.0i 1.234+1.234i) 113.41581818181818+2.234i)+(num-test (- 1234/11 0.0+1.0i 1.234+1.234i) 110.94781818181819-2.234i)+(num-test (* 1234/11 0.0+1.0i 1.234+1.234i) -138.43236363636365+138.43236363636365i)+(num-test (/ 1234/11 0.0+1.0i 1.234+1.234i) -45.45454545454546-45.45454545454546i)+(num-test (= 1234/11 0.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1234/11 0.0+1.0i -1.0+1.0i) 111.18181818181819+2.0i)+(num-test (- 1234/11 0.0+1.0i -1.0+1.0i) 113.18181818181819-2.0i)+(num-test (* 1234/11 0.0+1.0i -1.0+1.0i) -112.18181818181819-112.18181818181819i)+(num-test (/ 1234/11 0.0+1.0i -1.0+1.0i) -56.09090909090909+56.09090909090909i)+(num-test (= 1234/11 0.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1234/11 0.0+1.0i 0.0+1.0i) 112.18181818181819+2.0i)+(num-test (- 1234/11 0.0+1.0i 0.0+1.0i) 112.18181818181819-2.0i)+(num-test (* 1234/11 0.0+1.0i 0.0+1.0i) -112.18181818181819)+(num-test (/ 1234/11 0.0+1.0i 0.0+1.0i) -112.18181818181819)+(num-test (= 1234/11 0.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1 1) 3.234+1.234i)+(num-test (- 1.234+1.234i 1 1) -0.766+1.234i)+(num-test (* 1.234+1.234i 1 1) 1.234+1.234i)+(num-test (/ 1.234+1.234i 1 1) 1.234+1.234i)+(num-test (= 1.234+1.234i 1 1) #f)+(num-test (+ 1.234+1.234i 1 1.0) 3.234+1.234i)+(num-test (- 1.234+1.234i 1 1.0) -0.766+1.234i)+(num-test (* 1.234+1.234i 1 1.0) 1.234+1.234i)+(num-test (/ 1.234+1.234i 1 1.0) 1.234+1.234i)+(num-test (= 1.234+1.234i 1 1.0) #f)+(num-test (+ 1.234+1.234i 1 1/1) 3.234+1.234i)+(num-test (- 1.234+1.234i 1 1/1) -0.766+1.234i)+(num-test (* 1.234+1.234i 1 1/1) 1.234+1.234i)+(num-test (/ 1.234+1.234i 1 1/1) 1.234+1.234i)+(num-test (= 1.234+1.234i 1 1/1) #f)+(num-test (+ 1.234+1.234i 1 1.0+1.0i) 3.234+2.234i)+(num-test (- 1.234+1.234i 1 1.0+1.0i) -0.766+0.234i)+(num-test (* 1.234+1.234i 1 1.0+1.0i) 0.0+2.468i)+(num-test (/ 1.234+1.234i 1 1.0+1.0i) 1.234)+(num-test (= 1.234+1.234i 1 1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1 0) 2.234+1.234i)+(num-test (- 1.234+1.234i 1 0) 0.234+1.234i)+(num-test (* 1.234+1.234i 1 0) 0.0)+(num-test (+ 1.234+1.234i 1 0.0) 2.234+1.234i)+(num-test (- 1.234+1.234i 1 0.0) 0.234+1.234i)+(num-test (* 1.234+1.234i 1 0.0) 0.0)+(num-test (+ 1.234+1.234i 1 1234) 1236.23399999999992+1.234i)+(num-test (- 1.234+1.234i 1 1234) -1233.766+1.234i)+(num-test (* 1.234+1.234i 1 1234) 1522.756+1522.756i)+(num-test (/ 1.234+1.234i 1 1234) 0.001+0.001i)+(num-test (= 1.234+1.234i 1 1234) #f)+(num-test (+ 1.234+1.234i 1 123.4) 125.634+1.234i)+(num-test (- 1.234+1.234i 1 123.4) -123.16600000000001+1.234i)+(num-test (* 1.234+1.234i 1 123.4) 152.2756+152.2756i)+(num-test (/ 1.234+1.234i 1 123.4) 0.01+0.01i)+(num-test (= 1.234+1.234i 1 123.4) #f)+(num-test (+ 1.234+1.234i 1 1234/11) 114.41581818181818+1.234i)+(num-test (- 1.234+1.234i 1 1234/11) -111.94781818181818+1.234i)+(num-test (* 1.234+1.234i 1 1234/11) 138.43236363636365+138.43236363636365i)+(num-test (/ 1.234+1.234i 1 1234/11) 0.011+0.011i)+(num-test (= 1.234+1.234i 1 1234/11) #f)+(num-test (+ 1.234+1.234i 1 1.234+1.234i) 3.468+2.468i)+(num-test (- 1.234+1.234i 1 1.234+1.234i) -1.0)+(num-test (* 1.234+1.234i 1 1.234+1.234i) 0.0+3.04551200000000i)+(num-test (/ 1.234+1.234i 1 1.234+1.234i) 1.0)+(num-test (= 1.234+1.234i 1 1.234+1.234i) #f)+(num-test (+ 1.234+1.234i 1 -1.0+1.0i) 1.234+2.234i)+(num-test (- 1.234+1.234i 1 -1.0+1.0i) 1.234+0.234i)+(num-test (* 1.234+1.234i 1 -1.0+1.0i) -2.468)+(num-test (/ 1.234+1.234i 1 -1.0+1.0i) -0.0-1.234i)+(num-test (= 1.234+1.234i 1 -1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1 0.0+1.0i) 2.234+2.234i)+(num-test (- 1.234+1.234i 1 0.0+1.0i) 0.234+0.234i)+(num-test (* 1.234+1.234i 1 0.0+1.0i) -1.234+1.234i)+(num-test (/ 1.234+1.234i 1 0.0+1.0i) 1.234-1.234i)+(num-test (= 1.234+1.234i 1 0.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1.0 1) 3.234+1.234i)+(num-test (- 1.234+1.234i 1.0 1) -0.766+1.234i)+(num-test (* 1.234+1.234i 1.0 1) 1.234+1.234i)+(num-test (/ 1.234+1.234i 1.0 1) 1.234+1.234i)+(num-test (= 1.234+1.234i 1.0 1) #f)+(num-test (+ 1.234+1.234i 1.0 1.0) 3.234+1.234i)+(num-test (- 1.234+1.234i 1.0 1.0) -0.766+1.234i)+(num-test (* 1.234+1.234i 1.0 1.0) 1.234+1.234i)+(num-test (/ 1.234+1.234i 1.0 1.0) 1.234+1.234i)+(num-test (= 1.234+1.234i 1.0 1.0) #f)+(num-test (+ 1.234+1.234i 1.0 1/1) 3.234+1.234i)+(num-test (- 1.234+1.234i 1.0 1/1) -0.766+1.234i)+(num-test (* 1.234+1.234i 1.0 1/1) 1.234+1.234i)+(num-test (/ 1.234+1.234i 1.0 1/1) 1.234+1.234i)+(num-test (= 1.234+1.234i 1.0 1/1) #f)+(num-test (+ 1.234+1.234i 1.0 1.0+1.0i) 3.234+2.234i)+(num-test (- 1.234+1.234i 1.0 1.0+1.0i) -0.766+0.234i)+(num-test (* 1.234+1.234i 1.0 1.0+1.0i) 0.0+2.468i)+(num-test (/ 1.234+1.234i 1.0 1.0+1.0i) 1.234)+(num-test (= 1.234+1.234i 1.0 1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1.0 0) 2.234+1.234i)+(num-test (- 1.234+1.234i 1.0 0) 0.234+1.234i)+(num-test (* 1.234+1.234i 1.0 0) 0.0)+(num-test (+ 1.234+1.234i 1.0 0.0) 2.234+1.234i)+(num-test (- 1.234+1.234i 1.0 0.0) 0.234+1.234i)+(num-test (* 1.234+1.234i 1.0 0.0) 0.0)+(num-test (+ 1.234+1.234i 1.0 1234) 1236.23399999999992+1.234i)+(num-test (- 1.234+1.234i 1.0 1234) -1233.766+1.234i)+(num-test (* 1.234+1.234i 1.0 1234) 1522.756+1522.756i)+(num-test (/ 1.234+1.234i 1.0 1234) 0.001+0.001i)+(num-test (= 1.234+1.234i 1.0 1234) #f)+(num-test (+ 1.234+1.234i 1.0 123.4) 125.634+1.234i)+(num-test (- 1.234+1.234i 1.0 123.4) -123.16600000000001+1.234i)+(num-test (* 1.234+1.234i 1.0 123.4) 152.2756+152.2756i)+(num-test (/ 1.234+1.234i 1.0 123.4) 0.01+0.01i)+(num-test (= 1.234+1.234i 1.0 123.4) #f)+(num-test (+ 1.234+1.234i 1.0 1234/11) 114.41581818181818+1.234i)+(num-test (- 1.234+1.234i 1.0 1234/11) -111.94781818181818+1.234i)+(num-test (* 1.234+1.234i 1.0 1234/11) 138.43236363636365+138.43236363636365i)+(num-test (/ 1.234+1.234i 1.0 1234/11) 0.011+0.011i)+(num-test (= 1.234+1.234i 1.0 1234/11) #f)+(num-test (+ 1.234+1.234i 1.0 1.234+1.234i) 3.468+2.468i)+(num-test (- 1.234+1.234i 1.0 1.234+1.234i) -1.0)+(num-test (* 1.234+1.234i 1.0 1.234+1.234i) 0.0+3.04551200000000i)+(num-test (/ 1.234+1.234i 1.0 1.234+1.234i) 1.0)+(num-test (= 1.234+1.234i 1.0 1.234+1.234i) #f)+(num-test (+ 1.234+1.234i 1.0 -1.0+1.0i) 1.234+2.234i)+(num-test (- 1.234+1.234i 1.0 -1.0+1.0i) 1.234+0.234i)+(num-test (* 1.234+1.234i 1.0 -1.0+1.0i) -2.468)+(num-test (/ 1.234+1.234i 1.0 -1.0+1.0i) -0.0-1.234i)+(num-test (= 1.234+1.234i 1.0 -1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1.0 0.0+1.0i) 2.234+2.234i)+(num-test (- 1.234+1.234i 1.0 0.0+1.0i) 0.234+0.234i)+(num-test (* 1.234+1.234i 1.0 0.0+1.0i) -1.234+1.234i)+(num-test (/ 1.234+1.234i 1.0 0.0+1.0i) 1.234-1.234i)+(num-test (= 1.234+1.234i 1.0 0.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1/1 1) 3.234+1.234i)+(num-test (- 1.234+1.234i 1/1 1) -0.766+1.234i)+(num-test (* 1.234+1.234i 1/1 1) 1.234+1.234i)+(num-test (/ 1.234+1.234i 1/1 1) 1.234+1.234i)+(num-test (= 1.234+1.234i 1/1 1) #f)+(num-test (+ 1.234+1.234i 1/1 1.0) 3.234+1.234i)+(num-test (- 1.234+1.234i 1/1 1.0) -0.766+1.234i)+(num-test (* 1.234+1.234i 1/1 1.0) 1.234+1.234i)+(num-test (/ 1.234+1.234i 1/1 1.0) 1.234+1.234i)+(num-test (= 1.234+1.234i 1/1 1.0) #f)+(num-test (+ 1.234+1.234i 1/1 1/1) 3.234+1.234i)+(num-test (- 1.234+1.234i 1/1 1/1) -0.766+1.234i)+(num-test (* 1.234+1.234i 1/1 1/1) 1.234+1.234i)+(num-test (/ 1.234+1.234i 1/1 1/1) 1.234+1.234i)+(num-test (= 1.234+1.234i 1/1 1/1) #f)+(num-test (+ 1.234+1.234i 1/1 1.0+1.0i) 3.234+2.234i)+(num-test (- 1.234+1.234i 1/1 1.0+1.0i) -0.766+0.234i)+(num-test (* 1.234+1.234i 1/1 1.0+1.0i) 0.0+2.468i)+(num-test (/ 1.234+1.234i 1/1 1.0+1.0i) 1.234)+(num-test (= 1.234+1.234i 1/1 1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1/1 0) 2.234+1.234i)+(num-test (- 1.234+1.234i 1/1 0) 0.234+1.234i)+(num-test (* 1.234+1.234i 1/1 0) 0.0)+(num-test (+ 1.234+1.234i 1/1 0.0) 2.234+1.234i)+(num-test (- 1.234+1.234i 1/1 0.0) 0.234+1.234i)+(num-test (* 1.234+1.234i 1/1 0.0) 0.0)+(num-test (+ 1.234+1.234i 1/1 1234) 1236.23399999999992+1.234i)+(num-test (- 1.234+1.234i 1/1 1234) -1233.766+1.234i)+(num-test (* 1.234+1.234i 1/1 1234) 1522.756+1522.756i)+(num-test (/ 1.234+1.234i 1/1 1234) 0.001+0.001i)+(num-test (= 1.234+1.234i 1/1 1234) #f)+(num-test (+ 1.234+1.234i 1/1 123.4) 125.634+1.234i)+(num-test (- 1.234+1.234i 1/1 123.4) -123.16600000000001+1.234i)+(num-test (* 1.234+1.234i 1/1 123.4) 152.2756+152.2756i)+(num-test (/ 1.234+1.234i 1/1 123.4) 0.01+0.01i)+(num-test (= 1.234+1.234i 1/1 123.4) #f)+(num-test (+ 1.234+1.234i 1/1 1234/11) 114.41581818181818+1.234i)+(num-test (- 1.234+1.234i 1/1 1234/11) -111.94781818181818+1.234i)+(num-test (* 1.234+1.234i 1/1 1234/11) 138.43236363636365+138.43236363636365i)+(num-test (/ 1.234+1.234i 1/1 1234/11) 0.011+0.011i)+(num-test (= 1.234+1.234i 1/1 1234/11) #f)+(num-test (+ 1.234+1.234i 1/1 1.234+1.234i) 3.468+2.468i)+(num-test (- 1.234+1.234i 1/1 1.234+1.234i) -1.0)+(num-test (* 1.234+1.234i 1/1 1.234+1.234i) 0.0+3.04551200000000i)+(num-test (/ 1.234+1.234i 1/1 1.234+1.234i) 1.0)+(num-test (= 1.234+1.234i 1/1 1.234+1.234i) #f)+(num-test (+ 1.234+1.234i 1/1 -1.0+1.0i) 1.234+2.234i)+(num-test (- 1.234+1.234i 1/1 -1.0+1.0i) 1.234+0.234i)+(num-test (* 1.234+1.234i 1/1 -1.0+1.0i) -2.468)+(num-test (/ 1.234+1.234i 1/1 -1.0+1.0i) -0.0-1.234i)+(num-test (= 1.234+1.234i 1/1 -1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1/1 0.0+1.0i) 2.234+2.234i)+(num-test (- 1.234+1.234i 1/1 0.0+1.0i) 0.234+0.234i)+(num-test (* 1.234+1.234i 1/1 0.0+1.0i) -1.234+1.234i)+(num-test (/ 1.234+1.234i 1/1 0.0+1.0i) 1.234-1.234i)+(num-test (= 1.234+1.234i 1/1 0.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1.0+1.0i 1) 3.234+2.234i)+(num-test (- 1.234+1.234i 1.0+1.0i 1) -0.766+0.234i)+(num-test (* 1.234+1.234i 1.0+1.0i 1) 0.0+2.468i)+(num-test (/ 1.234+1.234i 1.0+1.0i 1) 1.234)+(num-test (= 1.234+1.234i 1.0+1.0i 1) #f)+(num-test (+ 1.234+1.234i 1.0+1.0i 1.0) 3.234+2.234i)+(num-test (- 1.234+1.234i 1.0+1.0i 1.0) -0.766+0.234i)+(num-test (* 1.234+1.234i 1.0+1.0i 1.0) 0.0+2.468i)+(num-test (/ 1.234+1.234i 1.0+1.0i 1.0) 1.234)+(num-test (= 1.234+1.234i 1.0+1.0i 1.0) #f)+(num-test (+ 1.234+1.234i 1.0+1.0i 1/1) 3.234+2.234i)+(num-test (- 1.234+1.234i 1.0+1.0i 1/1) -0.766+0.234i)+(num-test (* 1.234+1.234i 1.0+1.0i 1/1) 0.0+2.468i)+(num-test (/ 1.234+1.234i 1.0+1.0i 1/1) 1.234)+(num-test (= 1.234+1.234i 1.0+1.0i 1/1) #f)+(num-test (+ 1.234+1.234i 1.0+1.0i 1.0+1.0i) 3.234+3.234i)+(num-test (- 1.234+1.234i 1.0+1.0i 1.0+1.0i) -0.766-0.766i)+(num-test (* 1.234+1.234i 1.0+1.0i 1.0+1.0i) -2.468+2.468i)+(num-test (/ 1.234+1.234i 1.0+1.0i 1.0+1.0i) 0.617-0.617i)+(num-test (= 1.234+1.234i 1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1.0+1.0i 0) 2.234+2.234i)+(num-test (- 1.234+1.234i 1.0+1.0i 0) 0.234+0.234i)+(num-test (* 1.234+1.234i 1.0+1.0i 0) 0.0)+(num-test (+ 1.234+1.234i 1.0+1.0i 0.0) 2.234+2.234i)+(num-test (- 1.234+1.234i 1.0+1.0i 0.0) 0.234+0.234i)+(num-test (* 1.234+1.234i 1.0+1.0i 0.0) 0.0)+(num-test (+ 1.234+1.234i 1.0+1.0i 1234) 1236.23399999999992+2.234i)+(num-test (- 1.234+1.234i 1.0+1.0i 1234) -1233.766+0.234i)+(num-test (* 1.234+1.234i 1.0+1.0i 1234) 0.0+3045.51200000000017i)+(num-test (/ 1.234+1.234i 1.0+1.0i 1234) 0.001)+(num-test (= 1.234+1.234i 1.0+1.0i 1234) #f)+(num-test (+ 1.234+1.234i 1.0+1.0i 123.4) 125.634+2.234i)+(num-test (- 1.234+1.234i 1.0+1.0i 123.4) -123.16600000000001+0.234i)+(num-test (* 1.234+1.234i 1.0+1.0i 123.4) 0.0+304.55119999999999i)+(num-test (/ 1.234+1.234i 1.0+1.0i 123.4) 0.01)+(num-test (= 1.234+1.234i 1.0+1.0i 123.4) #f)+(num-test (+ 1.234+1.234i 1.0+1.0i 1234/11) 114.41581818181818+2.234i)+(num-test (- 1.234+1.234i 1.0+1.0i 1234/11) -111.94781818181818+0.234i)+(num-test (* 1.234+1.234i 1.0+1.0i 1234/11) 0.0+276.86472727272729i)+(num-test (/ 1.234+1.234i 1.0+1.0i 1234/11) 0.011)+(num-test (= 1.234+1.234i 1.0+1.0i 1234/11) #f)+(num-test (+ 1.234+1.234i 1.0+1.0i 1.234+1.234i) 3.468+3.468i)+(num-test (- 1.234+1.234i 1.0+1.0i 1.234+1.234i) -1.0-1.0i)+(num-test (* 1.234+1.234i 1.0+1.0i 1.234+1.234i) -3.04551200000000+3.04551200000000i)+(num-test (/ 1.234+1.234i 1.0+1.0i 1.234+1.234i) 0.5-0.5i)+(num-test (= 1.234+1.234i 1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1.234+1.234i 1.0+1.0i -1.0+1.0i) 1.234+3.234i)+(num-test (- 1.234+1.234i 1.0+1.0i -1.0+1.0i) 1.234-0.766i)+(num-test (* 1.234+1.234i 1.0+1.0i -1.0+1.0i) -2.468-2.468i)+(num-test (/ 1.234+1.234i 1.0+1.0i -1.0+1.0i) -0.617-0.617i)+(num-test (= 1.234+1.234i 1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1.0+1.0i 0.0+1.0i) 2.234+3.234i)+(num-test (- 1.234+1.234i 1.0+1.0i 0.0+1.0i) 0.234-0.766i)+(num-test (* 1.234+1.234i 1.0+1.0i 0.0+1.0i) -2.468)+(num-test (/ 1.234+1.234i 1.0+1.0i 0.0+1.0i) 0.0-1.234i)+(num-test (= 1.234+1.234i 1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1.234+1.234i 0 1) 2.234+1.234i)+(num-test (- 1.234+1.234i 0 1) 0.234+1.234i)+(num-test (* 1.234+1.234i 0 1) 0.0)+(num-test (+ 1.234+1.234i 0 1.0) 2.234+1.234i)+(num-test (- 1.234+1.234i 0 1.0) 0.234+1.234i)+(num-test (* 1.234+1.234i 0 1.0) 0.0)+(num-test (+ 1.234+1.234i 0 1/1) 2.234+1.234i)+(num-test (- 1.234+1.234i 0 1/1) 0.234+1.234i)+(num-test (* 1.234+1.234i 0 1/1) 0.0)+(num-test (+ 1.234+1.234i 0 1.0+1.0i) 2.234+2.234i)+(num-test (- 1.234+1.234i 0 1.0+1.0i) 0.234+0.234i)+(num-test (* 1.234+1.234i 0 1.0+1.0i) 0.0)+(num-test (+ 1.234+1.234i 0 0) 1.234+1.234i)+(num-test (- 1.234+1.234i 0 0) 1.234+1.234i)+(num-test (* 1.234+1.234i 0 0) 0.0)+(num-test (+ 1.234+1.234i 0 0.0) 1.234+1.234i)+(num-test (- 1.234+1.234i 0 0.0) 1.234+1.234i)+(num-test (* 1.234+1.234i 0 0.0) 0.0)+(num-test (+ 1.234+1.234i 0 1234) 1235.23399999999992+1.234i)+(num-test (- 1.234+1.234i 0 1234) -1232.766+1.234i)+(num-test (* 1.234+1.234i 0 1234) 0.0)+(num-test (+ 1.234+1.234i 0 123.4) 124.634+1.234i)+(num-test (- 1.234+1.234i 0 123.4) -122.16600000000001+1.234i)+(num-test (* 1.234+1.234i 0 123.4) 0.0)+(num-test (+ 1.234+1.234i 0 1234/11) 113.41581818181818+1.234i)+(num-test (- 1.234+1.234i 0 1234/11) -110.94781818181818+1.234i)+(num-test (* 1.234+1.234i 0 1234/11) 0.0)+(num-test (+ 1.234+1.234i 0 1.234+1.234i) 2.468+2.468i)+(num-test (- 1.234+1.234i 0 1.234+1.234i) 0.0)+(num-test (* 1.234+1.234i 0 1.234+1.234i) 0.0)+(num-test (+ 1.234+1.234i 0 -1.0+1.0i) 0.234+2.234i)+(num-test (- 1.234+1.234i 0 -1.0+1.0i) 2.234+0.234i)+(num-test (* 1.234+1.234i 0 -1.0+1.0i) -0.0)+(num-test (+ 1.234+1.234i 0 0.0+1.0i) 1.234+2.234i)+(num-test (- 1.234+1.234i 0 0.0+1.0i) 1.234+0.234i)+(num-test (* 1.234+1.234i 0 0.0+1.0i) 0.0)+(num-test (+ 1.234+1.234i 0.0 1) 2.234+1.234i)+(num-test (- 1.234+1.234i 0.0 1) 0.234+1.234i)+(num-test (* 1.234+1.234i 0.0 1) 0.0)+(num-test (+ 1.234+1.234i 0.0 1.0) 2.234+1.234i)+(num-test (- 1.234+1.234i 0.0 1.0) 0.234+1.234i)+(num-test (* 1.234+1.234i 0.0 1.0) 0.0)+(num-test (+ 1.234+1.234i 0.0 1/1) 2.234+1.234i)+(num-test (- 1.234+1.234i 0.0 1/1) 0.234+1.234i)+(num-test (* 1.234+1.234i 0.0 1/1) 0.0)+(num-test (+ 1.234+1.234i 0.0 1.0+1.0i) 2.234+2.234i)+(num-test (- 1.234+1.234i 0.0 1.0+1.0i) 0.234+0.234i)+(num-test (* 1.234+1.234i 0.0 1.0+1.0i) 0.0)+(num-test (+ 1.234+1.234i 0.0 0) 1.234+1.234i)+(num-test (- 1.234+1.234i 0.0 0) 1.234+1.234i)+(num-test (* 1.234+1.234i 0.0 0) 0.0)+(num-test (+ 1.234+1.234i 0.0 0.0) 1.234+1.234i)+(num-test (- 1.234+1.234i 0.0 0.0) 1.234+1.234i)+(num-test (* 1.234+1.234i 0.0 0.0) 0.0)+(num-test (+ 1.234+1.234i 0.0 1234) 1235.23399999999992+1.234i)+(num-test (- 1.234+1.234i 0.0 1234) -1232.766+1.234i)+(num-test (* 1.234+1.234i 0.0 1234) 0.0)+(num-test (+ 1.234+1.234i 0.0 123.4) 124.634+1.234i)+(num-test (- 1.234+1.234i 0.0 123.4) -122.166+1.234i)+(num-test (* 1.234+1.234i 0.0 123.4) 0.0)+(num-test (+ 1.234+1.234i 0.0 1234/11) 113.41581818181818+1.234i)+(num-test (- 1.234+1.234i 0.0 1234/11) -110.94781818181818+1.234i)+(num-test (* 1.234+1.234i 0.0 1234/11) 0.0)+(num-test (+ 1.234+1.234i 0.0 1.234+1.234i) 2.468+2.468i)+(num-test (- 1.234+1.234i 0.0 1.234+1.234i) 0.0)+(num-test (* 1.234+1.234i 0.0 1.234+1.234i) 0.0)+(num-test (+ 1.234+1.234i 0.0 -1.0+1.0i) 0.234+2.234i)+(num-test (- 1.234+1.234i 0.0 -1.0+1.0i) 2.234+0.234i)+(num-test (* 1.234+1.234i 0.0 -1.0+1.0i) -0.0)+(num-test (+ 1.234+1.234i 0.0 0.0+1.0i) 1.234+2.234i)+(num-test (- 1.234+1.234i 0.0 0.0+1.0i) 1.234+0.234i)+(num-test (* 1.234+1.234i 0.0 0.0+1.0i) 0.0)+(num-test (+ 1.234+1.234i 1234 1) 1236.23399999999992+1.234i)+(num-test (- 1.234+1.234i 1234 1) -1233.766+1.234i)+(num-test (* 1.234+1.234i 1234 1) 1522.756+1522.756i)+(num-test (/ 1.234+1.234i 1234 1) 0.001+0.001i)+(num-test (= 1.234+1.234i 1234 1) #f)+(num-test (+ 1.234+1.234i 1234 1.0) 1236.23399999999992+1.234i)+(num-test (- 1.234+1.234i 1234 1.0) -1233.766+1.234i)+(num-test (* 1.234+1.234i 1234 1.0) 1522.756+1522.756i)+(num-test (/ 1.234+1.234i 1234 1.0) 0.001+0.001i)+(num-test (= 1.234+1.234i 1234 1.0) #f)+(num-test (+ 1.234+1.234i 1234 1/1) 1236.23399999999992+1.234i)+(num-test (- 1.234+1.234i 1234 1/1) -1233.766+1.234i)+(num-test (* 1.234+1.234i 1234 1/1) 1522.756+1522.756i)+(num-test (/ 1.234+1.234i 1234 1/1) 0.001+0.001i)+(num-test (= 1.234+1.234i 1234 1/1) #f)+(num-test (+ 1.234+1.234i 1234 1.0+1.0i) 1236.23399999999992+2.234i)+(num-test (- 1.234+1.234i 1234 1.0+1.0i) -1233.766+0.234i)+(num-test (* 1.234+1.234i 1234 1.0+1.0i) 0.0+3045.51200000000017i)+(num-test (/ 1.234+1.234i 1234 1.0+1.0i) 0.001)+(num-test (= 1.234+1.234i 1234 1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1234 0) 1235.23399999999992+1.234i)+(num-test (- 1.234+1.234i 1234 0) -1232.766+1.234i)+(num-test (* 1.234+1.234i 1234 0) 0.0)+(num-test (+ 1.234+1.234i 1234 0.0) 1235.23399999999992+1.234i)+(num-test (- 1.234+1.234i 1234 0.0) -1232.766+1.234i)+(num-test (* 1.234+1.234i 1234 0.0) 0.0)+(num-test (+ 1.234+1.234i 1234 1234) 2469.23399999999992+1.234i)+(num-test (- 1.234+1.234i 1234 1234) -2466.766+1.234i)+(num-test (* 1.234+1.234i 1234 1234) 1879080.90400000009686+1879080.90400000009686i)+(num-test (/ 1.234+1.234i 1234 1234) 0.00000081037277+0.00000081037277i)+(num-test (= 1.234+1.234i 1234 1234) #f)+(num-test (+ 1.234+1.234i 1234 123.4) 1358.63400000000001+1.234i)+(num-test (- 1.234+1.234i 1234 123.4) -1356.16600000000017+1.234i)+(num-test (* 1.234+1.234i 1234 123.4) 187908.09040000001551+187908.09040000001551i)+(num-test (/ 1.234+1.234i 1234 123.4) 0.00000810372771+0.00000810372771i)+(num-test (= 1.234+1.234i 1234 123.4) #f)+(num-test (+ 1.234+1.234i 1234 1234/11) 1347.41581818181817+1.234i)+(num-test (- 1.234+1.234i 1234 1234/11) -1344.94781818181832+1.234i)+(num-test (* 1.234+1.234i 1234 1234/11) 170825.53672727273079+170825.53672727273079i)+(num-test (/ 1.234+1.234i 1234 1234/11) 0.00000891410049+0.00000891410049i)+(num-test (= 1.234+1.234i 1234 1234/11) #f)+(num-test (+ 1.234+1.234i 1234 1.234+1.234i) 1236.46799999999985+2.468i)+(num-test (- 1.234+1.234i 1234 1.234+1.234i) -1234.0)+(num-test (* 1.234+1.234i 1234 1.234+1.234i) 0.0+3758.16180800000029i)+(num-test (/ 1.234+1.234i 1234 1.234+1.234i) 0.00081037277147)+(num-test (= 1.234+1.234i 1234 1.234+1.234i) #f)+(num-test (+ 1.234+1.234i 1234 -1.0+1.0i) 1234.23399999999992+2.234i)+(num-test (- 1.234+1.234i 1234 -1.0+1.0i) -1231.766+0.234i)+(num-test (* 1.234+1.234i 1234 -1.0+1.0i) -3045.51200000000017)+(num-test (/ 1.234+1.234i 1234 -1.0+1.0i) -0.0-0.001i)+(num-test (= 1.234+1.234i 1234 -1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1234 0.0+1.0i) 1235.23399999999992+2.234i)+(num-test (- 1.234+1.234i 1234 0.0+1.0i) -1232.766+0.234i)+(num-test (* 1.234+1.234i 1234 0.0+1.0i) -1522.756+1522.756i)+(num-test (/ 1.234+1.234i 1234 0.0+1.0i) 0.001-0.001i)+(num-test (= 1.234+1.234i 1234 0.0+1.0i) #f)+(num-test (+ 1.234+1.234i 123.4 1) 125.634+1.234i)+(num-test (- 1.234+1.234i 123.4 1) -123.16600000000001+1.234i)+(num-test (* 1.234+1.234i 123.4 1) 152.2756+152.2756i)+(num-test (/ 1.234+1.234i 123.4 1) 0.01+0.01i)+(num-test (= 1.234+1.234i 123.4 1) #f)+(num-test (+ 1.234+1.234i 123.4 1.0) 125.634+1.234i)+(num-test (- 1.234+1.234i 123.4 1.0) -123.16600000000001+1.234i)+(num-test (* 1.234+1.234i 123.4 1.0) 152.2756+152.2756i)+(num-test (/ 1.234+1.234i 123.4 1.0) 0.01+0.01i)+(num-test (= 1.234+1.234i 123.4 1.0) #f)+(num-test (+ 1.234+1.234i 123.4 1/1) 125.634+1.234i)+(num-test (- 1.234+1.234i 123.4 1/1) -123.16600000000001+1.234i)+(num-test (* 1.234+1.234i 123.4 1/1) 152.2756+152.2756i)+(num-test (/ 1.234+1.234i 123.4 1/1) 0.01+0.01i)+(num-test (= 1.234+1.234i 123.4 1/1) #f)+(num-test (+ 1.234+1.234i 123.4 1.0+1.0i) 125.634+2.234i)+(num-test (- 1.234+1.234i 123.4 1.0+1.0i) -123.16600000000001+0.234i)+(num-test (* 1.234+1.234i 123.4 1.0+1.0i) 0.0+304.55119999999999i)+(num-test (/ 1.234+1.234i 123.4 1.0+1.0i) 0.01)+(num-test (= 1.234+1.234i 123.4 1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 123.4 0) 124.634+1.234i)+(num-test (- 1.234+1.234i 123.4 0) -122.16600000000001+1.234i)+(num-test (* 1.234+1.234i 123.4 0) 0.0)+(num-test (+ 1.234+1.234i 123.4 0.0) 124.634+1.234i)+(num-test (- 1.234+1.234i 123.4 0.0) -122.16600000000001+1.234i)+(num-test (* 1.234+1.234i 123.4 0.0) 0.0)+(num-test (+ 1.234+1.234i 123.4 1234) 1358.63400000000001+1.234i)+(num-test (- 1.234+1.234i 123.4 1234) -1356.16599999999994+1.234i)+(num-test (* 1.234+1.234i 123.4 1234) 187908.09039999998640+187908.09039999998640i)+(num-test (/ 1.234+1.234i 123.4 1234) 0.00000810372771+0.00000810372771i)+(num-test (= 1.234+1.234i 123.4 1234) #f)+(num-test (+ 1.234+1.234i 123.4 123.4) 248.03399999999999+1.234i)+(num-test (- 1.234+1.234i 123.4 123.4) -245.56600000000003+1.234i)+(num-test (* 1.234+1.234i 123.4 123.4) 18790.80904000000010+18790.80904000000010i)+(num-test (/ 1.234+1.234i 123.4 123.4) 0.00008103727715+0.00008103727715i)+(num-test (= 1.234+1.234i 123.4 123.4) #f)+(num-test (+ 1.234+1.234i 123.4 1234/11) 236.81581818181817+1.234i)+(num-test (- 1.234+1.234i 123.4 1234/11) -234.34781818181818+1.234i)+(num-test (* 1.234+1.234i 123.4 1234/11) 17082.55367272727381+17082.55367272727381i)+(num-test (/ 1.234+1.234i 123.4 1234/11) 0.00008914100486+0.00008914100486i)+(num-test (= 1.234+1.234i 123.4 1234/11) #f)+(num-test (+ 1.234+1.234i 123.4 1.234+1.234i) 125.86799999999999+2.468i)+(num-test (- 1.234+1.234i 123.4 1.234+1.234i) -123.4)+(num-test (* 1.234+1.234i 123.4 1.234+1.234i) 0.0+375.81618079999998i)+(num-test (/ 1.234+1.234i 123.4 1.234+1.234i) 0.00810372771475)+(num-test (= 1.234+1.234i 123.4 1.234+1.234i) #f)+(num-test (+ 1.234+1.234i 123.4 -1.0+1.0i) 123.634+2.234i)+(num-test (- 1.234+1.234i 123.4 -1.0+1.0i) -121.16600000000001+0.234i)+(num-test (* 1.234+1.234i 123.4 -1.0+1.0i) -304.55119999999999)+(num-test (/ 1.234+1.234i 123.4 -1.0+1.0i) -0.0-0.01i)+(num-test (= 1.234+1.234i 123.4 -1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 123.4 0.0+1.0i) 124.634+2.234i)+(num-test (- 1.234+1.234i 123.4 0.0+1.0i) -122.16600000000001+0.234i)+(num-test (* 1.234+1.234i 123.4 0.0+1.0i) -152.2756+152.2756i)+(num-test (/ 1.234+1.234i 123.4 0.0+1.0i) 0.01-0.01i)+(num-test (= 1.234+1.234i 123.4 0.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1234/11 1) 114.41581818181818+1.234i)+(num-test (- 1.234+1.234i 1234/11 1) -111.94781818181818+1.234i)+(num-test (* 1.234+1.234i 1234/11 1) 138.43236363636365+138.43236363636365i)+(num-test (/ 1.234+1.234i 1234/11 1) 0.011+0.011i)+(num-test (= 1.234+1.234i 1234/11 1) #f)+(num-test (+ 1.234+1.234i 1234/11 1.0) 114.41581818181818+1.234i)+(num-test (- 1.234+1.234i 1234/11 1.0) -111.94781818181818+1.234i)+(num-test (* 1.234+1.234i 1234/11 1.0) 138.43236363636365+138.43236363636365i)+(num-test (/ 1.234+1.234i 1234/11 1.0) 0.011+0.011i)+(num-test (= 1.234+1.234i 1234/11 1.0) #f)+(num-test (+ 1.234+1.234i 1234/11 1/1) 114.41581818181818+1.234i)+(num-test (- 1.234+1.234i 1234/11 1/1) -111.94781818181818+1.234i)+(num-test (* 1.234+1.234i 1234/11 1/1) 138.43236363636365+138.43236363636365i)+(num-test (/ 1.234+1.234i 1234/11 1/1) 0.011+0.011i)+(num-test (= 1.234+1.234i 1234/11 1/1) #f)+(num-test (+ 1.234+1.234i 1234/11 1.0+1.0i) 114.41581818181818+2.234i)+(num-test (- 1.234+1.234i 1234/11 1.0+1.0i) -111.94781818181818+0.234i)+(num-test (* 1.234+1.234i 1234/11 1.0+1.0i) 0.0+276.86472727272729i)+(num-test (/ 1.234+1.234i 1234/11 1.0+1.0i) 0.011)+(num-test (= 1.234+1.234i 1234/11 1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1234/11 0) 113.41581818181818+1.234i)+(num-test (- 1.234+1.234i 1234/11 0) -110.94781818181818+1.234i)+(num-test (* 1.234+1.234i 1234/11 0) 0.0)+(num-test (+ 1.234+1.234i 1234/11 0.0) 113.41581818181818+1.234i)+(num-test (- 1.234+1.234i 1234/11 0.0) -110.94781818181818+1.234i)+(num-test (* 1.234+1.234i 1234/11 0.0) 0.0)+(num-test (+ 1.234+1.234i 1234/11 1234) 1347.41581818181817+1.234i)+(num-test (- 1.234+1.234i 1234/11 1234) -1344.94781818181809+1.234i)+(num-test (* 1.234+1.234i 1234/11 1234) 170825.53672727273079+170825.53672727273079i)+(num-test (/ 1.234+1.234i 1234/11 1234) 0.00000891410049+0.00000891410049i)+(num-test (= 1.234+1.234i 1234/11 1234) #f)+(num-test (+ 1.234+1.234i 1234/11 123.4) 236.81581818181820+1.234i)+(num-test (- 1.234+1.234i 1234/11 123.4) -234.34781818181818+1.234i)+(num-test (* 1.234+1.234i 1234/11 123.4) 17082.55367272727381+17082.55367272727381i)+(num-test (/ 1.234+1.234i 1234/11 123.4) 0.00008914100486+0.00008914100486i)+(num-test (= 1.234+1.234i 1234/11 123.4) #f)+(num-test (+ 1.234+1.234i 1234/11 1234/11) 225.59763636363635+1.234i)+(num-test (- 1.234+1.234i 1234/11 1234/11) -223.12963636363637+1.234i)+(num-test (* 1.234+1.234i 1234/11 1234/11) 15529.59424793388644+15529.59424793388644i)+(num-test (/ 1.234+1.234i 1234/11 1234/11) 0.00009805510535+0.00009805510535i)+(num-test (= 1.234+1.234i 1234/11 1234/11) #f)+(num-test (+ 1.234+1.234i 1234/11 1.234+1.234i) 114.64981818181818+2.468i)+(num-test (- 1.234+1.234i 1234/11 1.234+1.234i) -112.18181818181817)+(num-test (* 1.234+1.234i 1234/11 1.234+1.234i) 0.0+341.65107345454550i)+(num-test (/ 1.234+1.234i 1234/11 1.234+1.234i) 0.00891410048622)+(num-test (= 1.234+1.234i 1234/11 1.234+1.234i) #f)+(num-test (+ 1.234+1.234i 1234/11 -1.0+1.0i) 112.41581818181818+2.234i)+(num-test (- 1.234+1.234i 1234/11 -1.0+1.0i) -109.94781818181818+0.234i)+(num-test (* 1.234+1.234i 1234/11 -1.0+1.0i) -276.86472727272729)+(num-test (/ 1.234+1.234i 1234/11 -1.0+1.0i) -0.0-0.011i)+(num-test (= 1.234+1.234i 1234/11 -1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1234/11 0.0+1.0i) 113.41581818181818+2.234i)+(num-test (- 1.234+1.234i 1234/11 0.0+1.0i) -110.94781818181818+0.234i)+(num-test (* 1.234+1.234i 1234/11 0.0+1.0i) -138.43236363636365+138.43236363636365i)+(num-test (/ 1.234+1.234i 1234/11 0.0+1.0i) 0.011-0.011i)+(num-test (= 1.234+1.234i 1234/11 0.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1.234+1.234i 1) 3.468+2.468i)+(num-test (- 1.234+1.234i 1.234+1.234i 1) -1.0)+(num-test (* 1.234+1.234i 1.234+1.234i 1) 0.0+3.04551200000000i)+(num-test (/ 1.234+1.234i 1.234+1.234i 1) 1.0)+(num-test (= 1.234+1.234i 1.234+1.234i 1) #f)+(num-test (+ 1.234+1.234i 1.234+1.234i 1.0) 3.468+2.468i)+(num-test (- 1.234+1.234i 1.234+1.234i 1.0) -1.0)+(num-test (* 1.234+1.234i 1.234+1.234i 1.0) 0.0+3.04551200000000i)+(num-test (/ 1.234+1.234i 1.234+1.234i 1.0) 1.0)+(num-test (= 1.234+1.234i 1.234+1.234i 1.0) #f)+(num-test (+ 1.234+1.234i 1.234+1.234i 1/1) 3.468+2.468i)+(num-test (- 1.234+1.234i 1.234+1.234i 1/1) -1.0)+(num-test (* 1.234+1.234i 1.234+1.234i 1/1) 0.0+3.04551200000000i)+(num-test (/ 1.234+1.234i 1.234+1.234i 1/1) 1.0)+(num-test (= 1.234+1.234i 1.234+1.234i 1/1) #f)+(num-test (+ 1.234+1.234i 1.234+1.234i 1.0+1.0i) 3.468+3.468i)+(num-test (- 1.234+1.234i 1.234+1.234i 1.0+1.0i) -1.0-1.0i)+(num-test (* 1.234+1.234i 1.234+1.234i 1.0+1.0i) -3.04551200000000+3.04551200000000i)+(num-test (/ 1.234+1.234i 1.234+1.234i 1.0+1.0i) 0.5-0.5i)+(num-test (= 1.234+1.234i 1.234+1.234i 1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1.234+1.234i 0) 2.468+2.468i)+(num-test (- 1.234+1.234i 1.234+1.234i 0) 0.0)+(num-test (* 1.234+1.234i 1.234+1.234i 0) 0.0)+(num-test (+ 1.234+1.234i 1.234+1.234i 0.0) 2.468+2.468i)+(num-test (- 1.234+1.234i 1.234+1.234i 0.0) 0.0)+(num-test (* 1.234+1.234i 1.234+1.234i 0.0) 0.0)+(num-test (+ 1.234+1.234i 1.234+1.234i 1234) 1236.46800000000007+2.468i)+(num-test (- 1.234+1.234i 1.234+1.234i 1234) -1234.0)+(num-test (* 1.234+1.234i 1.234+1.234i 1234) 0.0+3758.16180799999984i)+(num-test (/ 1.234+1.234i 1.234+1.234i 1234) 0.00081037277147)+(num-test (= 1.234+1.234i 1.234+1.234i 1234) #f)+(num-test (+ 1.234+1.234i 1.234+1.234i 123.4) 125.86800000000001+2.468i)+(num-test (- 1.234+1.234i 1.234+1.234i 123.4) -123.4)+(num-test (* 1.234+1.234i 1.234+1.234i 123.4) 0.0+375.81618080000004i)+(num-test (/ 1.234+1.234i 1.234+1.234i 123.4) 0.00810372771475)+(num-test (= 1.234+1.234i 1.234+1.234i 123.4) #f)+(num-test (+ 1.234+1.234i 1.234+1.234i 1234/11) 114.64981818181818+2.468i)+(num-test (- 1.234+1.234i 1.234+1.234i 1234/11) -112.18181818181819)+(num-test (* 1.234+1.234i 1.234+1.234i 1234/11) 0.0+341.65107345454550i)+(num-test (/ 1.234+1.234i 1.234+1.234i 1234/11) 0.00891410048622)+(num-test (= 1.234+1.234i 1.234+1.234i 1234/11) #f)+(num-test (+ 1.234+1.234i 1.234+1.234i 1.234+1.234i) 3.70200000000000+3.70200000000000i)+(num-test (- 1.234+1.234i 1.234+1.234i 1.234+1.234i) -1.234-1.234i)+(num-test (* 1.234+1.234i 1.234+1.234i 1.234+1.234i) -3.75816180800000+3.75816180800000i)+(num-test (/ 1.234+1.234i 1.234+1.234i 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 1.234+1.234i 1.234+1.234i 1.234+1.234i) #t)+(num-test (+ 1.234+1.234i 1.234+1.234i -1.0+1.0i) 1.468+3.468i)+(num-test (- 1.234+1.234i 1.234+1.234i -1.0+1.0i) 1.0-1.0i)+(num-test (* 1.234+1.234i 1.234+1.234i -1.0+1.0i) -3.04551200000000-3.04551200000000i)+(num-test (/ 1.234+1.234i 1.234+1.234i -1.0+1.0i) -0.5-0.5i)+(num-test (= 1.234+1.234i 1.234+1.234i -1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 1.234+1.234i 0.0+1.0i) 2.468+3.468i)+(num-test (- 1.234+1.234i 1.234+1.234i 0.0+1.0i) 0.0-1.0i)+(num-test (* 1.234+1.234i 1.234+1.234i 0.0+1.0i) -3.04551200000000)+(num-test (/ 1.234+1.234i 1.234+1.234i 0.0+1.0i) 0.0-1.0i)+(num-test (= 1.234+1.234i 1.234+1.234i 0.0+1.0i) #f)+(num-test (+ 1.234+1.234i -1.0+1.0i 1) 1.234+2.234i)+(num-test (- 1.234+1.234i -1.0+1.0i 1) 1.234+0.234i)+(num-test (* 1.234+1.234i -1.0+1.0i 1) -2.468)+(num-test (/ 1.234+1.234i -1.0+1.0i 1) -0.0-1.234i)+(num-test (= 1.234+1.234i -1.0+1.0i 1) #f)+(num-test (+ 1.234+1.234i -1.0+1.0i 1.0) 1.234+2.234i)+(num-test (- 1.234+1.234i -1.0+1.0i 1.0) 1.234+0.234i)+(num-test (* 1.234+1.234i -1.0+1.0i 1.0) -2.468)+(num-test (/ 1.234+1.234i -1.0+1.0i 1.0) -0.0-1.234i)+(num-test (= 1.234+1.234i -1.0+1.0i 1.0) #f)+(num-test (+ 1.234+1.234i -1.0+1.0i 1/1) 1.234+2.234i)+(num-test (- 1.234+1.234i -1.0+1.0i 1/1) 1.234+0.234i)+(num-test (* 1.234+1.234i -1.0+1.0i 1/1) -2.468)+(num-test (/ 1.234+1.234i -1.0+1.0i 1/1) -0.0-1.234i)+(num-test (= 1.234+1.234i -1.0+1.0i 1/1) #f)+(num-test (+ 1.234+1.234i -1.0+1.0i 1.0+1.0i) 1.234+3.234i)+(num-test (- 1.234+1.234i -1.0+1.0i 1.0+1.0i) 1.234-0.766i)+(num-test (* 1.234+1.234i -1.0+1.0i 1.0+1.0i) -2.468-2.468i)+(num-test (/ 1.234+1.234i -1.0+1.0i 1.0+1.0i) -0.617-0.617i)+(num-test (= 1.234+1.234i -1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1.234+1.234i -1.0+1.0i 0) 0.234+2.234i)+(num-test (- 1.234+1.234i -1.0+1.0i 0) 2.234+0.234i)+(num-test (* 1.234+1.234i -1.0+1.0i 0) -0.0)+(num-test (+ 1.234+1.234i -1.0+1.0i 0.0) 0.234+2.234i)+(num-test (- 1.234+1.234i -1.0+1.0i 0.0) 2.234+0.234i)+(num-test (* 1.234+1.234i -1.0+1.0i 0.0) -0.0)+(num-test (+ 1.234+1.234i -1.0+1.0i 1234) 1234.23399999999992+2.234i)+(num-test (- 1.234+1.234i -1.0+1.0i 1234) -1231.766+0.234i)+(num-test (* 1.234+1.234i -1.0+1.0i 1234) -3045.51200000000017)+(num-test (/ 1.234+1.234i -1.0+1.0i 1234) -0.0-0.001i)+(num-test (= 1.234+1.234i -1.0+1.0i 1234) #f)+(num-test (+ 1.234+1.234i -1.0+1.0i 123.4) 123.634+2.234i)+(num-test (- 1.234+1.234i -1.0+1.0i 123.4) -121.16600000000001+0.234i)+(num-test (* 1.234+1.234i -1.0+1.0i 123.4) -304.55119999999999)+(num-test (/ 1.234+1.234i -1.0+1.0i 123.4) -0.0-0.01i)+(num-test (= 1.234+1.234i -1.0+1.0i 123.4) #f)+(num-test (+ 1.234+1.234i -1.0+1.0i 1234/11) 112.41581818181818+2.234i)+(num-test (- 1.234+1.234i -1.0+1.0i 1234/11) -109.94781818181818+0.234i)+(num-test (* 1.234+1.234i -1.0+1.0i 1234/11) -276.86472727272729)+(num-test (/ 1.234+1.234i -1.0+1.0i 1234/11) -0.0-0.011i)+(num-test (= 1.234+1.234i -1.0+1.0i 1234/11) #f)+(num-test (+ 1.234+1.234i -1.0+1.0i 1.234+1.234i) 1.468+3.468i)+(num-test (- 1.234+1.234i -1.0+1.0i 1.234+1.234i) 1.0-1.0i)+(num-test (* 1.234+1.234i -1.0+1.0i 1.234+1.234i) -3.04551200000000-3.04551200000000i)+(num-test (/ 1.234+1.234i -1.0+1.0i 1.234+1.234i) -0.5-0.5i)+(num-test (= 1.234+1.234i -1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1.234+1.234i -1.0+1.0i -1.0+1.0i) -0.766+3.234i)+(num-test (- 1.234+1.234i -1.0+1.0i -1.0+1.0i) 3.234-0.766i)+(num-test (* 1.234+1.234i -1.0+1.0i -1.0+1.0i) 2.468-2.468i)+(num-test (/ 1.234+1.234i -1.0+1.0i -1.0+1.0i) -0.617+0.617i)+(num-test (= 1.234+1.234i -1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1.234+1.234i -1.0+1.0i 0.0+1.0i) 0.234+3.234i)+(num-test (- 1.234+1.234i -1.0+1.0i 0.0+1.0i) 2.234-0.766i)+(num-test (* 1.234+1.234i -1.0+1.0i 0.0+1.0i) -0.0-2.468i)+(num-test (/ 1.234+1.234i -1.0+1.0i 0.0+1.0i) -1.234)+(num-test (= 1.234+1.234i -1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 1.234+1.234i 0.0+1.0i 1) 2.234+2.234i)+(num-test (- 1.234+1.234i 0.0+1.0i 1) 0.234+0.234i)+(num-test (* 1.234+1.234i 0.0+1.0i 1) -1.234+1.234i)+(num-test (/ 1.234+1.234i 0.0+1.0i 1) 1.234-1.234i)+(num-test (= 1.234+1.234i 0.0+1.0i 1) #f)+(num-test (+ 1.234+1.234i 0.0+1.0i 1.0) 2.234+2.234i)+(num-test (- 1.234+1.234i 0.0+1.0i 1.0) 0.234+0.234i)+(num-test (* 1.234+1.234i 0.0+1.0i 1.0) -1.234+1.234i)+(num-test (/ 1.234+1.234i 0.0+1.0i 1.0) 1.234-1.234i)+(num-test (= 1.234+1.234i 0.0+1.0i 1.0) #f)+(num-test (+ 1.234+1.234i 0.0+1.0i 1/1) 2.234+2.234i)+(num-test (- 1.234+1.234i 0.0+1.0i 1/1) 0.234+0.234i)+(num-test (* 1.234+1.234i 0.0+1.0i 1/1) -1.234+1.234i)+(num-test (/ 1.234+1.234i 0.0+1.0i 1/1) 1.234-1.234i)+(num-test (= 1.234+1.234i 0.0+1.0i 1/1) #f)+(num-test (+ 1.234+1.234i 0.0+1.0i 1.0+1.0i) 2.234+3.234i)+(num-test (- 1.234+1.234i 0.0+1.0i 1.0+1.0i) 0.234-0.766i)+(num-test (* 1.234+1.234i 0.0+1.0i 1.0+1.0i) -2.468)+(num-test (/ 1.234+1.234i 0.0+1.0i 1.0+1.0i) 0.0-1.234i)+(num-test (= 1.234+1.234i 0.0+1.0i 1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 0.0+1.0i 0) 1.234+2.234i)+(num-test (- 1.234+1.234i 0.0+1.0i 0) 1.234+0.234i)+(num-test (* 1.234+1.234i 0.0+1.0i 0) -0.0)+(num-test (+ 1.234+1.234i 0.0+1.0i 0.0) 1.234+2.234i)+(num-test (- 1.234+1.234i 0.0+1.0i 0.0) 1.234+0.234i)+(num-test (* 1.234+1.234i 0.0+1.0i 0.0) -0.0)+(num-test (+ 1.234+1.234i 0.0+1.0i 1234) 1235.23399999999992+2.234i)+(num-test (- 1.234+1.234i 0.0+1.0i 1234) -1232.766+0.234i)+(num-test (* 1.234+1.234i 0.0+1.0i 1234) -1522.756+1522.756i)+(num-test (/ 1.234+1.234i 0.0+1.0i 1234) 0.001-0.001i)+(num-test (= 1.234+1.234i 0.0+1.0i 1234) #f)+(num-test (+ 1.234+1.234i 0.0+1.0i 123.4) 124.634+2.234i)+(num-test (- 1.234+1.234i 0.0+1.0i 123.4) -122.16600000000001+0.234i)+(num-test (* 1.234+1.234i 0.0+1.0i 123.4) -152.2756+152.2756i)+(num-test (/ 1.234+1.234i 0.0+1.0i 123.4) 0.01-0.01i)+(num-test (= 1.234+1.234i 0.0+1.0i 123.4) #f)+(num-test (+ 1.234+1.234i 0.0+1.0i 1234/11) 113.41581818181818+2.234i)+(num-test (- 1.234+1.234i 0.0+1.0i 1234/11) -110.94781818181818+0.234i)+(num-test (* 1.234+1.234i 0.0+1.0i 1234/11) -138.43236363636365+138.43236363636365i)+(num-test (/ 1.234+1.234i 0.0+1.0i 1234/11) 0.011-0.011i)+(num-test (= 1.234+1.234i 0.0+1.0i 1234/11) #f)+(num-test (+ 1.234+1.234i 0.0+1.0i 1.234+1.234i) 2.468+3.468i)+(num-test (- 1.234+1.234i 0.0+1.0i 1.234+1.234i) 0.0-1.0i)+(num-test (* 1.234+1.234i 0.0+1.0i 1.234+1.234i) -3.04551200000000)+(num-test (/ 1.234+1.234i 0.0+1.0i 1.234+1.234i) 0.0-1.0i)+(num-test (= 1.234+1.234i 0.0+1.0i 1.234+1.234i) #f)+(num-test (+ 1.234+1.234i 0.0+1.0i -1.0+1.0i) 0.234+3.234i)+(num-test (- 1.234+1.234i 0.0+1.0i -1.0+1.0i) 2.234-0.766i)+(num-test (* 1.234+1.234i 0.0+1.0i -1.0+1.0i) 0.0-2.468i)+(num-test (/ 1.234+1.234i 0.0+1.0i -1.0+1.0i) -1.234)+(num-test (= 1.234+1.234i 0.0+1.0i -1.0+1.0i) #f)+(num-test (+ 1.234+1.234i 0.0+1.0i 0.0+1.0i) 1.234+3.234i)+(num-test (- 1.234+1.234i 0.0+1.0i 0.0+1.0i) 1.234-0.766i)+(num-test (* 1.234+1.234i 0.0+1.0i 0.0+1.0i) -1.234-1.234i)+(num-test (/ 1.234+1.234i 0.0+1.0i 0.0+1.0i) -1.234-1.234i)+(num-test (= 1.234+1.234i 0.0+1.0i 0.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1 1) 1.0+1.0i)+(num-test (- -1.0+1.0i 1 1) -3.0+1.0i)+(num-test (* -1.0+1.0i 1 1) -1.0+1.0i)+(num-test (/ -1.0+1.0i 1 1) -1.0+1.0i)+(num-test (= -1.0+1.0i 1 1) #f)+(num-test (+ -1.0+1.0i 1 1.0) 1.0+1.0i)+(num-test (- -1.0+1.0i 1 1.0) -3.0+1.0i)+(num-test (* -1.0+1.0i 1 1.0) -1.0+1.0i)+(num-test (/ -1.0+1.0i 1 1.0) -1.0+1.0i)+(num-test (= -1.0+1.0i 1 1.0) #f)+(num-test (+ -1.0+1.0i 1 1/1) 1.0+1.0i)+(num-test (- -1.0+1.0i 1 1/1) -3.0+1.0i)+(num-test (* -1.0+1.0i 1 1/1) -1.0+1.0i)+(num-test (/ -1.0+1.0i 1 1/1) -1.0+1.0i)+(num-test (= -1.0+1.0i 1 1/1) #f)+(num-test (+ -1.0+1.0i 1 1.0+1.0i) 1.0+2.0i)+(num-test (- -1.0+1.0i 1 1.0+1.0i) -3.0)+(num-test (* -1.0+1.0i 1 1.0+1.0i) -2.0)+(num-test (/ -1.0+1.0i 1 1.0+1.0i) 0.0+1.0i)+(num-test (= -1.0+1.0i 1 1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1 0) 0.0+1.0i)+(num-test (- -1.0+1.0i 1 0) -2.0+1.0i)+(num-test (* -1.0+1.0i 1 0) -0.0)+(num-test (+ -1.0+1.0i 1 0.0) 0.0+1.0i)+(num-test (- -1.0+1.0i 1 0.0) -2.0+1.0i)+(num-test (* -1.0+1.0i 1 0.0) -0.0)+(num-test (+ -1.0+1.0i 1 1234) 1234.0+1.0i)+(num-test (- -1.0+1.0i 1 1234) -1236.0+1.0i)+(num-test (* -1.0+1.0i 1 1234) -1234.0+1234.0i)+(num-test (/ -1.0+1.0i 1 1234) -0.00081037277147+0.00081037277147i)+(num-test (= -1.0+1.0i 1 1234) #f)+(num-test (+ -1.0+1.0i 1 123.4) 123.4+1.0i)+(num-test (- -1.0+1.0i 1 123.4) -125.4+1.0i)+(num-test (* -1.0+1.0i 1 123.4) -123.4+123.4i)+(num-test (/ -1.0+1.0i 1 123.4) -0.00810372771475+0.00810372771475i)+(num-test (= -1.0+1.0i 1 123.4) #f)+(num-test (+ -1.0+1.0i 1 1234/11) 112.18181818181819+1.0i)+(num-test (- -1.0+1.0i 1 1234/11) -114.18181818181819+1.0i)+(num-test (* -1.0+1.0i 1 1234/11) -112.18181818181819+112.18181818181819i)+(num-test (/ -1.0+1.0i 1 1234/11) -0.00891410048622+0.00891410048622i)+(num-test (= -1.0+1.0i 1 1234/11) #f)+(num-test (+ -1.0+1.0i 1 1.234+1.234i) 1.234+2.234i)+(num-test (- -1.0+1.0i 1 1.234+1.234i) -3.234-0.234i)+(num-test (* -1.0+1.0i 1 1.234+1.234i) -2.468)+(num-test (/ -1.0+1.0i 1 1.234+1.234i) 0.0+0.81037277147488i)+(num-test (= -1.0+1.0i 1 1.234+1.234i) #f)+(num-test (+ -1.0+1.0i 1 -1.0+1.0i) -1.0+2.0i)+(num-test (- -1.0+1.0i 1 -1.0+1.0i) -1.0)+(num-test (* -1.0+1.0i 1 -1.0+1.0i) 0.0-2.0i)+(num-test (/ -1.0+1.0i 1 -1.0+1.0i) 1.0)+(num-test (= -1.0+1.0i 1 -1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1 0.0+1.0i) 0.0+2.0i)+(num-test (- -1.0+1.0i 1 0.0+1.0i) -2.0)+(num-test (* -1.0+1.0i 1 0.0+1.0i) -1.0-1.0i)+(num-test (/ -1.0+1.0i 1 0.0+1.0i) 1.0+1.0i)+(num-test (= -1.0+1.0i 1 0.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1.0 1) 1.0+1.0i)+(num-test (- -1.0+1.0i 1.0 1) -3.0+1.0i)+(num-test (* -1.0+1.0i 1.0 1) -1.0+1.0i)+(num-test (/ -1.0+1.0i 1.0 1) -1.0+1.0i)+(num-test (= -1.0+1.0i 1.0 1) #f)+(num-test (+ -1.0+1.0i 1.0 1.0) 1.0+1.0i)+(num-test (- -1.0+1.0i 1.0 1.0) -3.0+1.0i)+(num-test (* -1.0+1.0i 1.0 1.0) -1.0+1.0i)+(num-test (/ -1.0+1.0i 1.0 1.0) -1.0+1.0i)+(num-test (= -1.0+1.0i 1.0 1.0) #f)+(num-test (+ -1.0+1.0i 1.0 1/1) 1.0+1.0i)+(num-test (- -1.0+1.0i 1.0 1/1) -3.0+1.0i)+(num-test (* -1.0+1.0i 1.0 1/1) -1.0+1.0i)+(num-test (/ -1.0+1.0i 1.0 1/1) -1.0+1.0i)+(num-test (= -1.0+1.0i 1.0 1/1) #f)+(num-test (+ -1.0+1.0i 1.0 1.0+1.0i) 1.0+2.0i)+(num-test (- -1.0+1.0i 1.0 1.0+1.0i) -3.0)+(num-test (* -1.0+1.0i 1.0 1.0+1.0i) -2.0)+(num-test (/ -1.0+1.0i 1.0 1.0+1.0i) 0.0+1.0i)+(num-test (= -1.0+1.0i 1.0 1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1.0 0) 0.0+1.0i)+(num-test (- -1.0+1.0i 1.0 0) -2.0+1.0i)+(num-test (* -1.0+1.0i 1.0 0) -0.0)+(num-test (+ -1.0+1.0i 1.0 0.0) 0.0+1.0i)+(num-test (- -1.0+1.0i 1.0 0.0) -2.0+1.0i)+(num-test (* -1.0+1.0i 1.0 0.0) -0.0)+(num-test (+ -1.0+1.0i 1.0 1234) 1234.0+1.0i)+(num-test (- -1.0+1.0i 1.0 1234) -1236.0+1.0i)+(num-test (* -1.0+1.0i 1.0 1234) -1234.0+1234.0i)+(num-test (/ -1.0+1.0i 1.0 1234) -0.00081037277147+0.00081037277147i)+(num-test (= -1.0+1.0i 1.0 1234) #f)+(num-test (+ -1.0+1.0i 1.0 123.4) 123.4+1.0i)+(num-test (- -1.0+1.0i 1.0 123.4) -125.4+1.0i)+(num-test (* -1.0+1.0i 1.0 123.4) -123.4+123.4i)+(num-test (/ -1.0+1.0i 1.0 123.4) -0.00810372771475+0.00810372771475i)+(num-test (= -1.0+1.0i 1.0 123.4) #f)+(num-test (+ -1.0+1.0i 1.0 1234/11) 112.18181818181819+1.0i)+(num-test (- -1.0+1.0i 1.0 1234/11) -114.18181818181819+1.0i)+(num-test (* -1.0+1.0i 1.0 1234/11) -112.18181818181819+112.18181818181819i)+(num-test (/ -1.0+1.0i 1.0 1234/11) -0.00891410048622+0.00891410048622i)+(num-test (= -1.0+1.0i 1.0 1234/11) #f)+(num-test (+ -1.0+1.0i 1.0 1.234+1.234i) 1.234+2.234i)+(num-test (- -1.0+1.0i 1.0 1.234+1.234i) -3.234-0.234i)+(num-test (* -1.0+1.0i 1.0 1.234+1.234i) -2.468)+(num-test (/ -1.0+1.0i 1.0 1.234+1.234i) 0.0+0.81037277147488i)+(num-test (= -1.0+1.0i 1.0 1.234+1.234i) #f)+(num-test (+ -1.0+1.0i 1.0 -1.0+1.0i) -1.0+2.0i)+(num-test (- -1.0+1.0i 1.0 -1.0+1.0i) -1.0)+(num-test (* -1.0+1.0i 1.0 -1.0+1.0i) 0.0-2.0i)+(num-test (/ -1.0+1.0i 1.0 -1.0+1.0i) 1.0)+(num-test (= -1.0+1.0i 1.0 -1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1.0 0.0+1.0i) 0.0+2.0i)+(num-test (- -1.0+1.0i 1.0 0.0+1.0i) -2.0)+(num-test (* -1.0+1.0i 1.0 0.0+1.0i) -1.0-1.0i)+(num-test (/ -1.0+1.0i 1.0 0.0+1.0i) 1.0+1.0i)+(num-test (= -1.0+1.0i 1.0 0.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1/1 1) 1.0+1.0i)+(num-test (- -1.0+1.0i 1/1 1) -3.0+1.0i)+(num-test (* -1.0+1.0i 1/1 1) -1.0+1.0i)+(num-test (/ -1.0+1.0i 1/1 1) -1.0+1.0i)+(num-test (= -1.0+1.0i 1/1 1) #f)+(num-test (+ -1.0+1.0i 1/1 1.0) 1.0+1.0i)+(num-test (- -1.0+1.0i 1/1 1.0) -3.0+1.0i)+(num-test (* -1.0+1.0i 1/1 1.0) -1.0+1.0i)+(num-test (/ -1.0+1.0i 1/1 1.0) -1.0+1.0i)+(num-test (= -1.0+1.0i 1/1 1.0) #f)+(num-test (+ -1.0+1.0i 1/1 1/1) 1.0+1.0i)+(num-test (- -1.0+1.0i 1/1 1/1) -3.0+1.0i)+(num-test (* -1.0+1.0i 1/1 1/1) -1.0+1.0i)+(num-test (/ -1.0+1.0i 1/1 1/1) -1.0+1.0i)+(num-test (= -1.0+1.0i 1/1 1/1) #f)+(num-test (+ -1.0+1.0i 1/1 1.0+1.0i) 1.0+2.0i)+(num-test (- -1.0+1.0i 1/1 1.0+1.0i) -3.0)+(num-test (* -1.0+1.0i 1/1 1.0+1.0i) -2.0)+(num-test (/ -1.0+1.0i 1/1 1.0+1.0i) 0.0+1.0i)+(num-test (= -1.0+1.0i 1/1 1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1/1 0) 0.0+1.0i)+(num-test (- -1.0+1.0i 1/1 0) -2.0+1.0i)+(num-test (* -1.0+1.0i 1/1 0) -0.0)+(num-test (+ -1.0+1.0i 1/1 0.0) 0.0+1.0i)+(num-test (- -1.0+1.0i 1/1 0.0) -2.0+1.0i)+(num-test (* -1.0+1.0i 1/1 0.0) -0.0)+(num-test (+ -1.0+1.0i 1/1 1234) 1234.0+1.0i)+(num-test (- -1.0+1.0i 1/1 1234) -1236.0+1.0i)+(num-test (* -1.0+1.0i 1/1 1234) -1234.0+1234.0i)+(num-test (/ -1.0+1.0i 1/1 1234) -0.00081037277147+0.00081037277147i)+(num-test (= -1.0+1.0i 1/1 1234) #f)+(num-test (+ -1.0+1.0i 1/1 123.4) 123.4+1.0i)+(num-test (- -1.0+1.0i 1/1 123.4) -125.4+1.0i)+(num-test (* -1.0+1.0i 1/1 123.4) -123.4+123.4i)+(num-test (/ -1.0+1.0i 1/1 123.4) -0.00810372771475+0.00810372771475i)+(num-test (= -1.0+1.0i 1/1 123.4) #f)+(num-test (+ -1.0+1.0i 1/1 1234/11) 112.18181818181819+1.0i)+(num-test (- -1.0+1.0i 1/1 1234/11) -114.18181818181819+1.0i)+(num-test (* -1.0+1.0i 1/1 1234/11) -112.18181818181819+112.18181818181819i)+(num-test (/ -1.0+1.0i 1/1 1234/11) -0.00891410048622+0.00891410048622i)+(num-test (= -1.0+1.0i 1/1 1234/11) #f)+(num-test (+ -1.0+1.0i 1/1 1.234+1.234i) 1.234+2.234i)+(num-test (- -1.0+1.0i 1/1 1.234+1.234i) -3.234-0.234i)+(num-test (* -1.0+1.0i 1/1 1.234+1.234i) -2.468)+(num-test (/ -1.0+1.0i 1/1 1.234+1.234i) 0.0+0.81037277147488i)+(num-test (= -1.0+1.0i 1/1 1.234+1.234i) #f)+(num-test (+ -1.0+1.0i 1/1 -1.0+1.0i) -1.0+2.0i)+(num-test (- -1.0+1.0i 1/1 -1.0+1.0i) -1.0)+(num-test (* -1.0+1.0i 1/1 -1.0+1.0i) 0.0-2.0i)+(num-test (/ -1.0+1.0i 1/1 -1.0+1.0i) 1.0)+(num-test (= -1.0+1.0i 1/1 -1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1/1 0.0+1.0i) 0.0+2.0i)+(num-test (- -1.0+1.0i 1/1 0.0+1.0i) -2.0)+(num-test (* -1.0+1.0i 1/1 0.0+1.0i) -1.0-1.0i)+(num-test (/ -1.0+1.0i 1/1 0.0+1.0i) 1.0+1.0i)+(num-test (= -1.0+1.0i 1/1 0.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1.0+1.0i 1) 1.0+2.0i)+(num-test (- -1.0+1.0i 1.0+1.0i 1) -3.0)+(num-test (* -1.0+1.0i 1.0+1.0i 1) -2.0)+(num-test (/ -1.0+1.0i 1.0+1.0i 1) 0.0+1.0i)+(num-test (= -1.0+1.0i 1.0+1.0i 1) #f)+(num-test (+ -1.0+1.0i 1.0+1.0i 1.0) 1.0+2.0i)+(num-test (- -1.0+1.0i 1.0+1.0i 1.0) -3.0)+(num-test (* -1.0+1.0i 1.0+1.0i 1.0) -2.0)+(num-test (/ -1.0+1.0i 1.0+1.0i 1.0) 0.0+1.0i)+(num-test (= -1.0+1.0i 1.0+1.0i 1.0) #f)+(num-test (+ -1.0+1.0i 1.0+1.0i 1/1) 1.0+2.0i)+(num-test (- -1.0+1.0i 1.0+1.0i 1/1) -3.0)+(num-test (* -1.0+1.0i 1.0+1.0i 1/1) -2.0)+(num-test (/ -1.0+1.0i 1.0+1.0i 1/1) 0.0+1.0i)+(num-test (= -1.0+1.0i 1.0+1.0i 1/1) #f)+(num-test (+ -1.0+1.0i 1.0+1.0i 1.0+1.0i) 1.0+3.0i)+(num-test (- -1.0+1.0i 1.0+1.0i 1.0+1.0i) -3.0-1.0i)+(num-test (* -1.0+1.0i 1.0+1.0i 1.0+1.0i) -2.0-2.0i)+(num-test (/ -1.0+1.0i 1.0+1.0i 1.0+1.0i) 0.5+0.5i)+(num-test (= -1.0+1.0i 1.0+1.0i 1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1.0+1.0i 0) 0.0+2.0i)+(num-test (- -1.0+1.0i 1.0+1.0i 0) -2.0)+(num-test (* -1.0+1.0i 1.0+1.0i 0) -0.0)+(num-test (+ -1.0+1.0i 1.0+1.0i 0.0) 0.0+2.0i)+(num-test (- -1.0+1.0i 1.0+1.0i 0.0) -2.0)+(num-test (* -1.0+1.0i 1.0+1.0i 0.0) -0.0)+(num-test (+ -1.0+1.0i 1.0+1.0i 1234) 1234.0+2.0i)+(num-test (- -1.0+1.0i 1.0+1.0i 1234) -1236.0)+(num-test (* -1.0+1.0i 1.0+1.0i 1234) -2468.0)+(num-test (/ -1.0+1.0i 1.0+1.0i 1234) 0.0+0.00081037277147i)+(num-test (= -1.0+1.0i 1.0+1.0i 1234) #f)+(num-test (+ -1.0+1.0i 1.0+1.0i 123.4) 123.4+2.0i)+(num-test (- -1.0+1.0i 1.0+1.0i 123.4) -125.4)+(num-test (* -1.0+1.0i 1.0+1.0i 123.4) -246.8)+(num-test (/ -1.0+1.0i 1.0+1.0i 123.4) 0.0+0.00810372771475i)+(num-test (= -1.0+1.0i 1.0+1.0i 123.4) #f)+(num-test (+ -1.0+1.0i 1.0+1.0i 1234/11) 112.18181818181819+2.0i)+(num-test (- -1.0+1.0i 1.0+1.0i 1234/11) -114.18181818181819)+(num-test (* -1.0+1.0i 1.0+1.0i 1234/11) -224.36363636363637)+(num-test (/ -1.0+1.0i 1.0+1.0i 1234/11) 0.0+0.00891410048622i)+(num-test (= -1.0+1.0i 1.0+1.0i 1234/11) #f)+(num-test (+ -1.0+1.0i 1.0+1.0i 1.234+1.234i) 1.234+3.234i)+(num-test (- -1.0+1.0i 1.0+1.0i 1.234+1.234i) -3.234-1.234i)+(num-test (* -1.0+1.0i 1.0+1.0i 1.234+1.234i) -2.468-2.468i)+(num-test (/ -1.0+1.0i 1.0+1.0i 1.234+1.234i) 0.40518638573744+0.40518638573744i)+(num-test (= -1.0+1.0i 1.0+1.0i 1.234+1.234i) #f)+(num-test (+ -1.0+1.0i 1.0+1.0i -1.0+1.0i) -1.0+3.0i)+(num-test (- -1.0+1.0i 1.0+1.0i -1.0+1.0i) -1.0-1.0i)+(num-test (* -1.0+1.0i 1.0+1.0i -1.0+1.0i) 2.0-2.0i)+(num-test (/ -1.0+1.0i 1.0+1.0i -1.0+1.0i) 0.5-0.5i)+(num-test (= -1.0+1.0i 1.0+1.0i -1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1.0+1.0i 0.0+1.0i) 0.0+3.0i)+(num-test (- -1.0+1.0i 1.0+1.0i 0.0+1.0i) -2.0-1.0i)+(num-test (* -1.0+1.0i 1.0+1.0i 0.0+1.0i) -0.0-2.0i)+(num-test (/ -1.0+1.0i 1.0+1.0i 0.0+1.0i) 1.0)+(num-test (= -1.0+1.0i 1.0+1.0i 0.0+1.0i) #f)+(num-test (+ -1.0+1.0i 0 1) 0.0+1.0i)+(num-test (- -1.0+1.0i 0 1) -2.0+1.0i)+(num-test (* -1.0+1.0i 0 1) -0.0)+(num-test (+ -1.0+1.0i 0 1.0) 0.0+1.0i)+(num-test (- -1.0+1.0i 0 1.0) -2.0+1.0i)+(num-test (* -1.0+1.0i 0 1.0) -0.0)+(num-test (+ -1.0+1.0i 0 1/1) 0.0+1.0i)+(num-test (- -1.0+1.0i 0 1/1) -2.0+1.0i)+(num-test (* -1.0+1.0i 0 1/1) -0.0)+(num-test (+ -1.0+1.0i 0 1.0+1.0i) 0.0+2.0i)+(num-test (- -1.0+1.0i 0 1.0+1.0i) -2.0)+(num-test (* -1.0+1.0i 0 1.0+1.0i) -0.0)+(num-test (+ -1.0+1.0i 0 0) -1.0+1.0i)+(num-test (- -1.0+1.0i 0 0) -1.0+1.0i)+(num-test (* -1.0+1.0i 0 0) -0.0)+(num-test (+ -1.0+1.0i 0 0.0) -1.0+1.0i)+(num-test (- -1.0+1.0i 0 0.0) -1.0+1.0i)+(num-test (* -1.0+1.0i 0 0.0) -0.0)+(num-test (+ -1.0+1.0i 0 1234) 1233.0+1.0i)+(num-test (- -1.0+1.0i 0 1234) -1235.0+1.0i)+(num-test (* -1.0+1.0i 0 1234) -0.0)+(num-test (+ -1.0+1.0i 0 123.4) 122.4+1.0i)+(num-test (- -1.0+1.0i 0 123.4) -124.4+1.0i)+(num-test (* -1.0+1.0i 0 123.4) -0.0)+(num-test (+ -1.0+1.0i 0 1234/11) 111.18181818181819+1.0i)+(num-test (- -1.0+1.0i 0 1234/11) -113.18181818181819+1.0i)+(num-test (* -1.0+1.0i 0 1234/11) -0.0)+(num-test (+ -1.0+1.0i 0 1.234+1.234i) 0.234+2.234i)+(num-test (- -1.0+1.0i 0 1.234+1.234i) -2.234-0.234i)+(num-test (* -1.0+1.0i 0 1.234+1.234i) -0.0)+(num-test (+ -1.0+1.0i 0 -1.0+1.0i) -2.0+2.0i)+(num-test (- -1.0+1.0i 0 -1.0+1.0i) 0.0)+(num-test (* -1.0+1.0i 0 -1.0+1.0i) 0.0)+(num-test (+ -1.0+1.0i 0 0.0+1.0i) -1.0+2.0i)+(num-test (- -1.0+1.0i 0 0.0+1.0i) -1.0)+(num-test (* -1.0+1.0i 0 0.0+1.0i) -0.0)+(num-test (+ -1.0+1.0i 0.0 1) 0.0+1.0i)+(num-test (- -1.0+1.0i 0.0 1) -2.0+1.0i)+(num-test (* -1.0+1.0i 0.0 1) -0.0)+(num-test (+ -1.0+1.0i 0.0 1.0) 0.0+1.0i)+(num-test (- -1.0+1.0i 0.0 1.0) -2.0+1.0i)+(num-test (* -1.0+1.0i 0.0 1.0) -0.0)+(num-test (+ -1.0+1.0i 0.0 1/1) 0.0+1.0i)+(num-test (- -1.0+1.0i 0.0 1/1) -2.0+1.0i)+(num-test (* -1.0+1.0i 0.0 1/1) -0.0)+(num-test (+ -1.0+1.0i 0.0 1.0+1.0i) 0.0+2.0i)+(num-test (- -1.0+1.0i 0.0 1.0+1.0i) -2.0)+(num-test (* -1.0+1.0i 0.0 1.0+1.0i) -0.0)+(num-test (+ -1.0+1.0i 0.0 0) -1.0+1.0i)+(num-test (- -1.0+1.0i 0.0 0) -1.0+1.0i)+(num-test (* -1.0+1.0i 0.0 0) -0.0)+(num-test (+ -1.0+1.0i 0.0 0.0) -1.0+1.0i)+(num-test (- -1.0+1.0i 0.0 0.0) -1.0+1.0i)+(num-test (* -1.0+1.0i 0.0 0.0) -0.0)+(num-test (+ -1.0+1.0i 0.0 1234) 1233.0+1.0i)+(num-test (- -1.0+1.0i 0.0 1234) -1235.0+1.0i)+(num-test (* -1.0+1.0i 0.0 1234) -0.0)+(num-test (+ -1.0+1.0i 0.0 123.4) 122.4+1.0i)+(num-test (- -1.0+1.0i 0.0 123.4) -124.4+1.0i)+(num-test (* -1.0+1.0i 0.0 123.4) -0.0)+(num-test (+ -1.0+1.0i 0.0 1234/11) 111.18181818181819+1.0i)+(num-test (- -1.0+1.0i 0.0 1234/11) -113.18181818181819+1.0i)+(num-test (* -1.0+1.0i 0.0 1234/11) -0.0)+(num-test (+ -1.0+1.0i 0.0 1.234+1.234i) 0.234+2.234i)+(num-test (- -1.0+1.0i 0.0 1.234+1.234i) -2.234-0.234i)+(num-test (* -1.0+1.0i 0.0 1.234+1.234i) -0.0)+(num-test (+ -1.0+1.0i 0.0 -1.0+1.0i) -2.0+2.0i)+(num-test (- -1.0+1.0i 0.0 -1.0+1.0i) 0.0)+(num-test (* -1.0+1.0i 0.0 -1.0+1.0i) 0.0)+(num-test (+ -1.0+1.0i 0.0 0.0+1.0i) -1.0+2.0i)+(num-test (- -1.0+1.0i 0.0 0.0+1.0i) -1.0)+(num-test (* -1.0+1.0i 0.0 0.0+1.0i) -0.0)+(num-test (+ -1.0+1.0i 1234 1) 1234.0+1.0i)+(num-test (- -1.0+1.0i 1234 1) -1236.0+1.0i)+(num-test (* -1.0+1.0i 1234 1) -1234.0+1234.0i)+(num-test (/ -1.0+1.0i 1234 1) -0.00081037277147+0.00081037277147i)+(num-test (= -1.0+1.0i 1234 1) #f)+(num-test (+ -1.0+1.0i 1234 1.0) 1234.0+1.0i)+(num-test (- -1.0+1.0i 1234 1.0) -1236.0+1.0i)+(num-test (* -1.0+1.0i 1234 1.0) -1234.0+1234.0i)+(num-test (/ -1.0+1.0i 1234 1.0) -0.00081037277147+0.00081037277147i)+(num-test (= -1.0+1.0i 1234 1.0) #f)+(num-test (+ -1.0+1.0i 1234 1/1) 1234.0+1.0i)+(num-test (- -1.0+1.0i 1234 1/1) -1236.0+1.0i)+(num-test (* -1.0+1.0i 1234 1/1) -1234.0+1234.0i)+(num-test (/ -1.0+1.0i 1234 1/1) -0.00081037277147+0.00081037277147i)+(num-test (= -1.0+1.0i 1234 1/1) #f)+(num-test (+ -1.0+1.0i 1234 1.0+1.0i) 1234.0+2.0i)+(num-test (- -1.0+1.0i 1234 1.0+1.0i) -1236.0)+(num-test (* -1.0+1.0i 1234 1.0+1.0i) -2468.0)+(num-test (/ -1.0+1.0i 1234 1.0+1.0i) 0.0+0.00081037277147i)+(num-test (= -1.0+1.0i 1234 1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1234 0) 1233.0+1.0i)+(num-test (- -1.0+1.0i 1234 0) -1235.0+1.0i)+(num-test (* -1.0+1.0i 1234 0) -0.0)+(num-test (+ -1.0+1.0i 1234 0.0) 1233.0+1.0i)+(num-test (- -1.0+1.0i 1234 0.0) -1235.0+1.0i)+(num-test (* -1.0+1.0i 1234 0.0) -0.0)+(num-test (+ -1.0+1.0i 1234 1234) 2467.0+1.0i)+(num-test (- -1.0+1.0i 1234 1234) -2469.0+1.0i)+(num-test (* -1.0+1.0i 1234 1234) -1522756.0+1522756.0i)+(num-test (/ -1.0+1.0i 1234 1234) -0.00000065670403+0.00000065670403i)+(num-test (= -1.0+1.0i 1234 1234) #f)+(num-test (+ -1.0+1.0i 1234 123.4) 1356.4+1.0i)+(num-test (- -1.0+1.0i 1234 123.4) -1358.4+1.0i)+(num-test (* -1.0+1.0i 1234 123.4) -152275.60000000000582+152275.60000000000582i)+(num-test (/ -1.0+1.0i 1234 123.4) -0.00000656704029+0.00000656704029i)+(num-test (= -1.0+1.0i 1234 123.4) #f)+(num-test (+ -1.0+1.0i 1234 1234/11) 1345.18181818181824+1.0i)+(num-test (- -1.0+1.0i 1234 1234/11) -1347.18181818181824+1.0i)+(num-test (* -1.0+1.0i 1234 1234/11) -138432.36363636364695+138432.36363636364695i)+(num-test (/ -1.0+1.0i 1234 1234/11) -0.00000722374432+0.00000722374432i)+(num-test (= -1.0+1.0i 1234 1234/11) #f)+(num-test (+ -1.0+1.0i 1234 1.234+1.234i) 1234.23399999999992+2.234i)+(num-test (- -1.0+1.0i 1234 1.234+1.234i) -1236.23399999999992-0.234i)+(num-test (* -1.0+1.0i 1234 1.234+1.234i) -3045.51200000000017)+(num-test (/ -1.0+1.0i 1234 1.234+1.234i) 0.0+0.00065670402875i)+(num-test (= -1.0+1.0i 1234 1.234+1.234i) #f)+(num-test (+ -1.0+1.0i 1234 -1.0+1.0i) 1232.0+2.0i)+(num-test (- -1.0+1.0i 1234 -1.0+1.0i) -1234.0)+(num-test (* -1.0+1.0i 1234 -1.0+1.0i) 0.0-2468.0i)+(num-test (/ -1.0+1.0i 1234 -1.0+1.0i) 0.00081037277147)+(num-test (= -1.0+1.0i 1234 -1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1234 0.0+1.0i) 1233.0+2.0i)+(num-test (- -1.0+1.0i 1234 0.0+1.0i) -1235.0)+(num-test (* -1.0+1.0i 1234 0.0+1.0i) -1234.0-1234.0i)+(num-test (/ -1.0+1.0i 1234 0.0+1.0i) 0.00081037277147+0.00081037277147i)+(num-test (= -1.0+1.0i 1234 0.0+1.0i) #f)+(num-test (+ -1.0+1.0i 123.4 1) 123.4+1.0i)+(num-test (- -1.0+1.0i 123.4 1) -125.4+1.0i)+(num-test (* -1.0+1.0i 123.4 1) -123.4+123.4i)+(num-test (/ -1.0+1.0i 123.4 1) -0.00810372771475+0.00810372771475i)+(num-test (= -1.0+1.0i 123.4 1) #f)+(num-test (+ -1.0+1.0i 123.4 1.0) 123.4+1.0i)+(num-test (- -1.0+1.0i 123.4 1.0) -125.4+1.0i)+(num-test (* -1.0+1.0i 123.4 1.0) -123.4+123.4i)+(num-test (/ -1.0+1.0i 123.4 1.0) -0.00810372771475+0.00810372771475i)+(num-test (= -1.0+1.0i 123.4 1.0) #f)+(num-test (+ -1.0+1.0i 123.4 1/1) 123.4+1.0i)+(num-test (- -1.0+1.0i 123.4 1/1) -125.4+1.0i)+(num-test (* -1.0+1.0i 123.4 1/1) -123.4+123.4i)+(num-test (/ -1.0+1.0i 123.4 1/1) -0.00810372771475+0.00810372771475i)+(num-test (= -1.0+1.0i 123.4 1/1) #f)+(num-test (+ -1.0+1.0i 123.4 1.0+1.0i) 123.4+2.0i)+(num-test (- -1.0+1.0i 123.4 1.0+1.0i) -125.4)+(num-test (* -1.0+1.0i 123.4 1.0+1.0i) -246.8)+(num-test (/ -1.0+1.0i 123.4 1.0+1.0i) 0.0+0.00810372771475i)+(num-test (= -1.0+1.0i 123.4 1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 123.4 0) 122.4+1.0i)+(num-test (- -1.0+1.0i 123.4 0) -124.4+1.0i)+(num-test (* -1.0+1.0i 123.4 0) -0.0)+(num-test (+ -1.0+1.0i 123.4 0.0) 122.4+1.0i)+(num-test (- -1.0+1.0i 123.4 0.0) -124.4+1.0i)+(num-test (* -1.0+1.0i 123.4 0.0) -0.0)+(num-test (+ -1.0+1.0i 123.4 1234) 1356.4+1.0i)+(num-test (- -1.0+1.0i 123.4 1234) -1358.4+1.0i)+(num-test (* -1.0+1.0i 123.4 1234) -152275.60000000000582+152275.60000000000582i)+(num-test (/ -1.0+1.0i 123.4 1234) -0.00000656704029+0.00000656704029i)+(num-test (= -1.0+1.0i 123.4 1234) #f)+(num-test (+ -1.0+1.0i 123.4 123.4) 245.8+1.0i)+(num-test (- -1.0+1.0i 123.4 123.4) -247.8+1.0i)+(num-test (* -1.0+1.0i 123.4 123.4) -15227.56000000000131+15227.56000000000131i)+(num-test (/ -1.0+1.0i 123.4 123.4) -0.00006567040287+0.00006567040287i)+(num-test (= -1.0+1.0i 123.4 123.4) #f)+(num-test (+ -1.0+1.0i 123.4 1234/11) 234.58181818181819+1.0i)+(num-test (- -1.0+1.0i 123.4 1234/11) -236.58181818181819+1.0i)+(num-test (* -1.0+1.0i 123.4 1234/11) -13843.23636363636433+13843.23636363636433i)+(num-test (/ -1.0+1.0i 123.4 1234/11) -0.00007223744316+0.00007223744316i)+(num-test (= -1.0+1.0i 123.4 1234/11) #f)+(num-test (+ -1.0+1.0i 123.4 1.234+1.234i) 123.634+2.234i)+(num-test (- -1.0+1.0i 123.4 1.234+1.234i) -125.634-0.234i)+(num-test (* -1.0+1.0i 123.4 1.234+1.234i) -304.55119999999999)+(num-test (/ -1.0+1.0i 123.4 1.234+1.234i) 0.0+0.00656704028748i)+(num-test (= -1.0+1.0i 123.4 1.234+1.234i) #f)+(num-test (+ -1.0+1.0i 123.4 -1.0+1.0i) 121.4+2.0i)+(num-test (- -1.0+1.0i 123.4 -1.0+1.0i) -123.4)+(num-test (* -1.0+1.0i 123.4 -1.0+1.0i) 0.0-246.8i)+(num-test (/ -1.0+1.0i 123.4 -1.0+1.0i) 0.00810372771475)+(num-test (= -1.0+1.0i 123.4 -1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 123.4 0.0+1.0i) 122.4+2.0i)+(num-test (- -1.0+1.0i 123.4 0.0+1.0i) -124.4)+(num-test (* -1.0+1.0i 123.4 0.0+1.0i) -123.4-123.4i)+(num-test (/ -1.0+1.0i 123.4 0.0+1.0i) 0.00810372771475+0.00810372771475i)+(num-test (= -1.0+1.0i 123.4 0.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1234/11 1) 112.18181818181819+1.0i)+(num-test (- -1.0+1.0i 1234/11 1) -114.18181818181819+1.0i)+(num-test (* -1.0+1.0i 1234/11 1) -112.18181818181819+112.18181818181819i)+(num-test (/ -1.0+1.0i 1234/11 1) -0.00891410048622+0.00891410048622i)+(num-test (= -1.0+1.0i 1234/11 1) #f)+(num-test (+ -1.0+1.0i 1234/11 1.0) 112.18181818181819+1.0i)+(num-test (- -1.0+1.0i 1234/11 1.0) -114.18181818181819+1.0i)+(num-test (* -1.0+1.0i 1234/11 1.0) -112.18181818181819+112.18181818181819i)+(num-test (/ -1.0+1.0i 1234/11 1.0) -0.00891410048622+0.00891410048622i)+(num-test (= -1.0+1.0i 1234/11 1.0) #f)+(num-test (+ -1.0+1.0i 1234/11 1/1) 112.18181818181819+1.0i)+(num-test (- -1.0+1.0i 1234/11 1/1) -114.18181818181819+1.0i)+(num-test (* -1.0+1.0i 1234/11 1/1) -112.18181818181819+112.18181818181819i)+(num-test (/ -1.0+1.0i 1234/11 1/1) -0.00891410048622+0.00891410048622i)+(num-test (= -1.0+1.0i 1234/11 1/1) #f)+(num-test (+ -1.0+1.0i 1234/11 1.0+1.0i) 112.18181818181819+2.0i)+(num-test (- -1.0+1.0i 1234/11 1.0+1.0i) -114.18181818181819)+(num-test (* -1.0+1.0i 1234/11 1.0+1.0i) -224.36363636363637)+(num-test (/ -1.0+1.0i 1234/11 1.0+1.0i) 0.0+0.00891410048622i)+(num-test (= -1.0+1.0i 1234/11 1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1234/11 0) 111.18181818181819+1.0i)+(num-test (- -1.0+1.0i 1234/11 0) -113.18181818181819+1.0i)+(num-test (* -1.0+1.0i 1234/11 0) -0.0)+(num-test (+ -1.0+1.0i 1234/11 0.0) 111.18181818181819+1.0i)+(num-test (- -1.0+1.0i 1234/11 0.0) -113.18181818181819+1.0i)+(num-test (* -1.0+1.0i 1234/11 0.0) -0.0)+(num-test (+ -1.0+1.0i 1234/11 1234) 1345.18181818181824+1.0i)+(num-test (- -1.0+1.0i 1234/11 1234) -1347.18181818181824+1.0i)+(num-test (* -1.0+1.0i 1234/11 1234) -138432.36363636364695+138432.36363636364695i)+(num-test (/ -1.0+1.0i 1234/11 1234) -0.00000722374432+0.00000722374432i)+(num-test (= -1.0+1.0i 1234/11 1234) #f)+(num-test (+ -1.0+1.0i 1234/11 123.4) 234.58181818181819+1.0i)+(num-test (- -1.0+1.0i 1234/11 123.4) -236.58181818181819+1.0i)+(num-test (* -1.0+1.0i 1234/11 123.4) -13843.23636363636433+13843.23636363636433i)+(num-test (/ -1.0+1.0i 1234/11 123.4) -0.00007223744316+0.00007223744316i)+(num-test (= -1.0+1.0i 1234/11 123.4) #f)+(num-test (+ -1.0+1.0i 1234/11 1234/11) 223.36363636363637+1.0i)+(num-test (- -1.0+1.0i 1234/11 1234/11) -225.36363636363637+1.0i)+(num-test (* -1.0+1.0i 1234/11 1234/11) -12584.76033057851419+12584.76033057851419i)+(num-test (/ -1.0+1.0i 1234/11 1234/11) -0.00007946118748+0.00007946118748i)+(num-test (= -1.0+1.0i 1234/11 1234/11) #f)+(num-test (+ -1.0+1.0i 1234/11 1.234+1.234i) 112.41581818181818+2.234i)+(num-test (- -1.0+1.0i 1234/11 1.234+1.234i) -114.41581818181818-0.234i)+(num-test (* -1.0+1.0i 1234/11 1.234+1.234i) -276.86472727272729)+(num-test (/ -1.0+1.0i 1234/11 1.234+1.234i) 0.0+0.00722374431623i)+(num-test (= -1.0+1.0i 1234/11 1.234+1.234i) #f)+(num-test (+ -1.0+1.0i 1234/11 -1.0+1.0i) 110.18181818181819+2.0i)+(num-test (- -1.0+1.0i 1234/11 -1.0+1.0i) -112.18181818181819)+(num-test (* -1.0+1.0i 1234/11 -1.0+1.0i) 0.0-224.36363636363637i)+(num-test (/ -1.0+1.0i 1234/11 -1.0+1.0i) 0.00891410048622)+(num-test (= -1.0+1.0i 1234/11 -1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1234/11 0.0+1.0i) 111.18181818181819+2.0i)+(num-test (- -1.0+1.0i 1234/11 0.0+1.0i) -113.18181818181819)+(num-test (* -1.0+1.0i 1234/11 0.0+1.0i) -112.18181818181819-112.18181818181819i)+(num-test (/ -1.0+1.0i 1234/11 0.0+1.0i) 0.00891410048622+0.00891410048622i)+(num-test (= -1.0+1.0i 1234/11 0.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1.234+1.234i 1) 1.234+2.234i)+(num-test (- -1.0+1.0i 1.234+1.234i 1) -3.234-0.234i)+(num-test (* -1.0+1.0i 1.234+1.234i 1) -2.468)+(num-test (/ -1.0+1.0i 1.234+1.234i 1) 0.0+0.81037277147488i)+(num-test (= -1.0+1.0i 1.234+1.234i 1) #f)+(num-test (+ -1.0+1.0i 1.234+1.234i 1.0) 1.234+2.234i)+(num-test (- -1.0+1.0i 1.234+1.234i 1.0) -3.234-0.234i)+(num-test (* -1.0+1.0i 1.234+1.234i 1.0) -2.468)+(num-test (/ -1.0+1.0i 1.234+1.234i 1.0) 0.0+0.81037277147488i)+(num-test (= -1.0+1.0i 1.234+1.234i 1.0) #f)+(num-test (+ -1.0+1.0i 1.234+1.234i 1/1) 1.234+2.234i)+(num-test (- -1.0+1.0i 1.234+1.234i 1/1) -3.234-0.234i)+(num-test (* -1.0+1.0i 1.234+1.234i 1/1) -2.468)+(num-test (/ -1.0+1.0i 1.234+1.234i 1/1) 0.0+0.81037277147488i)+(num-test (= -1.0+1.0i 1.234+1.234i 1/1) #f)+(num-test (+ -1.0+1.0i 1.234+1.234i 1.0+1.0i) 1.234+3.234i)+(num-test (- -1.0+1.0i 1.234+1.234i 1.0+1.0i) -3.234-1.234i)+(num-test (* -1.0+1.0i 1.234+1.234i 1.0+1.0i) -2.468-2.468i)+(num-test (/ -1.0+1.0i 1.234+1.234i 1.0+1.0i) 0.40518638573744+0.40518638573744i)+(num-test (= -1.0+1.0i 1.234+1.234i 1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1.234+1.234i 0) 0.234+2.234i)+(num-test (- -1.0+1.0i 1.234+1.234i 0) -2.234-0.234i)+(num-test (* -1.0+1.0i 1.234+1.234i 0) -0.0)+(num-test (+ -1.0+1.0i 1.234+1.234i 0.0) 0.234+2.234i)+(num-test (- -1.0+1.0i 1.234+1.234i 0.0) -2.234-0.234i)+(num-test (* -1.0+1.0i 1.234+1.234i 0.0) -0.0)+(num-test (+ -1.0+1.0i 1.234+1.234i 1234) 1234.23399999999992+2.234i)+(num-test (- -1.0+1.0i 1.234+1.234i 1234) -1236.23399999999992-0.234i)+(num-test (* -1.0+1.0i 1.234+1.234i 1234) -3045.51200000000017)+(num-test (/ -1.0+1.0i 1.234+1.234i 1234) 0.0+0.00065670402875i)+(num-test (= -1.0+1.0i 1.234+1.234i 1234) #f)+(num-test (+ -1.0+1.0i 1.234+1.234i 123.4) 123.634+2.234i)+(num-test (- -1.0+1.0i 1.234+1.234i 123.4) -125.634-0.234i)+(num-test (* -1.0+1.0i 1.234+1.234i 123.4) -304.55119999999999)+(num-test (/ -1.0+1.0i 1.234+1.234i 123.4) 0.0+0.00656704028748i)+(num-test (= -1.0+1.0i 1.234+1.234i 123.4) #f)+(num-test (+ -1.0+1.0i 1.234+1.234i 1234/11) 112.41581818181818+2.234i)+(num-test (- -1.0+1.0i 1.234+1.234i 1234/11) -114.41581818181818-0.234i)+(num-test (* -1.0+1.0i 1.234+1.234i 1234/11) -276.86472727272729)+(num-test (/ -1.0+1.0i 1.234+1.234i 1234/11) 0.0+0.00722374431623i)+(num-test (= -1.0+1.0i 1.234+1.234i 1234/11) #f)+(num-test (+ -1.0+1.0i 1.234+1.234i 1.234+1.234i) 1.468+3.468i)+(num-test (- -1.0+1.0i 1.234+1.234i 1.234+1.234i) -3.468-1.468i)+(num-test (* -1.0+1.0i 1.234+1.234i 1.234+1.234i) -3.04551200000000-3.04551200000000i)+(num-test (/ -1.0+1.0i 1.234+1.234i 1.234+1.234i) 0.32835201437394+0.32835201437394i)+(num-test (= -1.0+1.0i 1.234+1.234i 1.234+1.234i) #f)+(num-test (+ -1.0+1.0i 1.234+1.234i -1.0+1.0i) -0.766+3.234i)+(num-test (- -1.0+1.0i 1.234+1.234i -1.0+1.0i) -1.234-1.234i)+(num-test (* -1.0+1.0i 1.234+1.234i -1.0+1.0i) 2.468-2.468i)+(num-test (/ -1.0+1.0i 1.234+1.234i -1.0+1.0i) 0.40518638573744-0.40518638573744i)+(num-test (= -1.0+1.0i 1.234+1.234i -1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 1.234+1.234i 0.0+1.0i) 0.234+3.234i)+(num-test (- -1.0+1.0i 1.234+1.234i 0.0+1.0i) -2.234-1.234i)+(num-test (* -1.0+1.0i 1.234+1.234i 0.0+1.0i) -0.0-2.468i)+(num-test (/ -1.0+1.0i 1.234+1.234i 0.0+1.0i) 0.81037277147488)+(num-test (= -1.0+1.0i 1.234+1.234i 0.0+1.0i) #f)+(num-test (+ -1.0+1.0i -1.0+1.0i 1) -1.0+2.0i)+(num-test (- -1.0+1.0i -1.0+1.0i 1) -1.0)+(num-test (* -1.0+1.0i -1.0+1.0i 1) 0.0-2.0i)+(num-test (/ -1.0+1.0i -1.0+1.0i 1) 1.0)+(num-test (= -1.0+1.0i -1.0+1.0i 1) #f)+(num-test (+ -1.0+1.0i -1.0+1.0i 1.0) -1.0+2.0i)+(num-test (- -1.0+1.0i -1.0+1.0i 1.0) -1.0)+(num-test (* -1.0+1.0i -1.0+1.0i 1.0) 0.0-2.0i)+(num-test (/ -1.0+1.0i -1.0+1.0i 1.0) 1.0)+(num-test (= -1.0+1.0i -1.0+1.0i 1.0) #f)+(num-test (+ -1.0+1.0i -1.0+1.0i 1/1) -1.0+2.0i)+(num-test (- -1.0+1.0i -1.0+1.0i 1/1) -1.0)+(num-test (* -1.0+1.0i -1.0+1.0i 1/1) 0.0-2.0i)+(num-test (/ -1.0+1.0i -1.0+1.0i 1/1) 1.0)+(num-test (= -1.0+1.0i -1.0+1.0i 1/1) #f)+(num-test (+ -1.0+1.0i -1.0+1.0i 1.0+1.0i) -1.0+3.0i)+(num-test (- -1.0+1.0i -1.0+1.0i 1.0+1.0i) -1.0-1.0i)+(num-test (* -1.0+1.0i -1.0+1.0i 1.0+1.0i) 2.0-2.0i)+(num-test (/ -1.0+1.0i -1.0+1.0i 1.0+1.0i) 0.5-0.5i)+(num-test (= -1.0+1.0i -1.0+1.0i 1.0+1.0i) #f)+(num-test (+ -1.0+1.0i -1.0+1.0i 0) -2.0+2.0i)+(num-test (- -1.0+1.0i -1.0+1.0i 0) 0.0)+(num-test (* -1.0+1.0i -1.0+1.0i 0) 0.0)+(num-test (+ -1.0+1.0i -1.0+1.0i 0.0) -2.0+2.0i)+(num-test (- -1.0+1.0i -1.0+1.0i 0.0) 0.0)+(num-test (* -1.0+1.0i -1.0+1.0i 0.0) 0.0)+(num-test (+ -1.0+1.0i -1.0+1.0i 1234) 1232.0+2.0i)+(num-test (- -1.0+1.0i -1.0+1.0i 1234) -1234.0)+(num-test (* -1.0+1.0i -1.0+1.0i 1234) 0.0-2468.0i)+(num-test (/ -1.0+1.0i -1.0+1.0i 1234) 0.00081037277147)+(num-test (= -1.0+1.0i -1.0+1.0i 1234) #f)+(num-test (+ -1.0+1.0i -1.0+1.0i 123.4) 121.4+2.0i)+(num-test (- -1.0+1.0i -1.0+1.0i 123.4) -123.4)+(num-test (* -1.0+1.0i -1.0+1.0i 123.4) 0.0-246.8i)+(num-test (/ -1.0+1.0i -1.0+1.0i 123.4) 0.00810372771475)+(num-test (= -1.0+1.0i -1.0+1.0i 123.4) #f)+(num-test (+ -1.0+1.0i -1.0+1.0i 1234/11) 110.18181818181819+2.0i)+(num-test (- -1.0+1.0i -1.0+1.0i 1234/11) -112.18181818181819)+(num-test (* -1.0+1.0i -1.0+1.0i 1234/11) 0.0-224.36363636363637i)+(num-test (/ -1.0+1.0i -1.0+1.0i 1234/11) 0.00891410048622)+(num-test (= -1.0+1.0i -1.0+1.0i 1234/11) #f)+(num-test (+ -1.0+1.0i -1.0+1.0i 1.234+1.234i) -0.766+3.234i)+(num-test (- -1.0+1.0i -1.0+1.0i 1.234+1.234i) -1.234-1.234i)+(num-test (* -1.0+1.0i -1.0+1.0i 1.234+1.234i) 2.468-2.468i)+(num-test (/ -1.0+1.0i -1.0+1.0i 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= -1.0+1.0i -1.0+1.0i 1.234+1.234i) #f)+(num-test (+ -1.0+1.0i -1.0+1.0i -1.0+1.0i) -3.0+3.0i)+(num-test (- -1.0+1.0i -1.0+1.0i -1.0+1.0i) 1.0-1.0i)+(num-test (* -1.0+1.0i -1.0+1.0i -1.0+1.0i) 2.0+2.0i)+(num-test (/ -1.0+1.0i -1.0+1.0i -1.0+1.0i) -0.5-0.5i)+(num-test (= -1.0+1.0i -1.0+1.0i -1.0+1.0i) #t)+(num-test (+ -1.0+1.0i -1.0+1.0i 0.0+1.0i) -2.0+3.0i)+(num-test (- -1.0+1.0i -1.0+1.0i 0.0+1.0i) 0.0-1.0i)+(num-test (* -1.0+1.0i -1.0+1.0i 0.0+1.0i) 2.0)+(num-test (/ -1.0+1.0i -1.0+1.0i 0.0+1.0i) 0.0-1.0i)+(num-test (= -1.0+1.0i -1.0+1.0i 0.0+1.0i) #f)+(num-test (+ -1.0+1.0i 0.0+1.0i 1) 0.0+2.0i)+(num-test (- -1.0+1.0i 0.0+1.0i 1) -2.0)+(num-test (* -1.0+1.0i 0.0+1.0i 1) -1.0-1.0i)+(num-test (/ -1.0+1.0i 0.0+1.0i 1) 1.0+1.0i)+(num-test (= -1.0+1.0i 0.0+1.0i 1) #f)+(num-test (+ -1.0+1.0i 0.0+1.0i 1.0) 0.0+2.0i)+(num-test (- -1.0+1.0i 0.0+1.0i 1.0) -2.0)+(num-test (* -1.0+1.0i 0.0+1.0i 1.0) -1.0-1.0i)+(num-test (/ -1.0+1.0i 0.0+1.0i 1.0) 1.0+1.0i)+(num-test (= -1.0+1.0i 0.0+1.0i 1.0) #f)+(num-test (+ -1.0+1.0i 0.0+1.0i 1/1) 0.0+2.0i)+(num-test (- -1.0+1.0i 0.0+1.0i 1/1) -2.0)+(num-test (* -1.0+1.0i 0.0+1.0i 1/1) -1.0-1.0i)+(num-test (/ -1.0+1.0i 0.0+1.0i 1/1) 1.0+1.0i)+(num-test (= -1.0+1.0i 0.0+1.0i 1/1) #f)+(num-test (+ -1.0+1.0i 0.0+1.0i 1.0+1.0i) 0.0+3.0i)+(num-test (- -1.0+1.0i 0.0+1.0i 1.0+1.0i) -2.0-1.0i)+(num-test (* -1.0+1.0i 0.0+1.0i 1.0+1.0i) 0.0-2.0i)+(num-test (/ -1.0+1.0i 0.0+1.0i 1.0+1.0i) 1.0)+(num-test (= -1.0+1.0i 0.0+1.0i 1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 0.0+1.0i 0) -1.0+2.0i)+(num-test (- -1.0+1.0i 0.0+1.0i 0) -1.0)+(num-test (* -1.0+1.0i 0.0+1.0i 0) 0.0)+(num-test (+ -1.0+1.0i 0.0+1.0i 0.0) -1.0+2.0i)+(num-test (- -1.0+1.0i 0.0+1.0i 0.0) -1.0)+(num-test (* -1.0+1.0i 0.0+1.0i 0.0) 0.0)+(num-test (+ -1.0+1.0i 0.0+1.0i 1234) 1233.0+2.0i)+(num-test (- -1.0+1.0i 0.0+1.0i 1234) -1235.0)+(num-test (* -1.0+1.0i 0.0+1.0i 1234) -1234.0-1234.0i)+(num-test (/ -1.0+1.0i 0.0+1.0i 1234) 0.00081037277147+0.00081037277147i)+(num-test (= -1.0+1.0i 0.0+1.0i 1234) #f)+(num-test (+ -1.0+1.0i 0.0+1.0i 123.4) 122.4+2.0i)+(num-test (- -1.0+1.0i 0.0+1.0i 123.4) -124.4)+(num-test (* -1.0+1.0i 0.0+1.0i 123.4) -123.4-123.4i)+(num-test (/ -1.0+1.0i 0.0+1.0i 123.4) 0.00810372771475+0.00810372771475i)+(num-test (= -1.0+1.0i 0.0+1.0i 123.4) #f)+(num-test (+ -1.0+1.0i 0.0+1.0i 1234/11) 111.18181818181819+2.0i)+(num-test (- -1.0+1.0i 0.0+1.0i 1234/11) -113.18181818181819)+(num-test (* -1.0+1.0i 0.0+1.0i 1234/11) -112.18181818181819-112.18181818181819i)+(num-test (/ -1.0+1.0i 0.0+1.0i 1234/11) 0.00891410048622+0.00891410048622i)+(num-test (= -1.0+1.0i 0.0+1.0i 1234/11) #f)+(num-test (+ -1.0+1.0i 0.0+1.0i 1.234+1.234i) 0.234+3.234i)+(num-test (- -1.0+1.0i 0.0+1.0i 1.234+1.234i) -2.234-1.234i)+(num-test (* -1.0+1.0i 0.0+1.0i 1.234+1.234i) 0.0-2.468i)+(num-test (/ -1.0+1.0i 0.0+1.0i 1.234+1.234i) 0.81037277147488)+(num-test (= -1.0+1.0i 0.0+1.0i 1.234+1.234i) #f)+(num-test (+ -1.0+1.0i 0.0+1.0i -1.0+1.0i) -2.0+3.0i)+(num-test (- -1.0+1.0i 0.0+1.0i -1.0+1.0i) 0.0-1.0i)+(num-test (* -1.0+1.0i 0.0+1.0i -1.0+1.0i) 2.0)+(num-test (/ -1.0+1.0i 0.0+1.0i -1.0+1.0i) -0.0-1.0i)+(num-test (= -1.0+1.0i 0.0+1.0i -1.0+1.0i) #f)+(num-test (+ -1.0+1.0i 0.0+1.0i 0.0+1.0i) -1.0+3.0i)+(num-test (- -1.0+1.0i 0.0+1.0i 0.0+1.0i) -1.0-1.0i)+(num-test (* -1.0+1.0i 0.0+1.0i 0.0+1.0i) 1.0-1.0i)+(num-test (/ -1.0+1.0i 0.0+1.0i 0.0+1.0i) 1.0-1.0i)+(num-test (= -1.0+1.0i 0.0+1.0i 0.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1 1) 2.0+1.0i)+(num-test (- 0.0+1.0i 1 1) -2.0+1.0i)+(num-test (* 0.0+1.0i 1 1) 0.0+1.0i)+(num-test (/ 0.0+1.0i 1 1) 0.0+1.0i)+(num-test (= 0.0+1.0i 1 1) #f)+(num-test (+ 0.0+1.0i 1 1.0) 2.0+1.0i)+(num-test (- 0.0+1.0i 1 1.0) -2.0+1.0i)+(num-test (* 0.0+1.0i 1 1.0) 0.0+1.0i)+(num-test (/ 0.0+1.0i 1 1.0) 0.0+1.0i)+(num-test (= 0.0+1.0i 1 1.0) #f)+(num-test (+ 0.0+1.0i 1 1/1) 2.0+1.0i)+(num-test (- 0.0+1.0i 1 1/1) -2.0+1.0i)+(num-test (* 0.0+1.0i 1 1/1) 0.0+1.0i)+(num-test (/ 0.0+1.0i 1 1/1) 0.0+1.0i)+(num-test (= 0.0+1.0i 1 1/1) #f)+(num-test (+ 0.0+1.0i 1 1.0+1.0i) 2.0+2.0i)+(num-test (- 0.0+1.0i 1 1.0+1.0i) -2.0)+(num-test (* 0.0+1.0i 1 1.0+1.0i) -1.0+1.0i)+(num-test (/ 0.0+1.0i 1 1.0+1.0i) 0.5+0.5i)+(num-test (= 0.0+1.0i 1 1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1 0) 1.0+1.0i)+(num-test (- 0.0+1.0i 1 0) -1.0+1.0i)+(num-test (* 0.0+1.0i 1 0) 0.0)+(num-test (+ 0.0+1.0i 1 0.0) 1.0+1.0i)+(num-test (- 0.0+1.0i 1 0.0) -1.0+1.0i)+(num-test (* 0.0+1.0i 1 0.0) 0.0)+(num-test (+ 0.0+1.0i 1 1234) 1235.0+1.0i)+(num-test (- 0.0+1.0i 1 1234) -1235.0+1.0i)+(num-test (* 0.0+1.0i 1 1234) 0.0+1234.0i)+(num-test (/ 0.0+1.0i 1 1234) 0.0+0.00081037277147i)+(num-test (= 0.0+1.0i 1 1234) #f)+(num-test (+ 0.0+1.0i 1 123.4) 124.4+1.0i)+(num-test (- 0.0+1.0i 1 123.4) -124.4+1.0i)+(num-test (* 0.0+1.0i 1 123.4) 0.0+123.4i)+(num-test (/ 0.0+1.0i 1 123.4) 0.0+0.00810372771475i)+(num-test (= 0.0+1.0i 1 123.4) #f)+(num-test (+ 0.0+1.0i 1 1234/11) 113.18181818181819+1.0i)+(num-test (- 0.0+1.0i 1 1234/11) -113.18181818181819+1.0i)+(num-test (* 0.0+1.0i 1 1234/11) 0.0+112.18181818181819i)+(num-test (/ 0.0+1.0i 1 1234/11) 0.0+0.00891410048622i)+(num-test (= 0.0+1.0i 1 1234/11) #f)+(num-test (+ 0.0+1.0i 1 1.234+1.234i) 2.234+2.234i)+(num-test (- 0.0+1.0i 1 1.234+1.234i) -2.234-0.234i)+(num-test (* 0.0+1.0i 1 1.234+1.234i) -1.234+1.234i)+(num-test (/ 0.0+1.0i 1 1.234+1.234i) 0.40518638573744+0.40518638573744i)+(num-test (= 0.0+1.0i 1 1.234+1.234i) #f)+(num-test (+ 0.0+1.0i 1 -1.0+1.0i) 0.0+2.0i)+(num-test (- 0.0+1.0i 1 -1.0+1.0i) 0.0)+(num-test (* 0.0+1.0i 1 -1.0+1.0i) -1.0-1.0i)+(num-test (/ 0.0+1.0i 1 -1.0+1.0i) 0.5-0.5i)+(num-test (= 0.0+1.0i 1 -1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1 0.0+1.0i) 1.0+2.0i)+(num-test (- 0.0+1.0i 1 0.0+1.0i) -1.0)+(num-test (* 0.0+1.0i 1 0.0+1.0i) -1.0)+(num-test (/ 0.0+1.0i 1 0.0+1.0i) 1.0)+(num-test (= 0.0+1.0i 1 0.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1.0 1) 2.0+1.0i)+(num-test (- 0.0+1.0i 1.0 1) -2.0+1.0i)+(num-test (* 0.0+1.0i 1.0 1) 0.0+1.0i)+(num-test (/ 0.0+1.0i 1.0 1) 0.0+1.0i)+(num-test (= 0.0+1.0i 1.0 1) #f)+(num-test (+ 0.0+1.0i 1.0 1.0) 2.0+1.0i)+(num-test (- 0.0+1.0i 1.0 1.0) -2.0+1.0i)+(num-test (* 0.0+1.0i 1.0 1.0) 0.0+1.0i)+(num-test (/ 0.0+1.0i 1.0 1.0) 0.0+1.0i)+(num-test (= 0.0+1.0i 1.0 1.0) #f)+(num-test (+ 0.0+1.0i 1.0 1/1) 2.0+1.0i)+(num-test (- 0.0+1.0i 1.0 1/1) -2.0+1.0i)+(num-test (* 0.0+1.0i 1.0 1/1) 0.0+1.0i)+(num-test (/ 0.0+1.0i 1.0 1/1) 0.0+1.0i)+(num-test (= 0.0+1.0i 1.0 1/1) #f)+(num-test (+ 0.0+1.0i 1.0 1.0+1.0i) 2.0+2.0i)+(num-test (- 0.0+1.0i 1.0 1.0+1.0i) -2.0)+(num-test (* 0.0+1.0i 1.0 1.0+1.0i) -1.0+1.0i)+(num-test (/ 0.0+1.0i 1.0 1.0+1.0i) 0.5+0.5i)+(num-test (= 0.0+1.0i 1.0 1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1.0 0) 1.0+1.0i)+(num-test (- 0.0+1.0i 1.0 0) -1.0+1.0i)+(num-test (* 0.0+1.0i 1.0 0) 0.0)+(num-test (+ 0.0+1.0i 1.0 0.0) 1.0+1.0i)+(num-test (- 0.0+1.0i 1.0 0.0) -1.0+1.0i)+(num-test (* 0.0+1.0i 1.0 0.0) 0.0)+(num-test (+ 0.0+1.0i 1.0 1234) 1235.0+1.0i)+(num-test (- 0.0+1.0i 1.0 1234) -1235.0+1.0i)+(num-test (* 0.0+1.0i 1.0 1234) 0.0+1234.0i)+(num-test (/ 0.0+1.0i 1.0 1234) 0.0+0.00081037277147i)+(num-test (= 0.0+1.0i 1.0 1234) #f)+(num-test (+ 0.0+1.0i 1.0 123.4) 124.4+1.0i)+(num-test (- 0.0+1.0i 1.0 123.4) -124.4+1.0i)+(num-test (* 0.0+1.0i 1.0 123.4) 0.0+123.4i)+(num-test (/ 0.0+1.0i 1.0 123.4) 0.0+0.00810372771475i)+(num-test (= 0.0+1.0i 1.0 123.4) #f)+(num-test (+ 0.0+1.0i 1.0 1234/11) 113.18181818181819+1.0i)+(num-test (- 0.0+1.0i 1.0 1234/11) -113.18181818181819+1.0i)+(num-test (* 0.0+1.0i 1.0 1234/11) 0.0+112.18181818181819i)+(num-test (/ 0.0+1.0i 1.0 1234/11) 0.0+0.00891410048622i)+(num-test (= 0.0+1.0i 1.0 1234/11) #f)+(num-test (+ 0.0+1.0i 1.0 1.234+1.234i) 2.234+2.234i)+(num-test (- 0.0+1.0i 1.0 1.234+1.234i) -2.234-0.234i)+(num-test (* 0.0+1.0i 1.0 1.234+1.234i) -1.234+1.234i)+(num-test (/ 0.0+1.0i 1.0 1.234+1.234i) 0.40518638573744+0.40518638573744i)+(num-test (= 0.0+1.0i 1.0 1.234+1.234i) #f)+(num-test (+ 0.0+1.0i 1.0 -1.0+1.0i) 0.0+2.0i)+(num-test (- 0.0+1.0i 1.0 -1.0+1.0i) 0.0)+(num-test (* 0.0+1.0i 1.0 -1.0+1.0i) -1.0-1.0i)+(num-test (/ 0.0+1.0i 1.0 -1.0+1.0i) 0.5-0.5i)+(num-test (= 0.0+1.0i 1.0 -1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1.0 0.0+1.0i) 1.0+2.0i)+(num-test (- 0.0+1.0i 1.0 0.0+1.0i) -1.0)+(num-test (* 0.0+1.0i 1.0 0.0+1.0i) -1.0)+(num-test (/ 0.0+1.0i 1.0 0.0+1.0i) 1.0)+(num-test (= 0.0+1.0i 1.0 0.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1/1 1) 2.0+1.0i)+(num-test (- 0.0+1.0i 1/1 1) -2.0+1.0i)+(num-test (* 0.0+1.0i 1/1 1) 0.0+1.0i)+(num-test (/ 0.0+1.0i 1/1 1) 0.0+1.0i)+(num-test (= 0.0+1.0i 1/1 1) #f)+(num-test (+ 0.0+1.0i 1/1 1.0) 2.0+1.0i)+(num-test (- 0.0+1.0i 1/1 1.0) -2.0+1.0i)+(num-test (* 0.0+1.0i 1/1 1.0) 0.0+1.0i)+(num-test (/ 0.0+1.0i 1/1 1.0) 0.0+1.0i)+(num-test (= 0.0+1.0i 1/1 1.0) #f)+(num-test (+ 0.0+1.0i 1/1 1/1) 2.0+1.0i)+(num-test (- 0.0+1.0i 1/1 1/1) -2.0+1.0i)+(num-test (* 0.0+1.0i 1/1 1/1) 0.0+1.0i)+(num-test (/ 0.0+1.0i 1/1 1/1) 0.0+1.0i)+(num-test (= 0.0+1.0i 1/1 1/1) #f)+(num-test (+ 0.0+1.0i 1/1 1.0+1.0i) 2.0+2.0i)+(num-test (- 0.0+1.0i 1/1 1.0+1.0i) -2.0)+(num-test (* 0.0+1.0i 1/1 1.0+1.0i) -1.0+1.0i)+(num-test (/ 0.0+1.0i 1/1 1.0+1.0i) 0.5+0.5i)+(num-test (= 0.0+1.0i 1/1 1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1/1 0) 1.0+1.0i)+(num-test (- 0.0+1.0i 1/1 0) -1.0+1.0i)+(num-test (* 0.0+1.0i 1/1 0) 0.0)+(num-test (+ 0.0+1.0i 1/1 0.0) 1.0+1.0i)+(num-test (- 0.0+1.0i 1/1 0.0) -1.0+1.0i)+(num-test (* 0.0+1.0i 1/1 0.0) 0.0)+(num-test (+ 0.0+1.0i 1/1 1234) 1235.0+1.0i)+(num-test (- 0.0+1.0i 1/1 1234) -1235.0+1.0i)+(num-test (* 0.0+1.0i 1/1 1234) 0.0+1234.0i)+(num-test (/ 0.0+1.0i 1/1 1234) 0.0+0.00081037277147i)+(num-test (= 0.0+1.0i 1/1 1234) #f)+(num-test (+ 0.0+1.0i 1/1 123.4) 124.4+1.0i)+(num-test (- 0.0+1.0i 1/1 123.4) -124.4+1.0i)+(num-test (* 0.0+1.0i 1/1 123.4) 0.0+123.4i)+(num-test (/ 0.0+1.0i 1/1 123.4) 0.0+0.00810372771475i)+(num-test (= 0.0+1.0i 1/1 123.4) #f)+(num-test (+ 0.0+1.0i 1/1 1234/11) 113.18181818181819+1.0i)+(num-test (- 0.0+1.0i 1/1 1234/11) -113.18181818181819+1.0i)+(num-test (* 0.0+1.0i 1/1 1234/11) 0.0+112.18181818181819i)+(num-test (/ 0.0+1.0i 1/1 1234/11) 0.0+0.00891410048622i)+(num-test (= 0.0+1.0i 1/1 1234/11) #f)+(num-test (+ 0.0+1.0i 1/1 1.234+1.234i) 2.234+2.234i)+(num-test (- 0.0+1.0i 1/1 1.234+1.234i) -2.234-0.234i)+(num-test (* 0.0+1.0i 1/1 1.234+1.234i) -1.234+1.234i)+(num-test (/ 0.0+1.0i 1/1 1.234+1.234i) 0.40518638573744+0.40518638573744i)+(num-test (= 0.0+1.0i 1/1 1.234+1.234i) #f)+(num-test (+ 0.0+1.0i 1/1 -1.0+1.0i) 0.0+2.0i)+(num-test (- 0.0+1.0i 1/1 -1.0+1.0i) 0.0)+(num-test (* 0.0+1.0i 1/1 -1.0+1.0i) -1.0-1.0i)+(num-test (/ 0.0+1.0i 1/1 -1.0+1.0i) 0.5-0.5i)+(num-test (= 0.0+1.0i 1/1 -1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1/1 0.0+1.0i) 1.0+2.0i)+(num-test (- 0.0+1.0i 1/1 0.0+1.0i) -1.0)+(num-test (* 0.0+1.0i 1/1 0.0+1.0i) -1.0)+(num-test (/ 0.0+1.0i 1/1 0.0+1.0i) 1.0)+(num-test (= 0.0+1.0i 1/1 0.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1.0+1.0i 1) 2.0+2.0i)+(num-test (- 0.0+1.0i 1.0+1.0i 1) -2.0)+(num-test (* 0.0+1.0i 1.0+1.0i 1) -1.0+1.0i)+(num-test (/ 0.0+1.0i 1.0+1.0i 1) 0.5+0.5i)+(num-test (= 0.0+1.0i 1.0+1.0i 1) #f)+(num-test (+ 0.0+1.0i 1.0+1.0i 1.0) 2.0+2.0i)+(num-test (- 0.0+1.0i 1.0+1.0i 1.0) -2.0)+(num-test (* 0.0+1.0i 1.0+1.0i 1.0) -1.0+1.0i)+(num-test (/ 0.0+1.0i 1.0+1.0i 1.0) 0.5+0.5i)+(num-test (= 0.0+1.0i 1.0+1.0i 1.0) #f)+(num-test (+ 0.0+1.0i 1.0+1.0i 1/1) 2.0+2.0i)+(num-test (- 0.0+1.0i 1.0+1.0i 1/1) -2.0)+(num-test (* 0.0+1.0i 1.0+1.0i 1/1) -1.0+1.0i)+(num-test (/ 0.0+1.0i 1.0+1.0i 1/1) 0.5+0.5i)+(num-test (= 0.0+1.0i 1.0+1.0i 1/1) #f)+(num-test (+ 0.0+1.0i 1.0+1.0i 1.0+1.0i) 2.0+3.0i)+(num-test (- 0.0+1.0i 1.0+1.0i 1.0+1.0i) -2.0-1.0i)+(num-test (* 0.0+1.0i 1.0+1.0i 1.0+1.0i) -2.0)+(num-test (/ 0.0+1.0i 1.0+1.0i 1.0+1.0i) 0.5)+(num-test (= 0.0+1.0i 1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1.0+1.0i 0) 1.0+2.0i)+(num-test (- 0.0+1.0i 1.0+1.0i 0) -1.0)+(num-test (* 0.0+1.0i 1.0+1.0i 0) -0.0)+(num-test (+ 0.0+1.0i 1.0+1.0i 0.0) 1.0+2.0i)+(num-test (- 0.0+1.0i 1.0+1.0i 0.0) -1.0)+(num-test (* 0.0+1.0i 1.0+1.0i 0.0) -0.0)+(num-test (+ 0.0+1.0i 1.0+1.0i 1234) 1235.0+2.0i)+(num-test (- 0.0+1.0i 1.0+1.0i 1234) -1235.0)+(num-test (* 0.0+1.0i 1.0+1.0i 1234) -1234.0+1234.0i)+(num-test (/ 0.0+1.0i 1.0+1.0i 1234) 0.00040518638574+0.00040518638574i)+(num-test (= 0.0+1.0i 1.0+1.0i 1234) #f)+(num-test (+ 0.0+1.0i 1.0+1.0i 123.4) 124.4+2.0i)+(num-test (- 0.0+1.0i 1.0+1.0i 123.4) -124.4)+(num-test (* 0.0+1.0i 1.0+1.0i 123.4) -123.4+123.4i)+(num-test (/ 0.0+1.0i 1.0+1.0i 123.4) 0.00405186385737+0.00405186385737i)+(num-test (= 0.0+1.0i 1.0+1.0i 123.4) #f)+(num-test (+ 0.0+1.0i 1.0+1.0i 1234/11) 113.18181818181819+2.0i)+(num-test (- 0.0+1.0i 1.0+1.0i 1234/11) -113.18181818181819)+(num-test (* 0.0+1.0i 1.0+1.0i 1234/11) -112.18181818181819+112.18181818181819i)+(num-test (/ 0.0+1.0i 1.0+1.0i 1234/11) 0.00445705024311+0.00445705024311i)+(num-test (= 0.0+1.0i 1.0+1.0i 1234/11) #f)+(num-test (+ 0.0+1.0i 1.0+1.0i 1.234+1.234i) 2.234+3.234i)+(num-test (- 0.0+1.0i 1.0+1.0i 1.234+1.234i) -2.234-1.234i)+(num-test (* 0.0+1.0i 1.0+1.0i 1.234+1.234i) -2.468)+(num-test (/ 0.0+1.0i 1.0+1.0i 1.234+1.234i) 0.40518638573744)+(num-test (= 0.0+1.0i 1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 0.0+1.0i 1.0+1.0i -1.0+1.0i) 0.0+3.0i)+(num-test (- 0.0+1.0i 1.0+1.0i -1.0+1.0i) 0.0-1.0i)+(num-test (* 0.0+1.0i 1.0+1.0i -1.0+1.0i) 0.0-2.0i)+(num-test (/ 0.0+1.0i 1.0+1.0i -1.0+1.0i) -0.0-0.5i)+(num-test (= 0.0+1.0i 1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1.0+1.0i 0.0+1.0i) 1.0+3.0i)+(num-test (- 0.0+1.0i 1.0+1.0i 0.0+1.0i) -1.0-1.0i)+(num-test (* 0.0+1.0i 1.0+1.0i 0.0+1.0i) -1.0-1.0i)+(num-test (/ 0.0+1.0i 1.0+1.0i 0.0+1.0i) 0.5-0.5i)+(num-test (= 0.0+1.0i 1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 0.0+1.0i 0 1) 1.0+1.0i)+(num-test (- 0.0+1.0i 0 1) -1.0+1.0i)+(num-test (* 0.0+1.0i 0 1) 0.0)+(num-test (+ 0.0+1.0i 0 1.0) 1.0+1.0i)+(num-test (- 0.0+1.0i 0 1.0) -1.0+1.0i)+(num-test (* 0.0+1.0i 0 1.0) 0.0)+(num-test (+ 0.0+1.0i 0 1/1) 1.0+1.0i)+(num-test (- 0.0+1.0i 0 1/1) -1.0+1.0i)+(num-test (* 0.0+1.0i 0 1/1) 0.0)+(num-test (+ 0.0+1.0i 0 1.0+1.0i) 1.0+2.0i)+(num-test (- 0.0+1.0i 0 1.0+1.0i) -1.0)+(num-test (* 0.0+1.0i 0 1.0+1.0i) 0.0)+(num-test (+ 0.0+1.0i 0 0) 0.0+1.0i)+(num-test (- 0.0+1.0i 0 0) 0.0+1.0i)+(num-test (* 0.0+1.0i 0 0) 0.0)+(num-test (+ 0.0+1.0i 0 0.0) 0.0+1.0i)+(num-test (- 0.0+1.0i 0 0.0) 0.0+1.0i)+(num-test (* 0.0+1.0i 0 0.0) 0.0)+(num-test (+ 0.0+1.0i 0 1234) 1234.0+1.0i)+(num-test (- 0.0+1.0i 0 1234) -1234.0+1.0i)+(num-test (* 0.0+1.0i 0 1234) 0.0)+(num-test (+ 0.0+1.0i 0 123.4) 123.4+1.0i)+(num-test (- 0.0+1.0i 0 123.4) -123.4+1.0i)+(num-test (* 0.0+1.0i 0 123.4) 0.0)+(num-test (+ 0.0+1.0i 0 1234/11) 112.18181818181819+1.0i)+(num-test (- 0.0+1.0i 0 1234/11) -112.18181818181819+1.0i)+(num-test (* 0.0+1.0i 0 1234/11) 0.0)+(num-test (+ 0.0+1.0i 0 1.234+1.234i) 1.234+2.234i)+(num-test (- 0.0+1.0i 0 1.234+1.234i) -1.234-0.234i)+(num-test (* 0.0+1.0i 0 1.234+1.234i) 0.0)+(num-test (+ 0.0+1.0i 0 -1.0+1.0i) -1.0+2.0i)+(num-test (- 0.0+1.0i 0 -1.0+1.0i) 1.0)+(num-test (* 0.0+1.0i 0 -1.0+1.0i) -0.0)+(num-test (+ 0.0+1.0i 0 0.0+1.0i) 0.0+2.0i)+(num-test (- 0.0+1.0i 0 0.0+1.0i) 0.0)+(num-test (* 0.0+1.0i 0 0.0+1.0i) 0.0)+(num-test (+ 0.0+1.0i 0.0 1) 1.0+1.0i)+(num-test (- 0.0+1.0i 0.0 1) -1.0+1.0i)+(num-test (* 0.0+1.0i 0.0 1) 0.0)+(num-test (+ 0.0+1.0i 0.0 1.0) 1.0+1.0i)+(num-test (- 0.0+1.0i 0.0 1.0) -1.0+1.0i)+(num-test (* 0.0+1.0i 0.0 1.0) 0.0)+(num-test (+ 0.0+1.0i 0.0 1/1) 1.0+1.0i)+(num-test (- 0.0+1.0i 0.0 1/1) -1.0+1.0i)+(num-test (* 0.0+1.0i 0.0 1/1) 0.0)+(num-test (+ 0.0+1.0i 0.0 1.0+1.0i) 1.0+2.0i)+(num-test (- 0.0+1.0i 0.0 1.0+1.0i) -1.0)+(num-test (* 0.0+1.0i 0.0 1.0+1.0i) 0.0)+(num-test (+ 0.0+1.0i 0.0 0) 0.0+1.0i)+(num-test (- 0.0+1.0i 0.0 0) 0.0+1.0i)+(num-test (* 0.0+1.0i 0.0 0) 0.0)+(num-test (+ 0.0+1.0i 0.0 0.0) 0.0+1.0i)+(num-test (- 0.0+1.0i 0.0 0.0) 0.0+1.0i)+(num-test (* 0.0+1.0i 0.0 0.0) 0.0)+(num-test (+ 0.0+1.0i 0.0 1234) 1234.0+1.0i)+(num-test (- 0.0+1.0i 0.0 1234) -1234.0+1.0i)+(num-test (* 0.0+1.0i 0.0 1234) 0.0)+(num-test (+ 0.0+1.0i 0.0 123.4) 123.4+1.0i)+(num-test (- 0.0+1.0i 0.0 123.4) -123.4+1.0i)+(num-test (* 0.0+1.0i 0.0 123.4) 0.0)+(num-test (+ 0.0+1.0i 0.0 1234/11) 112.18181818181819+1.0i)+(num-test (- 0.0+1.0i 0.0 1234/11) -112.18181818181819+1.0i)+(num-test (* 0.0+1.0i 0.0 1234/11) 0.0)+(num-test (+ 0.0+1.0i 0.0 1.234+1.234i) 1.234+2.234i)+(num-test (- 0.0+1.0i 0.0 1.234+1.234i) -1.234-0.234i)+(num-test (* 0.0+1.0i 0.0 1.234+1.234i) 0.0)+(num-test (+ 0.0+1.0i 0.0 -1.0+1.0i) -1.0+2.0i)+(num-test (- 0.0+1.0i 0.0 -1.0+1.0i) 1.0)+(num-test (* 0.0+1.0i 0.0 -1.0+1.0i) -0.0)+(num-test (+ 0.0+1.0i 0.0 0.0+1.0i) 0.0+2.0i)+(num-test (- 0.0+1.0i 0.0 0.0+1.0i) 0.0)+(num-test (* 0.0+1.0i 0.0 0.0+1.0i) 0.0)+(num-test (+ 0.0+1.0i 1234 1) 1235.0+1.0i)+(num-test (- 0.0+1.0i 1234 1) -1235.0+1.0i)+(num-test (* 0.0+1.0i 1234 1) 0.0+1234.0i)+(num-test (/ 0.0+1.0i 1234 1) 0.0+0.00081037277147i)+(num-test (= 0.0+1.0i 1234 1) #f)+(num-test (+ 0.0+1.0i 1234 1.0) 1235.0+1.0i)+(num-test (- 0.0+1.0i 1234 1.0) -1235.0+1.0i)+(num-test (* 0.0+1.0i 1234 1.0) 0.0+1234.0i)+(num-test (/ 0.0+1.0i 1234 1.0) 0.0+0.00081037277147i)+(num-test (= 0.0+1.0i 1234 1.0) #f)+(num-test (+ 0.0+1.0i 1234 1/1) 1235.0+1.0i)+(num-test (- 0.0+1.0i 1234 1/1) -1235.0+1.0i)+(num-test (* 0.0+1.0i 1234 1/1) 0.0+1234.0i)+(num-test (/ 0.0+1.0i 1234 1/1) 0.0+0.00081037277147i)+(num-test (= 0.0+1.0i 1234 1/1) #f)+(num-test (+ 0.0+1.0i 1234 1.0+1.0i) 1235.0+2.0i)+(num-test (- 0.0+1.0i 1234 1.0+1.0i) -1235.0)+(num-test (* 0.0+1.0i 1234 1.0+1.0i) -1234.0+1234.0i)+(num-test (/ 0.0+1.0i 1234 1.0+1.0i) 0.00040518638574+0.00040518638574i)+(num-test (= 0.0+1.0i 1234 1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1234 0) 1234.0+1.0i)+(num-test (- 0.0+1.0i 1234 0) -1234.0+1.0i)+(num-test (* 0.0+1.0i 1234 0) 0.0)+(num-test (+ 0.0+1.0i 1234 0.0) 1234.0+1.0i)+(num-test (- 0.0+1.0i 1234 0.0) -1234.0+1.0i)+(num-test (* 0.0+1.0i 1234 0.0) 0.0)+(num-test (+ 0.0+1.0i 1234 1234) 2468.0+1.0i)+(num-test (- 0.0+1.0i 1234 1234) -2468.0+1.0i)+(num-test (* 0.0+1.0i 1234 1234) 0.0+1522756.0i)+(num-test (/ 0.0+1.0i 1234 1234) 0.0+0.00000065670403i)+(num-test (= 0.0+1.0i 1234 1234) #f)+(num-test (+ 0.0+1.0i 1234 123.4) 1357.4+1.0i)+(num-test (- 0.0+1.0i 1234 123.4) -1357.4+1.0i)+(num-test (* 0.0+1.0i 1234 123.4) 0.0+152275.60000000000582i)+(num-test (/ 0.0+1.0i 1234 123.4) 0.0+0.00000656704029i)+(num-test (= 0.0+1.0i 1234 123.4) #f)+(num-test (+ 0.0+1.0i 1234 1234/11) 1346.18181818181824+1.0i)+(num-test (- 0.0+1.0i 1234 1234/11) -1346.18181818181824+1.0i)+(num-test (* 0.0+1.0i 1234 1234/11) 0.0+138432.36363636364695i)+(num-test (/ 0.0+1.0i 1234 1234/11) 0.0+0.00000722374432i)+(num-test (= 0.0+1.0i 1234 1234/11) #f)+(num-test (+ 0.0+1.0i 1234 1.234+1.234i) 1235.23399999999992+2.234i)+(num-test (- 0.0+1.0i 1234 1.234+1.234i) -1235.23399999999992-0.234i)+(num-test (* 0.0+1.0i 1234 1.234+1.234i) -1522.756+1522.756i)+(num-test (/ 0.0+1.0i 1234 1.234+1.234i) 0.00032835201437+0.00032835201437i)+(num-test (= 0.0+1.0i 1234 1.234+1.234i) #f)+(num-test (+ 0.0+1.0i 1234 -1.0+1.0i) 1233.0+2.0i)+(num-test (- 0.0+1.0i 1234 -1.0+1.0i) -1233.0)+(num-test (* 0.0+1.0i 1234 -1.0+1.0i) -1234.0-1234.0i)+(num-test (/ 0.0+1.0i 1234 -1.0+1.0i) 0.00040518638574-0.00040518638574i)+(num-test (= 0.0+1.0i 1234 -1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1234 0.0+1.0i) 1234.0+2.0i)+(num-test (- 0.0+1.0i 1234 0.0+1.0i) -1234.0)+(num-test (* 0.0+1.0i 1234 0.0+1.0i) -1234.0)+(num-test (/ 0.0+1.0i 1234 0.0+1.0i) 0.00081037277147)+(num-test (= 0.0+1.0i 1234 0.0+1.0i) #f)+(num-test (+ 0.0+1.0i 123.4 1) 124.4+1.0i)+(num-test (- 0.0+1.0i 123.4 1) -124.4+1.0i)+(num-test (* 0.0+1.0i 123.4 1) 0.0+123.4i)+(num-test (/ 0.0+1.0i 123.4 1) 0.0+0.00810372771475i)+(num-test (= 0.0+1.0i 123.4 1) #f)+(num-test (+ 0.0+1.0i 123.4 1.0) 124.4+1.0i)+(num-test (- 0.0+1.0i 123.4 1.0) -124.4+1.0i)+(num-test (* 0.0+1.0i 123.4 1.0) 0.0+123.4i)+(num-test (/ 0.0+1.0i 123.4 1.0) 0.0+0.00810372771475i)+(num-test (= 0.0+1.0i 123.4 1.0) #f)+(num-test (+ 0.0+1.0i 123.4 1/1) 124.4+1.0i)+(num-test (- 0.0+1.0i 123.4 1/1) -124.4+1.0i)+(num-test (* 0.0+1.0i 123.4 1/1) 0.0+123.4i)+(num-test (/ 0.0+1.0i 123.4 1/1) 0.0+0.00810372771475i)+(num-test (= 0.0+1.0i 123.4 1/1) #f)+(num-test (+ 0.0+1.0i 123.4 1.0+1.0i) 124.4+2.0i)+(num-test (- 0.0+1.0i 123.4 1.0+1.0i) -124.4)+(num-test (* 0.0+1.0i 123.4 1.0+1.0i) -123.4+123.4i)+(num-test (/ 0.0+1.0i 123.4 1.0+1.0i) 0.00405186385737+0.00405186385737i)+(num-test (= 0.0+1.0i 123.4 1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 123.4 0) 123.4+1.0i)+(num-test (- 0.0+1.0i 123.4 0) -123.4+1.0i)+(num-test (* 0.0+1.0i 123.4 0) 0.0)+(num-test (+ 0.0+1.0i 123.4 0.0) 123.4+1.0i)+(num-test (- 0.0+1.0i 123.4 0.0) -123.4+1.0i)+(num-test (* 0.0+1.0i 123.4 0.0) 0.0)+(num-test (+ 0.0+1.0i 123.4 1234) 1357.4+1.0i)+(num-test (- 0.0+1.0i 123.4 1234) -1357.4+1.0i)+(num-test (* 0.0+1.0i 123.4 1234) 0.0+152275.60000000000582i)+(num-test (/ 0.0+1.0i 123.4 1234) 0.0+0.00000656704029i)+(num-test (= 0.0+1.0i 123.4 1234) #f)+(num-test (+ 0.0+1.0i 123.4 123.4) 246.8+1.0i)+(num-test (- 0.0+1.0i 123.4 123.4) -246.8+1.0i)+(num-test (* 0.0+1.0i 123.4 123.4) 0.0+15227.56000000000131i)+(num-test (/ 0.0+1.0i 123.4 123.4) 0.0+0.00006567040287i)+(num-test (= 0.0+1.0i 123.4 123.4) #f)+(num-test (+ 0.0+1.0i 123.4 1234/11) 235.58181818181819+1.0i)+(num-test (- 0.0+1.0i 123.4 1234/11) -235.58181818181819+1.0i)+(num-test (* 0.0+1.0i 123.4 1234/11) 0.0+13843.23636363636433i)+(num-test (/ 0.0+1.0i 123.4 1234/11) 0.0+0.00007223744316i)+(num-test (= 0.0+1.0i 123.4 1234/11) #f)+(num-test (+ 0.0+1.0i 123.4 1.234+1.234i) 124.634+2.234i)+(num-test (- 0.0+1.0i 123.4 1.234+1.234i) -124.634-0.234i)+(num-test (* 0.0+1.0i 123.4 1.234+1.234i) -152.2756+152.2756i)+(num-test (/ 0.0+1.0i 123.4 1.234+1.234i) 0.00328352014374+0.00328352014374i)+(num-test (= 0.0+1.0i 123.4 1.234+1.234i) #f)+(num-test (+ 0.0+1.0i 123.4 -1.0+1.0i) 122.4+2.0i)+(num-test (- 0.0+1.0i 123.4 -1.0+1.0i) -122.4)+(num-test (* 0.0+1.0i 123.4 -1.0+1.0i) -123.4-123.4i)+(num-test (/ 0.0+1.0i 123.4 -1.0+1.0i) 0.00405186385737-0.00405186385737i)+(num-test (= 0.0+1.0i 123.4 -1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 123.4 0.0+1.0i) 123.4+2.0i)+(num-test (- 0.0+1.0i 123.4 0.0+1.0i) -123.4)+(num-test (* 0.0+1.0i 123.4 0.0+1.0i) -123.4)+(num-test (/ 0.0+1.0i 123.4 0.0+1.0i) 0.00810372771475)+(num-test (= 0.0+1.0i 123.4 0.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1234/11 1) 113.18181818181819+1.0i)+(num-test (- 0.0+1.0i 1234/11 1) -113.18181818181819+1.0i)+(num-test (* 0.0+1.0i 1234/11 1) 0.0+112.18181818181819i)+(num-test (/ 0.0+1.0i 1234/11 1) 0.0+0.00891410048622i)+(num-test (= 0.0+1.0i 1234/11 1) #f)+(num-test (+ 0.0+1.0i 1234/11 1.0) 113.18181818181819+1.0i)+(num-test (- 0.0+1.0i 1234/11 1.0) -113.18181818181819+1.0i)+(num-test (* 0.0+1.0i 1234/11 1.0) 0.0+112.18181818181819i)+(num-test (/ 0.0+1.0i 1234/11 1.0) 0.0+0.00891410048622i)+(num-test (= 0.0+1.0i 1234/11 1.0) #f)+(num-test (+ 0.0+1.0i 1234/11 1/1) 113.18181818181819+1.0i)+(num-test (- 0.0+1.0i 1234/11 1/1) -113.18181818181819+1.0i)+(num-test (* 0.0+1.0i 1234/11 1/1) 0.0+112.18181818181819i)+(num-test (/ 0.0+1.0i 1234/11 1/1) 0.0+0.00891410048622i)+(num-test (= 0.0+1.0i 1234/11 1/1) #f)+(num-test (+ 0.0+1.0i 1234/11 1.0+1.0i) 113.18181818181819+2.0i)+(num-test (- 0.0+1.0i 1234/11 1.0+1.0i) -113.18181818181819)+(num-test (* 0.0+1.0i 1234/11 1.0+1.0i) -112.18181818181819+112.18181818181819i)+(num-test (/ 0.0+1.0i 1234/11 1.0+1.0i) 0.00445705024311+0.00445705024311i)+(num-test (= 0.0+1.0i 1234/11 1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1234/11 0) 112.18181818181819+1.0i)+(num-test (- 0.0+1.0i 1234/11 0) -112.18181818181819+1.0i)+(num-test (* 0.0+1.0i 1234/11 0) 0.0)+(num-test (+ 0.0+1.0i 1234/11 0.0) 112.18181818181819+1.0i)+(num-test (- 0.0+1.0i 1234/11 0.0) -112.18181818181819+1.0i)+(num-test (* 0.0+1.0i 1234/11 0.0) 0.0)+(num-test (+ 0.0+1.0i 1234/11 1234) 1346.18181818181824+1.0i)+(num-test (- 0.0+1.0i 1234/11 1234) -1346.18181818181824+1.0i)+(num-test (* 0.0+1.0i 1234/11 1234) 0.0+138432.36363636364695i)+(num-test (/ 0.0+1.0i 1234/11 1234) 0.0+0.00000722374432i)+(num-test (= 0.0+1.0i 1234/11 1234) #f)+(num-test (+ 0.0+1.0i 1234/11 123.4) 235.58181818181819+1.0i)+(num-test (- 0.0+1.0i 1234/11 123.4) -235.58181818181819+1.0i)+(num-test (* 0.0+1.0i 1234/11 123.4) 0.0+13843.23636363636433i)+(num-test (/ 0.0+1.0i 1234/11 123.4) 0.0+0.00007223744316i)+(num-test (= 0.0+1.0i 1234/11 123.4) #f)+(num-test (+ 0.0+1.0i 1234/11 1234/11) 224.36363636363637+1.0i)+(num-test (- 0.0+1.0i 1234/11 1234/11) -224.36363636363637+1.0i)+(num-test (* 0.0+1.0i 1234/11 1234/11) 0.0+12584.76033057851419i)+(num-test (/ 0.0+1.0i 1234/11 1234/11) 0.0+0.00007946118748i)+(num-test (= 0.0+1.0i 1234/11 1234/11) #f)+(num-test (+ 0.0+1.0i 1234/11 1.234+1.234i) 113.41581818181818+2.234i)+(num-test (- 0.0+1.0i 1234/11 1.234+1.234i) -113.41581818181818-0.234i)+(num-test (* 0.0+1.0i 1234/11 1.234+1.234i) -138.43236363636365+138.43236363636365i)+(num-test (/ 0.0+1.0i 1234/11 1.234+1.234i) 0.00361187215811+0.00361187215811i)+(num-test (= 0.0+1.0i 1234/11 1.234+1.234i) #f)+(num-test (+ 0.0+1.0i 1234/11 -1.0+1.0i) 111.18181818181819+2.0i)+(num-test (- 0.0+1.0i 1234/11 -1.0+1.0i) -111.18181818181819)+(num-test (* 0.0+1.0i 1234/11 -1.0+1.0i) -112.18181818181819-112.18181818181819i)+(num-test (/ 0.0+1.0i 1234/11 -1.0+1.0i) 0.00445705024311-0.00445705024311i)+(num-test (= 0.0+1.0i 1234/11 -1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1234/11 0.0+1.0i) 112.18181818181819+2.0i)+(num-test (- 0.0+1.0i 1234/11 0.0+1.0i) -112.18181818181819)+(num-test (* 0.0+1.0i 1234/11 0.0+1.0i) -112.18181818181819)+(num-test (/ 0.0+1.0i 1234/11 0.0+1.0i) 0.00891410048622)+(num-test (= 0.0+1.0i 1234/11 0.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1.234+1.234i 1) 2.234+2.234i)+(num-test (- 0.0+1.0i 1.234+1.234i 1) -2.234-0.234i)+(num-test (* 0.0+1.0i 1.234+1.234i 1) -1.234+1.234i)+(num-test (/ 0.0+1.0i 1.234+1.234i 1) 0.40518638573744+0.40518638573744i)+(num-test (= 0.0+1.0i 1.234+1.234i 1) #f)+(num-test (+ 0.0+1.0i 1.234+1.234i 1.0) 2.234+2.234i)+(num-test (- 0.0+1.0i 1.234+1.234i 1.0) -2.234-0.234i)+(num-test (* 0.0+1.0i 1.234+1.234i 1.0) -1.234+1.234i)+(num-test (/ 0.0+1.0i 1.234+1.234i 1.0) 0.40518638573744+0.40518638573744i)+(num-test (= 0.0+1.0i 1.234+1.234i 1.0) #f)+(num-test (+ 0.0+1.0i 1.234+1.234i 1/1) 2.234+2.234i)+(num-test (- 0.0+1.0i 1.234+1.234i 1/1) -2.234-0.234i)+(num-test (* 0.0+1.0i 1.234+1.234i 1/1) -1.234+1.234i)+(num-test (/ 0.0+1.0i 1.234+1.234i 1/1) 0.40518638573744+0.40518638573744i)+(num-test (= 0.0+1.0i 1.234+1.234i 1/1) #f)+(num-test (+ 0.0+1.0i 1.234+1.234i 1.0+1.0i) 2.234+3.234i)+(num-test (- 0.0+1.0i 1.234+1.234i 1.0+1.0i) -2.234-1.234i)+(num-test (* 0.0+1.0i 1.234+1.234i 1.0+1.0i) -2.468)+(num-test (/ 0.0+1.0i 1.234+1.234i 1.0+1.0i) 0.40518638573744)+(num-test (= 0.0+1.0i 1.234+1.234i 1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1.234+1.234i 0) 1.234+2.234i)+(num-test (- 0.0+1.0i 1.234+1.234i 0) -1.234-0.234i)+(num-test (* 0.0+1.0i 1.234+1.234i 0) -0.0)+(num-test (+ 0.0+1.0i 1.234+1.234i 0.0) 1.234+2.234i)+(num-test (- 0.0+1.0i 1.234+1.234i 0.0) -1.234-0.234i)+(num-test (* 0.0+1.0i 1.234+1.234i 0.0) -0.0)+(num-test (+ 0.0+1.0i 1.234+1.234i 1234) 1235.23399999999992+2.234i)+(num-test (- 0.0+1.0i 1.234+1.234i 1234) -1235.23399999999992-0.234i)+(num-test (* 0.0+1.0i 1.234+1.234i 1234) -1522.756+1522.756i)+(num-test (/ 0.0+1.0i 1.234+1.234i 1234) 0.00032835201437+0.00032835201437i)+(num-test (= 0.0+1.0i 1.234+1.234i 1234) #f)+(num-test (+ 0.0+1.0i 1.234+1.234i 123.4) 124.634+2.234i)+(num-test (- 0.0+1.0i 1.234+1.234i 123.4) -124.634-0.234i)+(num-test (* 0.0+1.0i 1.234+1.234i 123.4) -152.2756+152.2756i)+(num-test (/ 0.0+1.0i 1.234+1.234i 123.4) 0.00328352014374+0.00328352014374i)+(num-test (= 0.0+1.0i 1.234+1.234i 123.4) #f)+(num-test (+ 0.0+1.0i 1.234+1.234i 1234/11) 113.41581818181818+2.234i)+(num-test (- 0.0+1.0i 1.234+1.234i 1234/11) -113.41581818181818-0.234i)+(num-test (* 0.0+1.0i 1.234+1.234i 1234/11) -138.43236363636365+138.43236363636365i)+(num-test (/ 0.0+1.0i 1.234+1.234i 1234/11) 0.00361187215811+0.00361187215811i)+(num-test (= 0.0+1.0i 1.234+1.234i 1234/11) #f)+(num-test (+ 0.0+1.0i 1.234+1.234i 1.234+1.234i) 2.468+3.468i)+(num-test (- 0.0+1.0i 1.234+1.234i 1.234+1.234i) -2.468-1.468i)+(num-test (* 0.0+1.0i 1.234+1.234i 1.234+1.234i) -3.04551200000000)+(num-test (/ 0.0+1.0i 1.234+1.234i 1.234+1.234i) 0.32835201437394)+(num-test (= 0.0+1.0i 1.234+1.234i 1.234+1.234i) #f)+(num-test (+ 0.0+1.0i 1.234+1.234i -1.0+1.0i) 0.234+3.234i)+(num-test (- 0.0+1.0i 1.234+1.234i -1.0+1.0i) -0.234-1.234i)+(num-test (* 0.0+1.0i 1.234+1.234i -1.0+1.0i) 0.0-2.468i)+(num-test (/ 0.0+1.0i 1.234+1.234i -1.0+1.0i) -0.0-0.40518638573744i)+(num-test (= 0.0+1.0i 1.234+1.234i -1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 1.234+1.234i 0.0+1.0i) 1.234+3.234i)+(num-test (- 0.0+1.0i 1.234+1.234i 0.0+1.0i) -1.234-1.234i)+(num-test (* 0.0+1.0i 1.234+1.234i 0.0+1.0i) -1.234-1.234i)+(num-test (/ 0.0+1.0i 1.234+1.234i 0.0+1.0i) 0.40518638573744-0.40518638573744i)+(num-test (= 0.0+1.0i 1.234+1.234i 0.0+1.0i) #f)+(num-test (+ 0.0+1.0i -1.0+1.0i 1) 0.0+2.0i)+(num-test (- 0.0+1.0i -1.0+1.0i 1) 0.0)+(num-test (* 0.0+1.0i -1.0+1.0i 1) -1.0-1.0i)+(num-test (/ 0.0+1.0i -1.0+1.0i 1) 0.5-0.5i)+(num-test (= 0.0+1.0i -1.0+1.0i 1) #f)+(num-test (+ 0.0+1.0i -1.0+1.0i 1.0) 0.0+2.0i)+(num-test (- 0.0+1.0i -1.0+1.0i 1.0) 0.0)+(num-test (* 0.0+1.0i -1.0+1.0i 1.0) -1.0-1.0i)+(num-test (/ 0.0+1.0i -1.0+1.0i 1.0) 0.5-0.5i)+(num-test (= 0.0+1.0i -1.0+1.0i 1.0) #f)+(num-test (+ 0.0+1.0i -1.0+1.0i 1/1) 0.0+2.0i)+(num-test (- 0.0+1.0i -1.0+1.0i 1/1) 0.0)+(num-test (* 0.0+1.0i -1.0+1.0i 1/1) -1.0-1.0i)+(num-test (/ 0.0+1.0i -1.0+1.0i 1/1) 0.5-0.5i)+(num-test (= 0.0+1.0i -1.0+1.0i 1/1) #f)+(num-test (+ 0.0+1.0i -1.0+1.0i 1.0+1.0i) 0.0+3.0i)+(num-test (- 0.0+1.0i -1.0+1.0i 1.0+1.0i) 0.0-1.0i)+(num-test (* 0.0+1.0i -1.0+1.0i 1.0+1.0i) 0.0-2.0i)+(num-test (/ 0.0+1.0i -1.0+1.0i 1.0+1.0i) 0.0-0.5i)+(num-test (= 0.0+1.0i -1.0+1.0i 1.0+1.0i) #f)+(num-test (+ 0.0+1.0i -1.0+1.0i 0) -1.0+2.0i)+(num-test (- 0.0+1.0i -1.0+1.0i 0) 1.0)+(num-test (* 0.0+1.0i -1.0+1.0i 0) 0.0)+(num-test (+ 0.0+1.0i -1.0+1.0i 0.0) -1.0+2.0i)+(num-test (- 0.0+1.0i -1.0+1.0i 0.0) 1.0)+(num-test (* 0.0+1.0i -1.0+1.0i 0.0) 0.0)+(num-test (+ 0.0+1.0i -1.0+1.0i 1234) 1233.0+2.0i)+(num-test (- 0.0+1.0i -1.0+1.0i 1234) -1233.0)+(num-test (* 0.0+1.0i -1.0+1.0i 1234) -1234.0-1234.0i)+(num-test (/ 0.0+1.0i -1.0+1.0i 1234) 0.00040518638574-0.00040518638574i)+(num-test (= 0.0+1.0i -1.0+1.0i 1234) #f)+(num-test (+ 0.0+1.0i -1.0+1.0i 123.4) 122.4+2.0i)+(num-test (- 0.0+1.0i -1.0+1.0i 123.4) -122.4)+(num-test (* 0.0+1.0i -1.0+1.0i 123.4) -123.4-123.4i)+(num-test (/ 0.0+1.0i -1.0+1.0i 123.4) 0.00405186385737-0.00405186385737i)+(num-test (= 0.0+1.0i -1.0+1.0i 123.4) #f)+(num-test (+ 0.0+1.0i -1.0+1.0i 1234/11) 111.18181818181819+2.0i)+(num-test (- 0.0+1.0i -1.0+1.0i 1234/11) -111.18181818181819)+(num-test (* 0.0+1.0i -1.0+1.0i 1234/11) -112.18181818181819-112.18181818181819i)+(num-test (/ 0.0+1.0i -1.0+1.0i 1234/11) 0.00445705024311-0.00445705024311i)+(num-test (= 0.0+1.0i -1.0+1.0i 1234/11) #f)+(num-test (+ 0.0+1.0i -1.0+1.0i 1.234+1.234i) 0.234+3.234i)+(num-test (- 0.0+1.0i -1.0+1.0i 1.234+1.234i) -0.234-1.234i)+(num-test (* 0.0+1.0i -1.0+1.0i 1.234+1.234i) 0.0-2.468i)+(num-test (/ 0.0+1.0i -1.0+1.0i 1.234+1.234i) 0.0-0.40518638573744i)+(num-test (= 0.0+1.0i -1.0+1.0i 1.234+1.234i) #f)+(num-test (+ 0.0+1.0i -1.0+1.0i -1.0+1.0i) -2.0+3.0i)+(num-test (- 0.0+1.0i -1.0+1.0i -1.0+1.0i) 2.0-1.0i)+(num-test (* 0.0+1.0i -1.0+1.0i -1.0+1.0i) 2.0)+(num-test (/ 0.0+1.0i -1.0+1.0i -1.0+1.0i) -0.5)+(num-test (= 0.0+1.0i -1.0+1.0i -1.0+1.0i) #f)+(num-test (+ 0.0+1.0i -1.0+1.0i 0.0+1.0i) -1.0+3.0i)+(num-test (- 0.0+1.0i -1.0+1.0i 0.0+1.0i) 1.0-1.0i)+(num-test (* 0.0+1.0i -1.0+1.0i 0.0+1.0i) 1.0-1.0i)+(num-test (/ 0.0+1.0i -1.0+1.0i 0.0+1.0i) -0.5-0.5i)+(num-test (= 0.0+1.0i -1.0+1.0i 0.0+1.0i) #f)+(num-test (+ 0.0+1.0i 0.0+1.0i 1) 1.0+2.0i)+(num-test (- 0.0+1.0i 0.0+1.0i 1) -1.0)+(num-test (* 0.0+1.0i 0.0+1.0i 1) -1.0)+(num-test (/ 0.0+1.0i 0.0+1.0i 1) 1.0)+(num-test (= 0.0+1.0i 0.0+1.0i 1) #f)+(num-test (+ 0.0+1.0i 0.0+1.0i 1.0) 1.0+2.0i)+(num-test (- 0.0+1.0i 0.0+1.0i 1.0) -1.0)+(num-test (* 0.0+1.0i 0.0+1.0i 1.0) -1.0)+(num-test (/ 0.0+1.0i 0.0+1.0i 1.0) 1.0)+(num-test (= 0.0+1.0i 0.0+1.0i 1.0) #f)+(num-test (+ 0.0+1.0i 0.0+1.0i 1/1) 1.0+2.0i)+(num-test (- 0.0+1.0i 0.0+1.0i 1/1) -1.0)+(num-test (* 0.0+1.0i 0.0+1.0i 1/1) -1.0)+(num-test (/ 0.0+1.0i 0.0+1.0i 1/1) 1.0)+(num-test (= 0.0+1.0i 0.0+1.0i 1/1) #f)+(num-test (+ 0.0+1.0i 0.0+1.0i 1.0+1.0i) 1.0+3.0i)+(num-test (- 0.0+1.0i 0.0+1.0i 1.0+1.0i) -1.0-1.0i)+(num-test (* 0.0+1.0i 0.0+1.0i 1.0+1.0i) -1.0-1.0i)+(num-test (/ 0.0+1.0i 0.0+1.0i 1.0+1.0i) 0.5-0.5i)+(num-test (= 0.0+1.0i 0.0+1.0i 1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 0.0+1.0i 0) 0.0+2.0i)+(num-test (- 0.0+1.0i 0.0+1.0i 0) 0.0)+(num-test (* 0.0+1.0i 0.0+1.0i 0) -0.0)+(num-test (+ 0.0+1.0i 0.0+1.0i 0.0) 0.0+2.0i)+(num-test (- 0.0+1.0i 0.0+1.0i 0.0) 0.0)+(num-test (* 0.0+1.0i 0.0+1.0i 0.0) -0.0)+(num-test (+ 0.0+1.0i 0.0+1.0i 1234) 1234.0+2.0i)+(num-test (- 0.0+1.0i 0.0+1.0i 1234) -1234.0)+(num-test (* 0.0+1.0i 0.0+1.0i 1234) -1234.0)+(num-test (/ 0.0+1.0i 0.0+1.0i 1234) 0.00081037277147)+(num-test (= 0.0+1.0i 0.0+1.0i 1234) #f)+(num-test (+ 0.0+1.0i 0.0+1.0i 123.4) 123.4+2.0i)+(num-test (- 0.0+1.0i 0.0+1.0i 123.4) -123.4)+(num-test (* 0.0+1.0i 0.0+1.0i 123.4) -123.4)+(num-test (/ 0.0+1.0i 0.0+1.0i 123.4) 0.00810372771475)+(num-test (= 0.0+1.0i 0.0+1.0i 123.4) #f)+(num-test (+ 0.0+1.0i 0.0+1.0i 1234/11) 112.18181818181819+2.0i)+(num-test (- 0.0+1.0i 0.0+1.0i 1234/11) -112.18181818181819)+(num-test (* 0.0+1.0i 0.0+1.0i 1234/11) -112.18181818181819)+(num-test (/ 0.0+1.0i 0.0+1.0i 1234/11) 0.00891410048622)+(num-test (= 0.0+1.0i 0.0+1.0i 1234/11) #f)+(num-test (+ 0.0+1.0i 0.0+1.0i 1.234+1.234i) 1.234+3.234i)+(num-test (- 0.0+1.0i 0.0+1.0i 1.234+1.234i) -1.234-1.234i)+(num-test (* 0.0+1.0i 0.0+1.0i 1.234+1.234i) -1.234-1.234i)+(num-test (/ 0.0+1.0i 0.0+1.0i 1.234+1.234i) 0.40518638573744-0.40518638573744i)+(num-test (= 0.0+1.0i 0.0+1.0i 1.234+1.234i) #f)+(num-test (+ 0.0+1.0i 0.0+1.0i -1.0+1.0i) -1.0+3.0i)+(num-test (- 0.0+1.0i 0.0+1.0i -1.0+1.0i) 1.0-1.0i)+(num-test (* 0.0+1.0i 0.0+1.0i -1.0+1.0i) 1.0-1.0i)+(num-test (/ 0.0+1.0i 0.0+1.0i -1.0+1.0i) -0.5-0.5i)+(num-test (= 0.0+1.0i 0.0+1.0i -1.0+1.0i) #f)+(num-test (+ 0.0+1.0i 0.0+1.0i 0.0+1.0i) 0.0+3.0i)+(num-test (- 0.0+1.0i 0.0+1.0i 0.0+1.0i) 0.0-1.0i)+(num-test (* 0.0+1.0i 0.0+1.0i 0.0+1.0i) -0.0-1.0i)+(num-test (/ 0.0+1.0i 0.0+1.0i 0.0+1.0i) 0.0-1.0i)+(num-test (= 0.0+1.0i 0.0+1.0i 0.0+1.0i) #t)++(num-test (+ 1073741824 1073741824 1073741824 1073741824) (* 4 1073741824))++(num-test (+ 0.6049332056786565E0 -0.9611373574853808E0) -3.562041518067242999999999999999999999981E-1)+(num-test (+ -0.4763715667865308E0 0.25936932107685584E0) -2.170022457096749600000000000000000000008E-1)+(num-test (+ 0.2666481927718355E0 -0.04984768063142031E0) 2.168005121404151899999999999999999999994E-1)+(num-test (+ -0.29478659758474846E0 0.3371004337672615E0) 4.231383618251304000000000000000000000076E-2)+(num-test (+ 0.8203063910979178E0 0.28968607542857916E0) 1.109992466526496959999999999999999999999E0)+(num-test (+ -0.08207985138263585E0 0.4368723951711785E0) 3.5479254378854265E-1)+(num-test (+ -0.8659875373355486E0 -6.631430771196765E9) -6.6314307720627525373355486E9)+(num-test (+ 0.15071385783307878E0 -7.154424279496395E9) -7.154424279345681142166921220000000000013E9)+(num-test (+ -0.8969642760814789E0 -2.4070067380831727E8) -2.407006747052815460814789000000000000005E8)+(num-test (+ -0.9610362081435054E0 9.070410778399954E9) 9.070410777438917634019580537500000000004E9)+(num-test (+ 0.5129052501104072E0 -7.47841120327471E9) -7.478411202761804451427678737500000000008E9)+(num-test (+ 0.3840242289740675E0 7.793048210060242E9) 7.793048210444265928192817499999999999991E9)+(num-test (+ 0.07603066126204616E0 5.215008470388369E-11) 7.603066131419624470388369000000000000006E-2)+(num-test (+ -0.17187858025312586E0 -5.116645189173968E-11) -1.718785803042923118917396799999999999997E-1)+(num-test (+ 0.2521315816245864E0 8.603210607505339E-11) 2.521315817106185060750533899999999999992E-1)+(num-test (+ -0.3557185853193914E0 -2.0371324697272998E-11) -3.557185853397627246972729979999999999995E-1)+(num-test (+ 0.7142792289542045E0 -7.106356053331326E-11) 7.142792288831409394666867399999999999997E-1)+(num-test (+ 0.4380415886629452E0 -3.069969538383403E-11) 4.380415886322455046161659700000000000005E-1)+(num-test (+ 0.24798614227178573E0 3.972393639614975E19) 3.972393639614975000024798614227178572989E19)+(num-test (+ -0.5210677288128815E0 4.846393336901129E19) 4.846393336901128999947893227118711850007E19)+(num-test (+ 0.5825404819115E0 1.9710987361264255E19) 1.971098736126425500058254048191149998548E19)+(num-test (+ 0.9105175208730549E0 2.391166552096775E19) 2.391166552096775000091051752087305489998E19)+(num-test (+ 0.48414423368371695E0 -9.696117779740095E19) -9.696117779740094999951585576631628304997E19)+(num-test (+ 0.25780758450697716E0 6.094683117025535E19) 6.094683117025535000025780758450697715991E19)+(num-test (+ 0.9824539149570484E0 -5.4680066990812835E-21) 9.824539149570483999945319933009187165013E-1)+(num-test (+ -0.9520982941158654E0 3.2513564801568073E-21) -9.520982941158653999967486435198431927013E-1)+(num-test (+ 0.0630170624560149E0 -9.858852595793203E-21) 6.301706245601489999014114740420679700008E-2)+(num-test (+ 0.24705141169888878E0 1.4582081178692862E-22) 2.470514116988887800001458208117869286195E-1)+(num-test (+ 0.7440948700757135E0 -3.0932442581890818E-21) 7.440948700757134999969067557418109181978E-1)+(num-test (+ -0.5055970869515372E0 4.0277457257516025E-21) -5.055970869515371999959722542742483974988E-1)+(num-test (+ 1.672355787134947E9 0.0064909681594120805E0) 1.6723557871414380296981083695625E9)+(num-test (+ -9.694504381396599E9 -0.8925470085542831E0) -9.694504382289146008554283099999999999987E9)+(num-test (+ -1.6695005924298635E9 -0.34426964741306E0) -1.669500592774133147413059987073324919041E9)+(num-test (+ -6.085591212594774E9 0.5107956920100049E0) -6.085591212083978307989995100000000000004E9)+(num-test (+ 7.457486660952688E9 -0.4323787588338597E0) 7.457486660520309458329226237499999999989E9)+(num-test (+ -8.790796444526546E9 0.911415263281967E0) -8.790796443615130736718033019187146237507E9)+(num-test (+ 9.667548804251982E9 -1.266547751029956E8) 9.54089402914898613522949218749999999999E9)+(num-test (+ -6.169561898845145E9 9.627911197121864E9) 3.458349298276719318847656250000000000009E9)+(num-test (+ -9.870287253215279E9 9.004242781937655E8) -8.969862975021513478950500488281249999995E9)+(num-test (+ -8.175630881172554E9 -4.08632236263908E9) -1.226195324381163404760742187500000000002E10)+(num-test (+ 2.9069444232153206E9 -7.961831315741894E9) -5.054886892526573399999999999999999999977E9)+(num-test (+ -7.003647401371184E9 -1.768371514817526E9) -8.772018916188710000000000000000000000001E9)+(num-test (+ -6.418847599138249E9 2.755257250162372E-11) -6.418847599138248999972447427498376279997E9)+(num-test (+ 2.3093152687241793E9 1.2205440142364766E-11) 2.309315268724179300012205440142364766011E9)+(num-test (+ 8.634577667577518E9 -9.065714034538668E-11) 8.634577667577518463044108484654613319994E9)+(num-test (+ 1.711283212591781E9 -3.235019197733951E-11) 1.71128321259178090092285000333516049E9)+(num-test (+ 2.583886638357791E9 -8.199109798920928E-11) 2.583886638357790946878458120760790719997E9)+(num-test (+ -7.517123950474774E9 5.2057802142431697E-11) -7.51712395047477399994794219785756830298E9)+(num-test (+ 3.266571938086574E9 -4.4782768261898355E19) -4.478276825863178306191342592239379882812E19)+(num-test (+ 2.1000389219899452E9 -8.547158903365463E19) -8.547158903155459107801005480000000000002E19)+(num-test (+ -3.9140926801217155E9 7.387959860641422E19) 7.387959860250012731987828450000000000009E19)+(num-test (+ -7.087607465790431E9 7.96875093387599E19) 7.968750933167229781420956900000000000008E19)+(num-test (+ -8.341000808926519E9 6.9360028397637304E19) 6.936002838929630319107348100000000000009E19)+(num-test (+ -5.507940634743809E9 9.760028858210094E19) 9.760028857659299936525619099999999999989E19)+(num-test (+ 8.492522971238823E9 -2.8253881864964467E-22) 8.492522971238822937011718749999717461174E9)+(num-test (+ 1.2731765723336241E9 -5.8473937102910264E-21) 1.273176572333624099999999999994152606294E9)+(num-test (+ 9.654280758878323E9 -4.2332114049658973E-22) 9.654280758878322601318359374999576678861E9)+(num-test (+ -6.864618926120946E9 -1.245648314796599E-21) -6.864618926120946000000000000001245648334E9)+(num-test (+ -3.9916044043798673E8 1.697737588450543E-21) -3.991604404379867299999999999983022624115E8)+(num-test (+ -7.818041624198686E9 4.635421587404246E-21) -7.818041624198685999999999999995364578418E9)+(num-test (+ 2.0609929543990767E-12 -0.2126306554359736E0) -2.126306554339126070456009232999999999998E-1)+(num-test (+ -1.5923091695877845E-11 0.515731533720818E0) 5.157315337048949444413677540931484848253E-1)+(num-test (+ 4.794527092905871E-11 -0.9066947202676092E0) -9.0669472021966392907094129E-1)+(num-test (+ -8.63854477728633E-11 0.3122982022565777E0) 3.122982021701922522271366999999999999999E-1)+(num-test (+ -7.577966666552416E-11 -0.24137602092437593E0) -2.413760210001555966655241600000000000004E-1)+(num-test (+ -4.971730475882754E-11 -0.8202688719750202E0) -8.202688720247375047588275400000000000012E-1)+(num-test (+ -5.249369194379291E-11 -8.546120620321186E9) -8.546120620321186000052493691943792910002E9)+(num-test (+ 8.280786962526793E-11 5.758373397436368E9) 5.758373397436367988669233650875267930002E9)+(num-test (+ 6.370323595535815E-11 -8.470663335712393E9) -8.470663335712392999936296764044641849996E9)+(num-test (+ 3.59771226839467E-11 3.5042505440266216E8) 3.504250544026621600359771226839466999997E8)+(num-test (+ -3.945501687396375E-11 -5.082779978069177E9) -5.082779978069177000039455016873963749988E9)+(num-test (+ 9.780590963267516E-11 -5.05591945120475E9) -5.055919451204750060937350340367324839998E9)+(num-test (+ 6.323293597096768E-11 -7.208898910487284E-11) -8.856053133905159999999999999999999999986E-12)+(num-test (+ -4.549781732354749E-11 -6.095452636416357E-11) -1.064523436877110600000000000000000000002E-10)+(num-test (+ -5.372680267837374E-11 2.0748354219485134E-11) -3.297844845888860599999999999999999999998E-11)+(num-test (+ 3.550879553916665E-11 -4.374873254056574E-11) -8.239937001399090000000000000000000000007E-12)+(num-test (+ -6.746002242414832E-11 3.0803985031459436E-11) -3.665603739268888400000000000000000000013E-11)+(num-test (+ -7.902512161494214E-11 -8.907842858073236E-11) -1.681035501956744999999999999999999999998E-10)+(num-test (+ -4.1465935469350415E-11 6.244210696961323E19) 6.24421069696132299999999999999585340645E19)+(num-test (+ 4.921297536286578E-11 -1.694436650099881E19) -1.694436650099880999999999999995078702462E19)+(num-test (+ -7.879478980672654E-11 6.41757969360492E19) 6.41757969360491970559999999999212052103E19)+(num-test (+ -8.200749317872953E-11 -9.490225542618815E19) -9.490225542618815000000000000008200749324E19)+(num-test (+ -7.572981329795812E-11 -3.350367078181029E19) -3.350367078181029000000000000007572981326E19)+(num-test (+ -5.955255565125549E-11 -5.009913629288125E19) -5.00991362928812500000000000000595525556E19)+(num-test (+ -9.818180775332558E-11 -7.926156011681593E-21) -9.818180776125173601168159300000000000011E-11)+(num-test (+ -5.2466438379505935E-12 8.468830229031857E-21) -5.246643829481763270968143000000000000009E-12)+(num-test (+ 3.582774358441715E-11 3.6865211729351863E-22) 3.582774358478580211729351862999999999999E-11)+(num-test (+ 7.169296413565744E-11 -9.974881413980864E-21) 7.169296412568255858601913599999999999987E-11)+(num-test (+ -9.615073655516977E-11 4.9552491300097786E-21) -9.615073655021452086999022140000000000005E-11)+(num-test (+ 6.7696956269187E-11 4.1431488006404866E-21) 6.769695627333015423852294397336791395272E-11)+(num-test (+ -4.663397365185298E19 0.9758464195927673E0) -4.663397365185297999902415358040723270005E19)+(num-test (+ -4.77977261393851E19 0.04145189313162445E0) -4.779772613938509999995854810686837555009E19)+(num-test (+ 7.195364554121596E19 0.5169917736820715E0) 7.195364554121596000051699177368207149992E19)+(num-test (+ -7.766254779507882E19 0.5919134938460356E0) -7.766254779507881999940808650615396440016E19)+(num-test (+ -8.411122653901408E19 -0.14463225181516137E0) -8.411122653901408000014463225181516137013E19)+(num-test (+ -9.101920591747218E19 0.23349918704239836E0) -9.101920591747217999976650081295760164003E19)+(num-test (+ 7.037477746142529E18 -3.250947575909365E9) 7.037477742891581424090634999999999999988E18)+(num-test (+ -6.864341752972099E19 -4.0510449339565725E9) -6.864341753377203493395657250000000000004E19)+(num-test (+ -5.329540273290228E19 8.14869777458878E9) -5.329540272475358222541121959686279296875E19)+(num-test (+ -9.726234388247201E19 2.053976989398215E9) -9.726234388041803301060178494453430175781E19)+(num-test (+ -1.910324088450308E19 6.247052535748024E9) -1.910324087825602746425197601318359375E19)+(num-test (+ -6.079933001949367E18 6.316829148809886E9) -6.07993299563253785119011402130126953125E18)+(num-test (+ -4.499107911798452E19 9.659763881732633E-11) -4.499107911798451999999999999990340236126E19)+(num-test (+ -3.0972208018542522E19 -9.077209886078653E-11) -3.097220801854252200000000000009077209882E19)+(num-test (+ -2.3000547840875442E19 -3.2043634522621155E-11) -2.300054784087544200000000000003204363456E19)+(num-test (+ 2.124555308489292E19 2.252166800652451E-11) 2.124555308489292000000000000002252166802E19)+(num-test (+ -7.74280238703686E19 1.7289553748884322E-11) -7.74280238703685999999999999999827104461E19)+(num-test (+ -8.119446783121816E19 -4.3461802389685114E-11) -8.11944678312181600000000000000434618023E19)+(num-test (+ -4.70848534032654E18 -4.698316648967506E19) -5.16916518300016E19)+(num-test (+ 2.853799842810312E19 -5.56805968603395E19) -2.714259843223638E19)+(num-test (+ -2.9128622996090335E19 -5.153369106520702E19) -8.0662314061297355E19)+(num-test (+ -5.415993984772977E19 4.481932558278175E19) -9.34061426494802E18)+(num-test (+ -1.4652301908531261E19 7.89284449966826E19) 6.4276143088151335352E19)+(num-test (+ -8.241911630479252E19 5.377001886877124E19) -2.864909743602128E19)+(num-test (+ -6.923631123395076E19 7.100129853298664E-22) -6.923631123395076E19)+(num-test (+ -5.864213410820717E19 -2.649878514627326E-21) -5.864213410820717E19)+(num-test (+ 8.660575002861176E19 2.751926085897399E-21) 8.660575002861176E19)+(num-test (+ -3.0252871646631318E19 6.852831573716124E-21) -3.0252871646631318E19)+(num-test (+ -9.155476807340938E19 -5.552907466957205E-21) -9.155476807340938E19)+(num-test (+ -4.03382621358461E19 6.670808279457885E-21) -4.03382621358461E19)+(num-test (+ 8.842980509187577E-21 0.5028466982188534E0) 5.028466982188534000088429805091875769998E-1)+(num-test (+ 1.7292043381396136E-21 0.19490424064972922E0) 1.949042406497292200017292043381396136E-1)+(num-test (+ -5.854820918836103E-21 -0.6700030154364615E0) -6.700030154364615000058548209188361029995E-1)+(num-test (+ -2.152396491682048E-21 0.5002930268902921E0) 5.002930268902920999978476035083179519998E-1)+(num-test (+ -1.0897149666610629E-21 0.16555534170490604E0) 1.655553417049060399989102850333389370996E-1)+(num-test (+ 6.321421497987867E-24 -0.08008112131564671E0) -8.008112131564670999999367857850201213302E-2)+(num-test (+ -6.1552667309563055E-21 7.235074489769488E9) 7.23507448976948833465576171874384473328E9)+(num-test (+ -2.2311335001219955E-22 1.220011008333989E9) 1.220011008333988904953002929687276886647E9)+(num-test (+ 8.523565724937177E-23 -4.1650242034123087E9) -4.165024203412308699999999999999914764338E9)+(num-test (+ -2.4400041303825447E-21 4.435554678685388E9) 4.435554678685387611389160156247559995867E9)+(num-test (+ -3.4479065449345757E-22 8.491084033112451E8) 8.491084033112450838088989257809052093456E8)+(num-test (+ -7.919939059912893E-21 -7.610637842585286E9) -7.610637842585286000000000000007919939044E9)+(num-test (+ 4.4958602369105625E-21 5.758376768873417E-11) 5.758376769323003023691056249999999999989E-11)+(num-test (+ 2.4375297386412195E-21 9.417086717671841E-11) 9.41708671791559397386412194999999999998E-11)+(num-test (+ 1.0040647133383462E-21 3.4701016271268983E-12) 3.470101628130963013338346199999999999999E-12)+(num-test (+ -3.885093055726793E-21 -8.523534862249969E-11) -8.523534862638478305572679299999999999995E-11)+(num-test (+ 1.027951323422187E-21 -7.65508060829868E-11) -7.655080608195884867657781300000000000011E-11)+(num-test (+ -9.83813940552434E-21 -5.048380063082019E-11) -5.048380064065832940552434000000000000001E-11)+(num-test (+ -7.640856498925806E-21 -5.743808556015994E19) -5.743808556015994E19)+(num-test (+ 8.053891045717591E-21 4.0840032650134725E19) 4.0840032650134725E19)+(num-test (+ -4.794782783871528E-21 -3.431216587740782E18) -3.431216587740782E18)+(num-test (+ 1.860870988390988E-21 -3.757945694933625E19) -3.757945694933625E19)+(num-test (+ 5.445498222566789E-21 7.575823566817991E19) 7.575823566817991E19)+(num-test (+ 2.631896745307223E-21 4.906449817201212E19) 4.906449817201212E19)+(num-test (+ -6.61689881073516E-21 5.357007670385275E-21) -1.25989114034988500000000000000000000001E-21)+(num-test (+ 3.0173001109587537E-21 5.2947222461350496E-21) 8.312022357093803300000000000000000000009E-21)+(num-test (+ -8.792518441030627E-21 -1.0516787854168774E-21) -9.84419722644750439999999999999999999997E-21)+(num-test (+ 7.349451992884509E-21 -8.427997362671486E-21) -1.078545369786976999999999999999999999993E-21)+(num-test (+ -7.881179611953633E-21 3.2080446524364824E-21) -4.673134959517150599999999999999999999987E-21)+(num-test (+ -9.614117725927607E-21 -5.35667712698602E-21) -1.4970794852913627E-20)+(num-test (- -0.011326914400453525E0 -0.6668141757661364E0) 6.554872613656828749999999999999999999976E-1)+(num-test (- -0.46185382764946437E0 0.7488210697846337E0) -1.210674897434098070000000000000000000001E0)+(num-test (- -0.35834120541234993E0 -0.30919976341834987E0) -4.914144199400005999999999999999999999972E-2)+(num-test (- 0.44705025064976966E0 -0.9277893553610955E0) 1.374839606010865160000000000000000000002E0)+(num-test (- -0.47647537517067917E0 0.29158058381073604E0) -7.680559589814152099999999999999999999997E-1)+(num-test (- -0.021697999002707746E0 0.1779871773524142E0) -1.996851763551219460000000000000000000001E-1)+(num-test (- 0.4179484378019861E0 9.9990307469939E9) -9.999030746575951861270279525000000000019E9)+(num-test (- -0.7475415524823718E0 1.3993312799214797E9) -1.399331280669021252482371799999999999998E9)+(num-test (- 0.2519442433861928E0 -6.699632771871848E9) 6.699632772123792243386192799999999999993E9)+(num-test (- -0.5124988631497671E0 2.7959244812290273E9) -2.795924481741526163149767100000000000009E9)+(num-test (- -0.6870193827604301E0 4.851102442573468E9) -4.851102443260487591073418381249999999995E9)+(num-test (- 0.7609656780357723E0 7.481252865855436E8) -7.481252858245779544715519187499999999991E8)+(num-test (- -0.6301276042170191E0 -7.099314875214215E-11) -6.301276041460259512478578500000000000002E-1)+(num-test (- -0.4139053484357884E0 -2.897413526398709E-11) -4.139053484068142647360129100000000000006E-1)+(num-test (- -0.6944623060197281E0 -3.291569879873739E-11) -6.94462305986812401201262610000000000001E-1)+(num-test (- -0.2057822500703933E0 3.6505182026159854E-11) -2.057822501068984820261598540000000000004E-1)+(num-test (- -0.8792706674467908E0 8.094527736950817E-11) -8.792706675277360773695081699999999999978E-1)+(num-test (- -0.6888184243601332E0 9.127622796988807E-11) -6.888184244514094279698880700000000000006E-1)+(num-test (- -0.980711030497252E0 8.752272461345245E19) -8.752272461345245000098071103049725200009E19)+(num-test (- 0.8035082489836539E0 -3.903355151264917E19) 3.90335515126491700008035082489836539001E19)+(num-test (- -0.7537841372394811E0 -5.879942447417834E19) 5.879942447417833999924621586276051889998E19)+(num-test (- -0.6877475951546845E0 -2.3972266191169642E19) 2.397226619116964199931225240484531550001E19)+(num-test (- -0.43128282112433525E0 -5.422824998003439E19) 5.422824998003438999956871717887566474998E19)+(num-test (- 0.29538116818276694E0 1.1291858990580939E19) -1.129185899058093899970461883181723306002E19)+(num-test (- 0.9166687388673976E0 6.395175407123937E-21) 9.166687388673975999936048245928760629984E-1)+(num-test (- 0.41840538498193025E0 -2.6655662412599155E-21) 4.18405384981930250002665566241259915501E-1)+(num-test (- -0.8036940092501853E0 6.7473779576832565E-21) -8.036940092501853000067473779576832565009E-1)+(num-test (- 0.8555054025209989E0 -7.939970418096797E-21) 8.55505402520998900007939970418096796999E-1)+(num-test (- 0.3365495704567003E0 8.694519827555395E-21) 3.365495704567002999913054801724446050001E-1)+(num-test (- -0.7430322011471231E0 7.430332379292914E-22) -7.430322011471231000007430332379292914019E-1)+(num-test (- 5.102372414731216E9 -0.5073635765350494E0) 5.102372415238580007199111899999999999994E9)+(num-test (- 4.629827365822252E9 0.6534380055543355E0) 4.629827365168814268005234812499999999993E9)+(num-test (- 7.218192507117569E9 0.9781542046565127E0) 7.21819250613941476507004979999999999999E9)+(num-test (- 6.595760326622413E8 0.7339510561932947E0) 6.595760319282902834902380148437500000014E8)+(num-test (- 7.191166637703489E9 0.80792475493853E0) 7.191166636895564548650337188817616151937E9)+(num-test (- -7.95531405213956E9 0.5353636841430115E0) -7.955314052674923429931585718750000000006E9)+(num-test (- 5.438904545553836E8 6.533536518165114E9) -5.98964606360973083972930908203125E9)+(num-test (- -7.389650313101625E8 -9.983943153365381E9) 9.244978122055218499999999999999999999979E9)+(num-test (- 8.364404619492165E9 -7.600563055115287E9) 1.596496767460745161181640624999999999997E10)+(num-test (- 2.070813748323649E9 6.421052769114957E9) -4.350239020791307926177978515625E9)+(num-test (- -2.8555256820439434E9 -3.4077342921686625E8) -2.514752252827077150000000000000000000005E9)+(num-test (- 9.147878229420991E8 8.439982790150545E9) -7.525194967208446025848388671875E9)+(num-test (- -4.315772980070098E9 -6.48869466068404E-11) -4.315772980070097999935113053393159599999E9)+(num-test (- -3.5186299785635023E9 3.990046539849716E-11) -3.518629978563502300039900465398497159997E9)+(num-test (- 2.5645532837267537E9 8.566645694205622E-13) 2.564553283726753699999143335430579437802E9)+(num-test (- 6.145110896031829E9 -9.242734002954773E-11) 6.145110896031828880402485933779547730013E9)+(num-test (- -6.6836855975624E9 9.117930361283473E-11) -6.683685597562399864287956647362834729995E9)+(num-test (- -1.7472828462085754E8 -5.125838712019503E-11) -1.747282846208575399487416128798049699998E8)+(num-test (- 9.05675399397055E9 9.086705650502484E19) -9.0867056495968086006029449462890625E19)+(num-test (- -5.834806594586836E9 9.981576053842906E19) -9.981576054426386659458683599999999999999E19)+(num-test (- 3.047010922754272E9 1.1715352070471352E19) -1.171535206742434107724572801589965820312E19)+(num-test (- 7.294295638574767E9 2.845702947515113E19) -2.845702946785683436142523288726806640625E19)+(num-test (- 8.264143132493019E9 -1.6322956072452289E19) 1.632295608071643213249301910400390625E19)+(num-test (- -9.597823287256088E9 3.954126758718671E19) -3.95412675967845332872560880000000000001E19)+(num-test (- 3.229389511771705E9 -4.329831377266493E-21) 3.229389511771705150604248046879329831377E9)+(num-test (- 6.897089200279753E9 2.4428208790287663E-21) 6.897089200279752731323242187497557179116E9)+(num-test (- 2.3579775300187545E9 4.729400988996349E-21) 2.357977530018754499999999999995270599018E9)+(num-test (- 1.6718929117460046E9 5.8162277016717065E-21) 1.671892911746004599999999999994183772301E9)+(num-test (- 2.537177500868296E9 1.4856605280697543E-21) 2.537177500868296146392822265623514339469E9)+(num-test (- 6.117674696930935E9 -1.6187214719634357E-21) 6.117674696930934906005859375001618721474E9)+(num-test (- 4.1877888304549216E-11 -0.06920550501017497E0) 6.920550505205285830454921600000000000007E-2)+(num-test (- 9.61054846124015E-11 0.885309193732889E0) -8.85309193636783481398417376384291797877E-1)+(num-test (- 2.5559085051828467E-11 -0.8112181469812297E0) 8.112181470067887850518284670000000000006E-1)+(num-test (- -1.4549570208293283E-12 -0.5049325945871657E0) 5.049325945857107429791706717000000000005E-1)+(num-test (- -7.091628047158497E-11 0.61946884965934E0) -6.194688497302562955729347334266968816526E-1)+(num-test (- 2.877466355456826E-11 0.4496491857374E0) -4.49649185708625317645189543551619872451E-1)+(num-test (- 1.3041612488449928E-12 5.408018587130755E9) -5.40801858713075542449820755750115500719E9)+(num-test (- -5.379752339715717E-11 -4.009594691514288E9) 4.009594691514287999946202476602842829998E9)+(num-test (- 7.023042501342336E-12 -3.4153434285746374E9) 3.415343428574637400007023042501342336004E9)+(num-test (- 6.968174934871611E-11 4.713087404332662E9) -4.713087404332661628653462781901283890003E9)+(num-test (- -5.153562653896506E-11 -8.44732228013254E8) 8.447322280132540463885888851797849400006E8)+(num-test (- -8.424177457818745E-11 1.6817117809824567E9) -1.681711780982456700084241774578187449998E9)+(num-test (- 3.374755984316538E-11 8.893678266883364E-11) -5.518922282566826000000000000000000000009E-11)+(num-test (- -8.684123447823306E-11 -7.888825869147879E-11) -7.952975786754269999999999999999999999987E-12)+(num-test (- 7.788477523205632E-11 1.741674745286914E-11) 6.046802777918717999999999999999999999988E-11)+(num-test (- 6.546622477606044E-11 -4.7719651007530584E-11) 1.131858757835910240000000000000000000001E-10)+(num-test (- -1.8595152377503265E-11 5.7288738553553045E-11) -7.588389093105630999999999999999999999984E-11)+(num-test (- -8.184033550427558E-11 -8.834399228929296E-11) 6.503656785017380000000000000000000000234E-12)+(num-test (- 5.749469292140762E-11 7.493129199779113E19) -7.493129199779112999999999999994250530697E19)+(num-test (- -5.2285095120702066E-11 -2.0611179974216552E19) 2.061117997421655199999999999994771490491E19)+(num-test (- -8.84727820032067E-11 4.7423077384022024E19) -4.742307738402202400000000000008847278205E19)+(num-test (- 3.437676989338625E-11 -3.5368755480277647E19) 3.536875548027764700000000000003437676988E19)+(num-test (- 2.2665031619145437E-11 -6.072845659234921E19) 6.072845659234921000000000000002266503153E19)+(num-test (- -8.429070146313393E-11 5.134329153614969E18) -5.134329153614969000000000000084290701453E18)+(num-test (- -9.009531819191212E-11 2.301790665456671E-22) -9.009531819214229906654566710000000000025E-11)+(num-test (- -2.706942469371907E-11 9.282350542107287E-21) -2.706942470300142054210728700000000000001E-11)+(num-test (- 5.358266626996117E-11 -4.409057695582885E-22) 5.358266627040207576955828850000000000004E-11)+(num-test (- -7.189537285608088E-11 9.569273217393917E-21) -7.189537286565015321739391700000000000027E-11)+(num-test (- -4.160295905335358E-11 5.930867524794025E-21) -4.160295905928444752479402499999999999992E-11)+(num-test (- 6.7922062777334035E-12 -7.747524338474154E-22) 6.792206278508155933847415400000000000006E-12)+(num-test (- -9.038821102045805E19 0.04779131019959271E0) -9.038821102045805000004779131019959271002E19)+(num-test (- 2.2020595055495963E19 -0.424631558292516E0) 2.202059505549596300042463155829251600002E19)+(num-test (- -8.164003027214308E19 0.6832198147365239E0) -8.164003027214308000068321981473652389997E19)+(num-test (- -3.878233560364984E19 -0.28756619113600546E0) -3.878233560364983999971243380886399453999E19)+(num-test (- 7.0829003521450525E19 -0.6071548125948544E0) 7.08290035214505250006071548125948544E19)+(num-test (- 5.968540808784698E19 0.7674294173432648E0) 5.968540808784697999923257058265673519995E19)+(num-test (- -2.2143621795153547E19 -2.443529365769125E9) -2.214362179271001763423087500000000000004E19)+(num-test (- -9.77092538926342E18 5.903189771537687E8) -9.770925389853738977153768658638000488281E18)+(num-test (- 9.974714452399537E19 -6.980456691485629E9) 9.974714453097582669148562899999999999991E19)+(num-test (- 1.7428950527159094E18 3.68843657888816E9) 1.742895049027472821111839771270751953125E18)+(num-test (- -1.1094381875350845E19 -7.157723640671709E9) -1.109438186819312135932829100000000000002E19)+(num-test (- -3.638795590369631E19 6.9246542750294075E9) -3.638795591062096427502940750000000000005E19)+(num-test (- -5.66543282261991E19 -5.1005028153082024E-11) -5.665432822619909999999999999994899497189E19)+(num-test (- -3.901527864456216E19 -1.064153465992923E-12) -3.901527864456215999999999999999893584646E19)+(num-test (- 1.1477489418879848E19 3.327888063907735E-11) 1.147748941887984799999999999996672111937E19)+(num-test (- 3.508978072054437E19 9.238453417997638E-11) 3.508978072054436999999999999990761546584E19)+(num-test (- -4.7642024461416964E19 -4.758309941438892E-11) -4.764202446141696399999999999995241690065E19)+(num-test (- -8.307715835429606E19 3.313910202186439E-11) -8.307715835429606000000000000003313910214E19)+(num-test (- 2.704675010192592E18 -2.6840207147078365E19) 2.9544882157270957E19)+(num-test (- -9.860969100714668E18 -4.719594638795429E19) 3.7334977287239622E19)+(num-test (- 7.87799781828944E18 -6.657221298850535E19) 7.4450210806794789744E19)+(num-test (- -3.3937781740759863E19 4.783805995045389E19) -8.1775841691213753E19)+(num-test (- -1.0747572720102216E19 -1.7144708598072445E19) 6.397135877970229E18)+(num-test (- 1.3938845733158445E19 5.604369854609131E19) -4.2104852812932865E19)+(num-test (- 6.0938348303695315E19 1.1005522580049531E-21) 6.0938348303695315E19)+(num-test (- -2.4870844028694925E19 1.5391650322730598E-22) -2.4870844028694925E19)+(num-test (- 7.323118607079343E19 6.637280375859432E-21) 7.323118607079343E19)+(num-test (- -4.181201584825501E19 4.768935182006663E-21) -4.181201584825501E19)+(num-test (- 4.1225910279381205E19 6.117191687463543E-21) 4.1225910279381205E19)+(num-test (- 6.438313875980151E17 -1.4883489002691529E-21) 6.438313875980151E17)+(num-test (- -4.573961206963222E-21 0.3586300020381973E0) -3.586300020381973000045739612069632220001E-1)+(num-test (- 7.74206782371325E-22 0.23168389210368656E0) -2.316838921036865599992257932176286750005E-1)+(num-test (- 8.572446613640605E-21 0.6114581963443891E0) -6.114581963443890999914275533863593949978E-1)+(num-test (- -8.539467934859551E-21 0.33474735899049E0) -3.347473589904900182020371578704711119401E-1)+(num-test (- -5.55811309570968E-21 -0.9637216018651454E0) 9.637216018651453999944418869042903199998E-1)+(num-test (- -6.705839413964189E-21 0.3787619614522374E0) -3.787619614522374000067058394139641890005E-1)+(num-test (- 1.338539206480238E-22 6.683968625235106E9) -6.683968625235106468200683593749866146082E9)+(num-test (- -9.64078167549023E-21 3.291420859310843E9) -3.291420859310842990875244140634640781671E9)+(num-test (- -9.26536204591093E-22 2.9839295142529476E8) -2.98392951425294760000000000000926536205E8)+(num-test (- -3.647737608953592E-21 6.115300020921433E8) -6.115300020921432971954345703161477376078E8)+(num-test (- 1.4069763806331204E-21 -1.183109060480878E9) 1.18310906048087800000000000000140697638E9)+(num-test (- -6.0037865798761924E-21 -7.442246743849378E9) 7.442246743849377999999999999993996213425E9)+(num-test (- -5.994118986299138E-21 -9.091558282012836E-11) 9.091558281413424101370086199999999999991E-11)+(num-test (- 6.969393585974241E-21 3.435352867093995E-11) -3.435352866397055641402575899999999999989E-11)+(num-test (- -6.278554484817533E-22 -4.7211920270841604E-11) 4.721192027021374855151824670000000000001E-11)+(num-test (- -8.603262886304741E-21 1.7296517702077242E-11) -1.729651771068050488630474100000000000006E-11)+(num-test (- 4.104502790901735E-21 -4.8473213720301105E-11) 4.847321372440560779090173499999999999986E-11)+(num-test (- -4.449725859444968E-21 -8.944265568403936E-11) 8.944265567958963414055503200000000000002E-11)+(num-test (- 4.828216540804827E-21 -1.1712152029346877E19) 1.1712152029346877E19)+(num-test (- -5.65034940464881E-21 -9.445303840982011E19) 9.445303840982011E19)+(num-test (- -7.24107519738777E-21 2.340578690102746E19) -2.340578690102746E19)+(num-test (- 1.7659593956231534E-21 -8.048768257390671E18) 8.048768257390671E18)+(num-test (- -3.0538518255248124E-21 8.834631867521575E19) -8.834631867521575E19)+(num-test (- 8.57952908388053E-21 -5.730742870111307E19) 5.730742870111307E19)+(num-test (- -4.5090103564928485E-21 1.8907114777916313E-21) -6.399721834284479799999999999999999999996E-21)+(num-test (- -3.8487625143236447E-22 5.354282198078924E-21) -5.739158449511288470000000000000000000003E-21)+(num-test (- 2.6660110440404615E-22 3.833744224501756E-22) -1.167733180461294499999999999999999999996E-22)+(num-test (- -7.503762004261027E-22 -9.623906576475644E-21) 8.873530376049541300000000000000000000014E-21)+(num-test (- -9.113431042260725E-21 -3.5516521546085545E-21) -5.561778887652170499999999999999999999997E-21)+(num-test (- -3.4813735333296525E-21 -2.6602650182385188E-21) -8.211085150911336999999999999999999999942E-22)+(num-test (* -0.2554913394465045E0 0.27042187315261135E0) -6.909044658739340841916780452607499999997E-2)+(num-test (* -0.4489211233229662E0 -0.42892136850270857E0) 1.925518625654598642702435865603340000003E-1)+(num-test (* -0.44586465919973783E0 -0.15168042462027043E0) 6.762894083058839862686475970136690000031E-2)+(num-test (* 0.5509395670465355E0 0.3577558280766836E0) 1.971018410289428517174637096677999999998E-1)+(num-test (* -0.42780066410606965E0 0.22704747885906007E0) -9.713106223951470697784938095387549999991E-2)+(num-test (* 0.20955388816500042E0 0.605628751935113E0) 1.269118597525194529275610775776050864747E-1)+(num-test (* 0.9993471610818964E0 -4.363771855901198E9) -4.360923015803940523218504871887199999987E9)+(num-test (* 0.10502219375257282E0 3.425205053451057E9) 3.597225487658284459716764716837978363041E8)+(num-test (* 0.7768651149081368E0 1.666066330143864E9) 1.294308811011790623456907580692100524906E9)+(num-test (* -0.6438389801759042E0 2.8922130868526487E9) -1.862119524290613178578671687454540000003E9)+(num-test (* -0.7427680566504474E0 6.763974500466173E9) -5.024064194944440168218138681386184692391E9)+(num-test (* -0.8563035843259611E0 2.9100478627456827E9) -2.491884415429230578930028553142970000007E9)+(num-test (* 0.6219502737119671E0 2.8868752190811842E-11) 1.795492832679837500144381979439820000005E-11)+(num-test (* 0.6767479505813657E0 2.9324524289075574E-11) 1.98453117144053746900587234314118E-11)+(num-test (* 0.7944531541461581E0 8.282076647859848E-11) 6.579721915772496180466156449968800000014E-11)+(num-test (* -0.4662914070981966E0 -6.921260263903422E-11) 3.22732418734836218212517276876520000001E-11)+(num-test (* 0.037804762510578516E0 -3.044514833184461E-11) -1.150971602284721156705916516398760000005E-12)+(num-test (* -0.5364168049485208E0 -3.695280705974925E-11) 1.982210669686983584095600640940000000003E-11)+(num-test (* 0.10343751426551051E0 4.8902635121181385E19) 5.058367017968254798845671333856350000002E18)+(num-test (* -0.45511004829813784E0 1.8210069906740634E19) -8.287585794769196371535086060990559999988E18)+(num-test (* -0.9675158737162977E0 8.097401718869682E19) -7.834364698864051180664785816331399999997E19)+(num-test (* -0.06573561186185628E0 2.6049125586869125E19) -1.712355208919177984462215919354999999997E18)+(num-test (* -0.5574365795036731E0 -8.822383181882661E19) 4.917919103979402413863422702119099999985E19)+(num-test (* -0.4222667103024276E0 -1.8561723355961213E19) 7.837997859065477747526525340678799999995E18)+(num-test (* -0.8412207478192143E0 2.3416069046402696E-22) -1.969808311420123220453436412175280000003E-22)+(num-test (* 0.24291385591230452E0 -9.448120185342916E-21) -2.295079305344524973092760016780319999996E-21)+(num-test (* -0.37792600430678414E0 -2.3929024368177364E-21) 9.043400566424941101603791982206959999978E-22)+(num-test (* -0.007648867433060369E0 -5.3162210182098465E-21) 4.066306981313632980042734472335849999998E-23)+(num-test (* -0.7631807323096114E0 -4.534410248041209E-21) 3.460574533692296555855373976182600000004E-21)+(num-test (* 0.4735366300649959E0 -1.3895270471326203E-21) -6.579919552833457409343160757567699999986E-22)+(num-test (* -8.64834403600587E9 -0.14057280586223464E0) 1.215721987203268063989050502795104980466E9)+(num-test (* -1.5525713051163936E9 0.10621224657238759E0) -1.649020862802360033147528021954240000002E8)+(num-test (* 3.297132746298694E9 0.05318660311813239E0) 1.753632908051865357781730185173082351681E8)+(num-test (* 2.1659831568875275E9 0.11704159596099262E0) 2.535101255067452830195785975470499999995E8)+(num-test (* -5.533403510176525E9 0.37778599060251605E0) -2.090442326495477997892444645726250000003E9)+(num-test (* -2.4217306331294374E9 0.6051350227557695E0) -1.465474021787126179631541139079300000002E9)+(num-test (* 1.4048311850866513E9 -4.304799039580996E9) -6.047515936334448947178704758694799999987E18)+(num-test (* -5.070278162013437E9 -9.116233758795675E9) 4.622184094703138120556628748497500000004E19)+(num-test (* 8.452801605894673E9 -9.002885976919611E9) -7.609960904339272295066535438875484466566E19)+(num-test (* 6.352601599408395E9 -4.484034289922495E9) -2.84852834019637276707985964548254013062E19)+(num-test (* -6.565407710101401E8 -6.718825369609182E9) 4.411182788445701880089696066398200000001E18)+(num-test (* -9.37193973536698E9 9.577576231327314E9) -8.976046725088278448381480077370724757202E19)+(num-test (* -1.7766859308675253E9 -4.079350537765101E-11) 7.247724707524128390808760574555300000015E-2)+(num-test (* 2.3810136983742104E9 9.195156930614704E-11) 2.189379461049416913728349262972160000005E-1)+(num-test (* -3.313966320976337E9 -3.44704749912067E-11) 1.142339931889161000998337758579000000001E-1)+(num-test (* 6.598963960681895E9 -2.4298605961767928E-11) -1.6034562503651679888964996364737701416E-1)+(num-test (* 7.908258993705348E9 1.528909719631646E-11) 1.209101404084048656249131044486427307128E-1)+(num-test (* -5.906667889594469E9 5.917852809041966E-11) -3.4954791162514609467168142486054E-1)+(num-test (* 4.86261281419926E9 -2.3925611132123714E19) -1.1634098327861323021375513143190574646E29)+(num-test (* -9.753392818607462E9 -2.5653634777279775E18) 2.502099772078991953507318766810499999998E28)+(num-test (* 1.5861252889272392E9 5.12939252547053E19) 8.135859201483165467280698143134187520016E28)+(num-test (* -8.422142961023593E8 1.0428099441045047E19) -8.782694430425160722507674279387100000022E27)+(num-test (* -3.109042783121446E9 -4.138252722536039E19) 1.286600476173334775049764879239400000004E29)+(num-test (* -6.459303282089468E8 1.8408981660472957E19) -1.18909195659417795593544068516876E28)+(num-test (* -1.432764110232635E9 8.98766033001457E-21) -1.287719715580647603395563949195000000001E-11)+(num-test (* 8.539623949953406E9 -3.498784805440049E-21) -2.987830652026891151867478398400020599353E-11)+(num-test (* 7.336784327799637E9 -1.048985206018761E-21) -7.696178219612118988966933703567504882842E-12)+(num-test (* -4.320357143553698E9 2.591531476439043E-21) -1.119634152697768142457549423101400000004E-11)+(num-test (* -9.374098076239548E9 5.5773248420603045E-21) -5.2282390072520541300690003822366E-11)+(num-test (* 9.118926580475056E9 -1.379170270330765E-21) -1.257655243712018104094987568109512329098E-11)+(num-test (* 8.145792307872788E-11 -0.06511382435429458E0) -5.304036895613925967063321178890399999982E-12)+(num-test (* -6.1928426627437E-11 0.2526275616632321E0) -1.564482741652978543296795912770000000003E-11)+(num-test (* -8.555119338859813E-11 -0.8366318482083728E0) 7.157485304113477734096792042286400000002E-11)+(num-test (* 8.243060442429263E-12 0.3939656708074719E0) 3.247482836708180702664407610209699999993E-12)+(num-test (* 8.600529286105945E-11 -0.891441509265547E0) -7.666868807288821095008580376914999999987E-11)+(num-test (* -7.531046724969747E-11 0.24398797995196886E0) -1.837484877349259372047496586078419999997E-11)+(num-test (* -3.7666526619188126E-12 4.659322150343885E9) -1.755004818033008198811983615043067932129E-2)+(num-test (* 3.032501107241211E-11 -9.592046453776636E9) -2.908789149178678011789796814619600000006E-1)+(num-test (* 7.311626957349528E-11 -9.061108567148174E9) -6.625144566303134478698468496187199999991E-1)+(num-test (* 4.898078204161461E-11 8.88014689134599E9) 4.34956539382539434542556734824485778809E-1)+(num-test (* 1.278207138618518E-11 -4.279966992086118E9) -5.470684362336102162321405533123999999992E-2)+(num-test (* -8.538580654966055E-11 -5.191059833953482E8) 4.432428307696650304902715905351E-2)+(num-test (* 4.0761422500127225E-11 1.527607426117321E-11) 6.226745171030000570391027616422499999987E-22)+(num-test (* -9.186363051001198E-11 8.557763803549676E-11) -7.861472520412421845045812851184799999979E-21)+(num-test (* -9.89183505930065E-11 9.717968160611499E-11) -9.61285381563042758142312881743500000002E-21)+(num-test (* 7.440627873114725E-12 -4.535521332601712E-11) -3.374712644646273959960130740919999999997E-22)+(num-test (* 8.701410920357686E-11 -7.032883383151379E-12) -6.119600827175551716944456414899399999975E-22)+(num-test (* 9.866226673114161E-11 -2.814669610817353E-11) -2.777016839025002299729708883583300000003E-21)+(num-test (* 5.192240545105114E-11 -3.366056660574579E19) -1.747737587015645175992519129700599999996E9)+(num-test (* -1.372355669576939E-11 -4.819955130360066E19) 6.614692750256090679268960117974000000002E8)+(num-test (* 3.637511103766519E-11 -4.071776382810416E19) -1.481113180452716050522430526190399999997E9)+(num-test (* 7.446388208685151E-13 2.7760294268649034E19) 2.06713927911698144246650226294134E7)+(num-test (* 6.267855179410938E-11 7.471751480940298E19) 4.683185621908299321917798617952399999997E9)+(num-test (* -4.336562006766369E-11 8.143188451558233E19) -3.531344165296609191472762946597699999996E9)+(num-test (* -1.0432655006975122E-11 -9.379512413340694E-21) 9.785321714202410134613576821466799999983E-32)+(num-test (* -8.167646898574611E-11 -5.810795749825724E-21) 4.746052788431460582580726109336400000004E-31)+(num-test (* -4.33805459341994E-11 -2.4289860591796017E-21) 1.053707413137706937228749003789799999998E-31)+(num-test (* -1.384613082275421E-11 2.2174009100764947E-21) -3.070242308741338958377843646768700000007E-32)+(num-test (* -4.910905591314494E-11 -5.456657623752349E-21) 2.679713043437427118620763024640600000007E-31)+(num-test (* 1.3653011366548008E-11 -3.925911962906968E-21) -5.3600520653635635667567009719744E-32)+(num-test (* 7.641468950470222E19 0.9034599537348024E0) 6.903761184457755820350566254132800000009E19)+(num-test (* 5.146778093125584E19 -0.2791459460022878E0) -1.436702239669392041403916711075200000002E19)+(num-test (* -8.874303077863696E19 -0.23153988023519345E0) 2.054755071819368785424861291991199999996E19)+(num-test (* 7.10798162637783E19 -0.4719034863212067E0) -3.354281310194779040746230255943679999999E19)+(num-test (* -9.820386602197546E19 0.03346146041258036E0) -3.286044775256677372510003197965599999991E18)+(num-test (* -5.210458089116161E19 0.11173798093222442E0) -5.822060666098160855554015008516199999997E18)+(num-test (* 3.257626718953688E18 -6.150510855712356E9) -2.003606849878328222529021336892800000007E28)+(num-test (* -7.755105754004988E19 5.514896832715505E9) -4.276860816013589383294629509647750854492E29)+(num-test (* 2.426235084788384E19 8.685431434428486E9) 2.10728984727342930836693974581298828125E29)+(num-test (* -2.847383850475709E19 -2.412830829567453E9) 6.870255538040273498936753499177000000002E28)+(num-test (* 1.4664659669727164E19 -4.8673539253155E9) -7.137808880686241930432174599520111083984E28)+(num-test (* -4.24770317054668E19 1.3102543269150825E9) -5.5655714586597020914994623011E28)+(num-test (* 2.17116835964837E19 -3.654789326884115E-11) -7.935162947711353824080778955354111999976E8)+(num-test (* -1.8125809977916906E17 -5.944782899600832E-11) 1.077540051981345570924422644657920000001E7)+(num-test (* -7.915462827540546E19 9.762153025588201E-11) -7.727195939080587759467382669774600000011E9)+(num-test (* -4.360953588949649E19 -7.152431005584812E-11) 3.119141966351983288172806713098800000002E9)+(num-test (* 3.550776271395866E19 -6.387656982922894E-11) -2.268114084477872045705002835620399999998E9)+(num-test (* -8.278954580496595E19 -7.359178231519021E-11) 6.09263023285252303789473682334949999999E9)+(num-test (* -5.5022682113038156E19 -8.979630229039327E19) 4.94083339585058897667477175561012E39)+(num-test (* 1.1716230943203277E19 5.5764415854118265E19) 6.53348774559675813536051493554405E38)+(num-test (* 7.462799608352103E19 6.061883497941003E19) 4.5238621794310193360802344979309E39)+(num-test (* -3.2160334983646097E19 -3.8817785710003675E19) 1.248392991757108737054938769406475E39)+(num-test (* 5.868090263060238E19 -8.37300331667736E19) -4.913353923516549470233569081168E39)+(num-test (* -7.3652924769962656E19 9.725738480757314E19) -7.16329084655549342691442378865984E39)+(num-test (* -6.447063647969567E19 4.0587529685661844E-21) -2.616703871973161409821231651015480000002E-1)+(num-test (* -3.1999317568381926E17 3.015031281949113E-21) -9.647894346969533174030688093163799999993E-4)+(num-test (* -1.5005852398726605E19 5.391316601974659E-21) -8.090130116403600588996007910269500000005E-2)+(num-test (* 1.0084552719733576E19 2.78150956101201E-21) 2.805027980846861049488413624776000000002E-2)+(num-test (* -7.171404412051077E19 1.4733392992015492E-21) -1.056591195074223176150038792848839999998E-1)+(num-test (* -5.909802783283228E19 5.356071274587122E-21) -3.165332492601832012651928738981599999998E-1)+(num-test (* 8.272641144282955E-22 -0.16191056182923802E0) -1.339427975482523749443486923949099999995E-22)+(num-test (* 8.410471541398583E-21 -0.43256058128353736E0) -3.638038458816019512260007931560879999991E-21)+(num-test (* -7.887238384137063E-22 0.5589746137044918E0) -4.408766028968254895651429959583400000002E-22)+(num-test (* 4.778995446616728E-21 0.21608373898977795E0) 1.0326632047200663557809034755476E-21)+(num-test (* 3.992449163872154E-21 0.9593422165456676E0) 3.830125030315009512425388980010399999991E-21)+(num-test (* -9.700320218813958E-21 -0.42620535269852766E0) 4.134328400148261975602018057078279999983E-21)+(num-test (* -1.7901566262876555E-21 9.461674014776534E8) -1.693787843332593653628245958251059055323E-12)+(num-test (* 1.0928019952544443E-22 8.279199780524873E9) 9.047526039267738313652918648958873748777E-13)+(num-test (* 9.942869097320962E-21 9.523169242022762E9) 9.46876251650656124754254949341964721678E-11)+(num-test (* -2.7432601692209267E-21 -4.922145522647528E9) 1.350272575938808435595052562419760000003E-11)+(num-test (* -5.97929682563092E-21 -6.147792689359443E8) 3.675947731212389417723913477756000000004E-12)+(num-test (* -1.3564305221188254E-21 1.0862842413758955E9) -1.4734691006989580907776383331457E-12)+(num-test (* -5.446806293721964E-21 -1.5358504316888942E-11) 8.365479797538664267835041412208799999977E-32)+(num-test (* -1.0222776562632463E-21 -1.9781477525280056E-11) 2.022216248196737715829186720579279999999E-32)+(num-test (* 8.192540157543917E-21 3.3215076993103644E-11) 2.721158521019146605658900627335480000005E-31)+(num-test (* 9.685592607330157E-21 6.034805605641166E-11) 5.845066856067266821880143244306199999988E-31)+(num-test (* 6.671870463340688E-21 -9.07657686679269E-11) -6.055774510579551477490933797071999999989E-31)+(num-test (* -1.109409648670322E-21 -4.7905821901849965E-11) 5.314718104539438656835419223873000000025E-32)+(num-test (* -3.9052432481663676E-22 2.0306112771345453E19) -7.930030979680167745084943578652280000005E-3)+(num-test (* 8.596834841113507E-21 -9.453548987989818E19) -8.127059931212420192062869827172600000005E-1)+(num-test (* 3.946325780779758E-21 -9.084484011754447E19) -3.585033346066809630978128408382600000004E-1)+(num-test (* 5.3518824877647604E-21 -6.814116447592617E19) -3.64683504854607466529059878139668000001E-1)+(num-test (* -7.456278485417833E-22 9.61914445493285E19) -7.172301984744205963559813785437470719996E-2)+(num-test (* -5.0781537010216826E-21 9.216915512986622E19) -4.680491362427717476508990573017719999994E-1)+(num-test (* 3.2906792172396555E-22 4.571445785546992E-21) 1.504316163923729767672342114125599999998E-42)+(num-test (* 5.39814714322422E-21 6.687033308557664E-21) 3.609758975123575798079875142208000000008E-41)+(num-test (* 4.3506183844841724E-21 7.266196706225928E-21) 3.161244897538486151238585450198720000008E-41)+(num-test (* 6.910763289107986E-21 3.910584203890238E-21) 2.702512175521023610171407324066800000011E-41)+(num-test (* -4.6131515924393325E-21 5.228174479773633E-21) -2.411836142691841383820888561997250000001E-41)+(num-test (* -2.1886866436065787E-21 6.29322016055891E-22) -1.377388691069093503544474490121700000002E-42)+(num-test (/ -0.651381628953465E0 -0.9237050214744277E0) 7.051835962889135018948026610294923703508E-1)+(num-test (/ 0.5067986732438687E0 0.6260017267692811E0) 8.095803119575965307784422745290898299591E-1)+(num-test (/ -0.8399445051045212E0 0.1829250718359493E0) -4.591740742120902283769244624290448381427E0)+(num-test (/ -0.5987041550692662E0 -0.4124053212463479E0) 1.451737221187875469260813375116670894624E0)+(num-test (/ 0.5861382519823647E0 -0.7560374696447822E0) -7.752767230673855251634630463492900473644E-1)+(num-test (/ -0.012882644582824954E0 -0.4671067448591679E0) 2.757965866390787237919533761751626109973E-2)+(num-test (/ -0.7830198970435231E0 2.1690164135025935E9) -3.610022921767930828778117437420472499541E-10)+(num-test (/ -0.2339206226652567E0 2.729373380002701E9) -8.570488170622710029144125942503181451939E-11)+(num-test (/ -0.2285806315782951E0 -2.602073870582813E9) 8.784555817667757706754728345837912936962E-11)+(num-test (/ -0.5298716781559242E0 1.3509547453340487E9) -3.922201539215168658138266422439019362809E-10)+(num-test (/ 0.7287190523338418E0 -8.244205871151566E9) -8.839166121309546680006433484161854320415E-11)+(num-test (/ 0.18973054487786212E0 6.557593452200545E9) 2.893295326415727180554709812740977209383E-11)+(num-test (/ 0.5084032300982587E0 4.5431682148621014E-11) 1.119049980221104893780059617560389832312E10)+(num-test (/ 0.6621212705475221E0 -1.838873437953206E-11) -3.6006897314505184969089186237646638616E10)+(num-test (/ -0.4041791750277005E0 7.707875701307648E-11) -5.243716825365141031107302892929967408104E9)+(num-test (/ -0.09569063343466655E0 4.789751448902253E-11) -1.9978204392338054187984205729651608099E9)+(num-test (/ -0.6471008513340974E0 1.890250884404079E-11) -3.423359600956370337454713673029890117878E10)+(num-test (/ -0.4301276572683971E0 9.134844738134672E-11) -4.708647706651977799170970961042517830565E9)+(num-test (/ -0.5061027989171409E0 4.246468515299164E19) -1.191820443490291421327933820140392588455E-20)+(num-test (/ -0.9601783702217944E0 7.495754288877955E19) -1.280962973461506313537075112900039769719E-20)+(num-test (/ -0.6477754868655262E0 -8.507334914535449E19) 7.614317449272520944989386124046318248581E-21)+(num-test (/ 0.1934462826116784E0 3.6173521417193476E19) 5.347731573618163299262146929108634114511E-21)+(num-test (/ -0.7794308505212441E0 4.172217291786081E19) -1.868145391314406352823434511710862322776E-20)+(num-test (/ -0.8462346361305484E0 7.378170819620111E19) -1.146943675904374803577079154661818066039E-20)+(num-test (/ 0.9783005897625496E0 6.175045007596078E-21) 1.584280905740958108982369263614665552851E20)+(num-test (/ -0.9700832605850568E0 -1.7695051741124812E-21) 5.4822290139480091183029856440319954731E20)+(num-test (/ 0.07062591404368701E0 -8.855398515753737E-21) -7.975464223100026969579387130724758972895E18)+(num-test (/ 0.4751383409805402E0 -8.1371029771106E-21) -5.839158510308749293926976970601471638106E19)+(num-test (/ -0.5103510786836052E0 8.302178001281015E-21) -6.147195092719750272554937885528717433502E19)+(num-test (/ 0.7148807879199733E0 4.338856119331781E-21) 1.647625015115898182854639201045676562387E20)+(num-test (/ 4.180670608983218E9 -0.8621420131862095E0) -4.849167010818503318377538718886882159085E9)+(num-test (/ 3.202209376555907E9 0.008113117870009012E0) 3.946952858152361317410218375892707092144E11)+(num-test (/ 7.767843042272955E9 -0.04145956871894663E0) -1.87359475322354819500790198613468533242E11)+(num-test (/ 1.1937839884817846E9 0.45557753834605563E0) 2.620374992181877679062077123717269598672E9)+(num-test (/ -2.4205138097471213E9 -0.3737757916008485E0) 6.475844247109412171348144805246962117951E9)+(num-test (/ -7.534066568550288E9 -0.3609372553147958E0) 2.087361849632108651836399241353567759856E10)+(num-test (/ 6.098867840095913E9 3.0464612528039427E9) 2.001951554277132357084991750811780094278E0)+(num-test (/ 4.956687716396978E9 7.035407926465974E9) 7.045345157244949942198957065331702603612E-1)+(num-test (/ 6.969049109639194E9 -8.115758334653503E9) -8.587058438990264159516222429259889060394E-1)+(num-test (/ -8.0699835500126705E9 -1.1896420666819375E9) 6.783539163608157717597859343396495021042E0)+(num-test (/ -2.229793060172571E9 -2.658809828346301E9) 8.386433043838395143199282594014446842336E-1)+(num-test (/ 3.0672739776038485E9 -7.988270854370873E9) -3.839722054398737311833139439634292109412E-1)+(num-test (/ 2.477055391151669E9 -1.3522358047779648E-11) -1.831822070085178675709536653203693354871E20)+(num-test (/ 1.1318646612469008E9 -8.457695758685169E-11) -1.338265992938554414702828284241585726631E19)+(num-test (/ -7.978772126259147E9 6.210468872769038E-11) -1.284729428601367805018001112036580297153E20)+(num-test (/ -9.057338243339752E9 7.364415429198257E-11) -1.22987877726580108212627205863468836645E20)+(num-test (/ -5.341117220720213E9 4.7359651161519756E-11) -1.127777990277920421924982539741683693507E20)+(num-test (/ 5.838003830912871E9 -5.0625478501901024E-11) -1.153175042225753978331600642680269130096E20)+(num-test (/ 6.407156672927742E9 5.006339136594536E19) 1.279808758079079048751288572047629634958E-10)+(num-test (/ 4.687485139826675E8 -3.5561755068968083E19) -1.318125365504547538826162177354689732851E-11)+(num-test (/ -5.838044723576891E9 -6.843985743599882E19) 8.530182473036721969937888742798001972008E-11)+(num-test (/ 3.9279221543350096E9 -5.882918042982924E19) -6.676826237652909876656284584084555589571E-11)+(num-test (/ -9.686323716926361E9 -3.44800215666902E19) 2.809256861452760638746791455737599480861E-10)+(num-test (/ 7.301304808910639E9 1.2845297359643038E19) 5.684029419085037872687787191413868358377E-10)+(num-test (/ 4.380345662298534E9 -4.352751895415198E-21) -1.006339384266859136854551985691861659542E30)+(num-test (/ 8.239490918139045E9 3.2397577733346748E-21) 2.543242888698483402490821850315555889368E30)+(num-test (/ 3.8980499504872713E9 8.311650110069505E-21) 4.689862901910189296816144765858628505003E29)+(num-test (/ -9.425472285331268E9 -3.294031046828316E-21) 2.861379310436876111669825630018089608938E30)+(num-test (/ 2.517833161624173E9 3.6891560299469316E-21) 6.824957093669990747641669780362243770063E29)+(num-test (/ -5.463519676339016E9 -7.298583081866205E-22) 7.485726496576409428699223883071063828111E30)+(num-test (/ 1.39357009199772E-11 0.417842407627649E0) 3.335157146709649079791043787228216537723E-11)+(num-test (/ 8.58494900746665E-11 -0.6481371063028898E0) -1.324557554872456302657963676252150750478E-10)+(num-test (/ -9.310282234439046E-11 0.9146343299129254E0) -1.017923986663107128254299604028521252096E-10)+(num-test (/ -8.800556770159418E-11 -0.9305573406536135E0) 9.457296596014170681132977631993414317205E-11)+(num-test (/ -1.3361456473382827E-11 0.06420301636905124E0) -2.081125970247038707404762086321230923761E-10)+(num-test (/ 6.1406425153971765E-12 -0.3082496074575478E0) -1.992100676476244033296635444865296145538E-11)+(num-test (/ -3.6962256202372035E-11 3.089420488573177E9) -1.196413901541863127466123235969256148157E-20)+(num-test (/ -6.145126590884831E-11 -6.225608984106817E9) 9.870723661849873241350389006374300024184E-21)+(num-test (/ 9.052281678541901E-11 -6.9187138778508625E9) -1.308376359878287335554324548627653637652E-20)+(num-test (/ -3.4950245360118636E-11 7.543342567738434E9) -4.633257080169574405642456881139071687897E-21)+(num-test (/ -3.482822570743636E-11 -3.87599225187502E9) 8.985628309909063146939690605121402184145E-21)+(num-test (/ -9.42226868788213E-11 7.501937454180854E9) -1.25597803839741017709728590003874245271E-20)+(num-test (/ -4.8165035309367155E-11 9.484620130429997E-11) -5.078225026096383416618039442767276425835E-1)+(num-test (/ 6.880022773725747E-11 -9.699156104509544E-11) -7.093424107822057000929770558471489984227E-1)+(num-test (/ 1.5817962388036865E-11 -7.11651152335492E-11) -2.222712959309569253469449863287830842251E-1)+(num-test (/ -7.0140750853949335E-12 -4.4677941652531186E-11) 1.569919030725435801904141818366904619636E-1)+(num-test (/ -2.6947489262085355E-11 8.365454450205894E-11) -3.221282169723859093984652053864584015511E-1)+(num-test (/ 8.703167674410303E-11 -4.88739813223768E-11) -1.780736383435491638475146912252252561499E0)+(num-test (/ 1.165112061543483E-12 -5.899528740399518E19) -1.974923952086012268924127751659019857389E-32)+(num-test (/ 7.126386981630328E-12 5.091741402945837E19) 1.399597194293359595983101664952569614126E-31)+(num-test (/ -7.132349854872655E-13 7.70347159367981E19) -9.258617712985762871283798832641751905855E-33)+(num-test (/ 4.507266517270466E-11 -1.6192737232544485E19) -2.78351118315665136913517665604742725923E-30)+(num-test (/ -3.025128309814261E-11 -5.606736896306867E19) 5.395523930874836927233660478269495795871E-31)+(num-test (/ -5.390258677516223E-11 6.628750121976767E18) -8.131636550373975963243412569165785520017E-30)+(num-test (/ -8.484515181627938E-11 6.226893371743352E-21) -1.362559895457550846279271972989853630227E10)+(num-test (/ 5.110456708789676E-11 -7.434814854731122E-21) -6.873683889434922905934754874417370413592E9)+(num-test (/ -7.784815533665352E-11 -8.942884975553875E-21) 8.705038200698988300091363733020271337225E9)+(num-test (/ 6.06871371776654E-11 -8.4720755768444E-21) -7.163195916657483482294943699821186479438E9)+(num-test (/ 6.395725883763629E-11 3.2465500186809204E-21) 1.970006883295217146112013920243427167994E10)+(num-test (/ 8.23766365482318E-11 3.5665958051648335E-21) 2.309671211661863324131996575306264215863E10)+(num-test (/ -6.882125490660233E19 0.680553203393516E0) -1.011254587641810638505458546065261498221E20)+(num-test (/ -8.955858402134752E19 0.11144092291315044E0) -8.036418012361891226885340978581557821805E20)+(num-test (/ 4.517225460957592E19 -0.5804969398143229E0) -7.781652496570381006264991321295105224966E19)+(num-test (/ -9.741926397385082E19 -0.9037000739789977E0) 1.078004381972805693752225428081454781542E20)+(num-test (/ 9.654390326446178E19 -0.061963385089831124E0) -1.558079874501654704495847314268744072438E21)+(num-test (/ 9.50855454738802E19 0.30375471599023185E0) 3.130339727036137864357134952530976170215E20)+(num-test (/ 4.323538184184934E19 -2.6027608151521606E9) -1.661135421670382968923474255247239383096E10)+(num-test (/ 4.0554081767557594E17 4.814123702784068E9) 8.423979995384136048633041200603888010585E7)+(num-test (/ 5.12727309625028E19 1.761988796449604E9) 2.909935129316203535920673855950717437829E10)+(num-test (/ -7.335661993746345E19 -4.961351435504E9) 1.478561252736806087045652086640747044774E10)+(num-test (/ 3.7135994768593306E18 3.273427798269768E8) 1.134468118961482490398408895662653948827E10)+(num-test (/ 1.3911083524706402E19 8.651242909451927E9) 1.607986698594236535694138981270724564992E9)+(num-test (/ 6.473382688386894E19 -3.700509647679497E-11) -1.74932193257385527761113361595002688054E30)+(num-test (/ 7.25328632809461E19 6.793518758100849E-11) 1.0676773828651782212117989476182162163E30)+(num-test (/ 7.053090091571119E19 8.009021819073383E-11) 8.806431360661641824334823520600629499368E29)+(num-test (/ -1.6322872380348074E19 -1.234889420758779E-11) 1.32180842316378978004378947103470484747E30)+(num-test (/ -7.716951191497702E19 -2.473367210466666E-11) 3.120018393888910452644610629695438606501E30)+(num-test (/ -2.1174708383466066E19 -9.66632270128099E-11) 2.190565020207733610503619470750854251338E29)+(num-test (/ 4.0902039392392786E18 -5.029423690873208E19) -8.132549951322828067822875337940065787516E-2)+(num-test (/ 1.4562115759233494E17 4.2665150414889705E19) 3.413117173530803542079920263107168159861E-3)+(num-test (/ -3.309692589578652E19 1.1329455009949342E19) -2.92131667999222745140457080629099499358E0)+(num-test (/ 3.059130103268258E19 -7.719433592654628E19) -3.962894513632647141286488246687660445133E-1)+(num-test (/ 5.622979366632147E19 -8.407251901594788E19) -6.688248945610292804540334084533940238665E-1)+(num-test (/ -7.457587910839625E18 1.102755747735572E19) -6.762683328700153669243467171164281736437E-1)+(num-test (/ 1.2026615920578564E19 -3.77964792582931E-21) -3.181940793583240608441984111790776956096E39)+(num-test (/ -2.74643694419756E19 2.538907641816601E-22) -1.08173960287601117923133084738647095934E41)+(num-test (/ 8.267361397156658E18 -4.986401395715489E-21) -1.657981526368955793956856573504468676464E39)+(num-test (/ 9.876393891158812E19 -5.792612775193684E-22) -1.704998119925007613535922021885867984527E41)+(num-test (/ 3.927461252713038E17 4.810589424292295E-21) 8.164199656866003466542429981600313024025E37)+(num-test (/ 7.29943837795987E19 -4.8820727437034755E-21) -1.495151498382347474354240468822304376928E40)+(num-test (/ -7.837850970911807E-21 0.41514160181315674E0) -1.887994587070894820872902637806483134671E-20)+(num-test (/ 1.1499234744049124E-21 0.4643166529612681E0) 2.476593219457143961012942936990797968514E-21)+(num-test (/ -1.094368243984769E-21 0.9008053219044149E0) -1.214877640455251662856715755193246361763E-21)+(num-test (/ 2.4821206327531197E-21 0.22988631081892086E0) 1.079716588565493668307955174993650571244E-20)+(num-test (/ -4.56226662576732E-22 0.6695285124602162E0) -6.814148375851898788485451948577541009839E-22)+(num-test (/ 6.442796853653397E-21 -0.0419134640377401E0) -1.537166397855380228851954699451812058468E-19)+(num-test (/ -5.584403218169678E-21 -8.092869169805251E9) 6.900399723506295845105466793248363429626E-31)+(num-test (/ -9.796722996869492E-21 -3.2988270899833827E9) 2.969759471970033259328414098139420231204E-30)+(num-test (/ 9.441829923771915E-22 5.464575083746736E9) 1.727825087783076315606418411938950517056E-31)+(num-test (/ -6.419360319610147E-21 -7.333962810289677E9) 8.752921831841952013186922455457072581443E-31)+(num-test (/ 7.973734412555454E-21 -9.367577614661436E9) -8.512055880994845185202464827966401354632E-31)+(num-test (/ 8.105484193881594E-21 -8.664550975192905E9) -9.354765431108951260398341387461553707907E-31)+(num-test (/ -5.3151708182942476E-21 -3.406928289732576E-11) 1.560106455516695805992469791379650741489E-10)+(num-test (/ -7.026602845639829E-21 -9.92483846943868E-11) 7.079815824989676856562805642631867847741E-11)+(num-test (/ -5.901970468193158E-21 2.074489043942647E-11) -2.845023686881582124910812196899705492945E-10)+(num-test (/ -6.40466723844613E-21 -2.551008177490094E-11) 2.510641594550905909683475044031419810602E-10)+(num-test (/ 8.056066940872177E-21 4.645883100460603E-11) 1.734022739417072488146823616965762354533E-10)+(num-test (/ 7.453765056481805E-21 6.956136187014756E-11) 1.071538114851171096483487539186715128913E-10)+(num-test (/ 7.357434693258832E-21 -7.093525088486332E19) -1.037204295675341715303117810431180096085E-40)+(num-test (/ -3.3759558579798473E-21 9.991075630444324E19) -3.378971376908405498870850768959668870304E-41)+(num-test (/ 6.908026973557955E-21 -4.20805893397862E19) -1.641618399822784611549409240045335916762E-40)+(num-test (/ 5.181767322756247E-21 7.46986056263721E19) 6.936899664063931551045422017869651239957E-41)+(num-test (/ -5.7217313601659264E-21 5.604979023134118E19) -1.020830111326005351069300302415295512527E-40)+(num-test (/ -9.340193892824771E-21 9.147101848766205E19) -1.021109641857175884684740262364588092125E-40)+(num-test (/ 8.331002176099931E-21 2.0276444314093977E-21) 4.108709617449606347005645831416724715479E0)+(num-test (/ -3.747505523684784E-21 4.394623185543803E-21) -8.527478615259381231018127145394525879915E-1)+(num-test (/ -3.310403953328861E-21 2.3420390876737627E-21) -1.413470838617356120752866783055539347411E0)+(num-test (/ 6.23845405853013E-21 -8.933620117412232E-21) -6.983119918397872761237650028889120834928E-1)+(num-test (/ -4.276770609150315E-21 6.853299965034864E-21) -6.240454424832049912604789277138688124888E-1)+(num-test (/ -8.847946637724495E-21 6.33827952828724E-21) -1.395953996386055439061738621964402924048E0)++(let ((top-exp 60))+  (let ((happy #t))+    (do ((i 2 (+ i 1)))+	((or (not happy) (> i top-exp)))+      (let* ((val1 (+ 2 (expt 2 i)))+	     (val2 (- val1 1)))+	(if (not (> val1 val2))+	    (begin (set! happy #f) (display "(> ") (display val1) (display " ") (display val2) (display ") -> ") (display (> val1 val2)) (display "?") (newline)))+	(if (< val1 val2)+	    (begin (set! happy #f) (display "(< ") (display val1) (display " ") (display val2) (display ") -> ") (display (< val1 val2)) (display "?") (newline))))))++  (let ((happy #t))+    (do ((i 2 (+ i 1)))+	((or (not happy) (> i top-exp)))+      (let* ((val1 (/ (expt 2 i) 3))+	     (val2 (/ (+ 1 (expt 2 i)) 3)))+	(if (> val1 val2)+	    (begin (set! happy #f) (display "(> ") (display val1) (display " ") (display val2) (display ") -> ") (display (> val1 val2)) (display "?") (newline)))+	(if (not (> val2 val1))+	    (begin (set! happy #f) (display "(> ") (display val1) (display " ") (display val2) (display ") -> ") (display (> val2 val1)) (display "?") (newline)))+	(if (not (< val1 val2))+	    (begin (set! happy #f) (display "(< ") (display val1) (display " ") (display val2) (display ") -> ") (display (< val1 val2)) (display "?") (newline)))+	(if (< val2 val1)+	    (begin (set! happy #f) (display "(< ") (display val1) (display " ") (display val2) (display ") -> ") (display (< val2 val1)) (display "?") (newline)))+	))))+++(if with-bignums+    (begin+      ;; these are trivial translations of some numeric tests in the+      ;; Clisp test suite.  Presumably they fall under Clisp's license,+      ;; which I belive is GPL++      (num-test (+ 17009115185923538769 -12047631083067675031) 4961484102855863738)+      (num-test (+ 12677011568664239747 3269056182420253574) 15946067751084493321)+      (num-test (+ 9315504781982082433 13857624532376678678) 23173129314358761111)+      (num-test (+ 15226508728194069537 11481952022080775416) 26708460750274844953)+      (num-test (+ 7461641943684774743 12249026721402718630) 19710668665087493373)+      (num-test (+ 1180469445886971055 -3208456171287181032) -2027986725400209977)+      (num-test (+ 18358552990465743315 221529797579218180385160273426219343697) 221529797579218180403518826416685087012)+      (num-test (+ -14819874956616484359 30498815629431206969122152847973230849) 30498815629431206954302277891356746490)+      (num-test (+ -11781881800334342169 112219460388643619332860331282276228017) 112219460388643619321078449481941885848)+      (num-test (+ 3570694277032201957 284821691832196381859344006870088122712) 284821691832196381862914701147120324669)+      (num-test (+ -17005463295060938595 69162171850264911722979835561124066203) 69162171850264911705974372266063127608)+      (num-test (+ 15647113311796203488 150750467185419235519670165664526735459) 150750467185419235535317278976322938947)+      (num-test (+ -14330150541101371097 -13054027994001826312503071338715966858478218093171762021549815587520723118772963817341751396703629529810372702877555022105594068768886421335353882155416908) -13054027994001826312503071338715966858478218093171762021549815587520723118772963817341751396703629529810372702877555022105594068768886435665504423256788005)+      (num-test (+ 7406427184711759740 -4059250217961011548005203450962458026528281798230141192186669580689721046971433745892994467792118611646113962840750314719233572760336084100766391093756252) -4059250217961011548005203450962458026528281798230141192186669580689721046971433745892994467792118611646113962840750314719233572760336076694339206381996512)+      (num-test (+ 8819522415901031498 7274905269237471130619913887005155660991437201841760414347836177003483932007334374478344594178179032728521106519295465031750530183363793325150672647162846) 7274905269237471130619913887005155660991437201841760414347836177003483932007334374478344594178179032728521106519295465031750530183363802144673088548194344)+      (num-test (+ -7242932332215698200 -10558564312909325527488520195600871241245891651644550509993750377630234801225525279855157008009255586978047154906058790342845859331159009687703010657137320) -10558564312909325527488520195600871241245891651644550509993750377630234801225525279855157008009255586978047154906058790342845859331159016930635342872835520)+      (num-test (+ 9794320575955609492 13380937715397052566925484435342184213544885758759259410983243841206628594840271850190097746775475837233042430565529099681550277688470325394342993771343357) 13380937715397052566925484435342184213544885758759259410983243841206628594840271850190097746775475837233042430565529099681550277688470335188663569726952849)+      (num-test (+ -18404048401680891243 6690884608978704096379677348142836785900717005050936986370615083929607190833180925295418079551348559691161519822750772440155040888224482801864925665484770) 6690884608978704096379677348142836785900717005050936986370615083929607190833180925295418079551348559691161519822750772440155040888224464397816523984593527)+      (num-test (+ -10763220363947284865 -30985722824355332972176356513316569304601382411274079243859710673739383446566598659878378034375348869471278415635671865753349734809209959160389615096293457362383744562507969316522225741589739150453090393424063226271167062127000223628785686999799282795143706407082119829140399988180879618548495395684946331608899565543458192773899200054228140747414544792128323269250618482622488195333106891323515989863192944848391405358725993695671970811097285270641251816244586360288952156538400321933146150313939864593445583603568771077260174826348411367609521412133720180359748539721570562669201065857989876521301209899829037444385) -30985722824355332972176356513316569304601382411274079243859710673739383446566598659878378034375348869471278415635671865753349734809209959160389615096293457362383744562507969316522225741589739150453090393424063226271167062127000223628785686999799282795143706407082119829140399988180879618548495395684946331608899565543458192773899200054228140747414544792128323269250618482622488195333106891323515989863192944848391405358725993695671970811097285270641251816244586360288952156538400321933146150313939864593445583603568771077260174826348411367609521412133720180359748539721570562669201065857989876521311973120192984729250)+      (num-test (+ -12742462236537568498 8711131313747826394504271797986775572294949693272674156076339989631171694968899228610359983845552623710580616605402899155485071497929100432998183040757832449369366844015907530612334721882095163137705867337969942902346066961718232788529860214990099385213558935023241940238638069647809530490438245386869385682221280939688108487754251075630026707075310465788398213293782900699868609660892232563106662995330591906155134237356516622436517046191466823447743155250482328613449506396571170001248589926831956459700467126756876526930443317428628239358666456771112897986098390410773312792390699312960051747534683311506465130527) 8711131313747826394504271797986775572294949693272674156076339989631171694968899228610359983845552623710580616605402899155485071497929100432998183040757832449369366844015907530612334721882095163137705867337969942902346066961718232788529860214990099385213558935023241940238638069647809530490438245386869385682221280939688108487754251075630026707075310465788398213293782900699868609660892232563106662995330591906155134237356516622436517046191466823447743155250482328613449506396571170001248589926831956459700467126756876526930443317428628239358666456771112897986098390410773312792390699312960051747521940849269927562029)+      (num-test (+ 9991390529516174614 7879872958436992955898278403297937595295396115022400543178444946646147916754852888072481665174663073269556311758611700754643170639645548596647557683044355930340624784190093631808382820554407595007761070026239341594197877214157118335743842022627898879376346092898666610367809537340994845045475091410516226225078052019727419030585524815982151736622865401299588936172760762386183577504972623377661437665668080131418564228642443266935225613702941906491478788336262289516199380144218708241406077806669686589734333554945412904560108150202389909124657090061223183441083590340175629756198442568877659538345749595968764873879) 7879872958436992955898278403297937595295396115022400543178444946646147916754852888072481665174663073269556311758611700754643170639645548596647557683044355930340624784190093631808382820554407595007761070026239341594197877214157118335743842022627898879376346092898666610367809537340994845045475091410516226225078052019727419030585524815982151736622865401299588936172760762386183577504972623377661437665668080131418564228642443266935225613702941906491478788336262289516199380144218708241406077806669686589734333554945412904560108150202389909124657090061223183441083590340175629756198442568877659538355740986498281048493)+      (num-test (+ 831234034418847630 -744676478858160349467117341859049692149463503380690495147216354303526704924280287782902146026018180364963325847811379182950159627878800024734206345960410146056000392683000433501805629464626281031086102425271022388473812300724085127447081771317912465921636737545371909901577246384446144919253141375367648958387948463576516115079816552636772639965957498569187848459747361493535081532845254971492261148968198806736512864867151355002902241562014241077734122599581732704243705918200179789271894804233542502502119523149682814025979598424744685548054183678652651244898867735764030968089217841214778606507809487462642341164) -744676478858160349467117341859049692149463503380690495147216354303526704924280287782902146026018180364963325847811379182950159627878800024734206345960410146056000392683000433501805629464626281031086102425271022388473812300724085127447081771317912465921636737545371909901577246384446144919253141375367648958387948463576516115079816552636772639965957498569187848459747361493535081532845254971492261148968198806736512864867151355002902241562014241077734122599581732704243705918200179789271894804233542502502119523149682814025979598424744685548054183678652651244898867735764030968089217841214778606506978253428223493534)+      (num-test (+ -6996572501442843347 -16567158719848992553565776505785820491834685475229611199353714982570065913508303466008005931649515528390057456882757990896824841386431756898386429000065518724021230756426613661219891419166146764347562529640689229693578574350948436847247856000438153789455857903402883189892697143647998643667467614427922009931545254965075041050860609824086811877108940020349157317276288348430058535959434983921323332907180869396258655826781438419383792024592535415693101119109484610789291889841197827977530804650015884500878613240443324806805475203272442094530735476095374446946252236490708915034012846683015547314889561060687692538144) -16567158719848992553565776505785820491834685475229611199353714982570065913508303466008005931649515528390057456882757990896824841386431756898386429000065518724021230756426613661219891419166146764347562529640689229693578574350948436847247856000438153789455857903402883189892697143647998643667467614427922009931545254965075041050860609824086811877108940020349157317276288348430058535959434983921323332907180869396258655826781438419383792024592535415693101119109484610789291889841197827977530804650015884500878613240443324806805475203272442094530735476095374446946252236490708915034012846683015547314896557633189135381491)+      (num-test (+ -8920936222630165483 -18738991973681679876688842391791783563249057933653045519186959571392922172943405646958686202208790537612746921398028331540617848217445632123805070077600768524509025758950743971128222843292926773668584735575066246660802064630842300367821042873152766467703905048558085377302000898639290554395913805527529259855535801856020623830262396582180677933562523957295341539162448074423901242873918231922121053192425691524797238343327318801359521456598967984637483081312932069399045363737622797213185099130529375169698811801965974416555301085043300426947769193582129151016159057101028336667142913854943018973494705119572045938607) -18738991973681679876688842391791783563249057933653045519186959571392922172943405646958686202208790537612746921398028331540617848217445632123805070077600768524509025758950743971128222843292926773668584735575066246660802064630842300367821042873152766467703905048558085377302000898639290554395913805527529259855535801856020623830262396582180677933562523957295341539162448074423901242873918231922121053192425691524797238343327318801359521456598967984637483081312932069399045363737622797213185099130529375169698811801965974416555301085043300426947769193582129151016159057101028336667142913854943018973503626055794676104090)+      (num-test (+ -243510292488206214847646757340020705642 5940577100149745132) -243510292488206214841706180239870960510)+      (num-test (+ 35446324064743728955945058978206455057 -6248622708755929572) 35446324064743728949696436269450525485)+      (num-test (+ -285342226760657637664173494795024413673 -11942737781617905307) -285342226760657637676116232576642318980)+      (num-test (+ 180790435817422032042321866247362452865 12401641959336396832) 180790435817422032054723508206698849697)+      (num-test (+ -179994871947239535956826388240542999950 13573822506399140772) -179994871947239535943252565734143859178)+      (num-test (+ -308198027295905163635866438671452347268 -8790069282378476990) -308198027295905163644656507953830824258)+      (num-test (+ -139324757925833055762410227358605285566 -190622873846936719063564661032771271922) -329947631772769774825974888391376557488)+      (num-test (+ 332866352618304570046318203427223999347 147978646177673305481282943528696833018) 480844998795977875527601146955920832365)+      (num-test (+ -39471620476300923970352914034802271156 28992893610776120142668950821916856486) -10478726865524803827683963212885414670)+      (num-test (+ 274120253734611965146455315763505869288 254675910805265090692978775702306142625) 528796164539877055839434091465812011913)+      (num-test (+ -122086811464559635596206661886176775901 287312583034687582188356355813963609701) 165225771570127946592149693927786833800)+      (num-test (+ 288576174771266329955482943556556984728 -57843540651903655425270706396868707777) 230732634119362674530212237159688276951)+      (num-test (+ -47977736580820486006305788441965482221 984809271313988066640898939725532304075331399066274624928410251834520283291912387208948664716457549646483445981126881113426109906085249657168046936670489) 984809271313988066640898939725532304075331399066274624928410251834520283291912387208948664716457549646483445981126833135689529085599243351379604971188268)+      (num-test (+ 21225484205143479814642328762121362291 11839789093732539327981861490012713257538550745921177905266671749716203131127256902110452504526721633943016923389974867770082516862899595554460170417713940) 11839789093732539327981861490012713257538550745921177905266671749716203131127256902110452504526721633943016923389974888995566722006379410196788932539076231)+      (num-test (+ -193095363331703875886398909106293703000 4389392021031719669078675478621418677903292147307684123866099084349756491860737402449105804868232530632178577388168068485304437343508442251302846768269976) 4389392021031719669078675478621418677903292147307684123866099084349756491860737402449105804868232530632178577388167875389941105639632555852393740474566976)+      (num-test (+ -14827657635864183514988182371035598180 -7256545787852407071411458891023580461638051949278710509801472046178301830006724297747051044450550248499056073213660185258676369175307019300952192657194576) -7256545787852407071411458891023580461638051949278710509801472046178301830006724297747051044450550248499056073213660200086334005039490534289134563692792756)+      (num-test (+ 54301423175725658626298504084995819705 -13385853291610595576947504757201441006088030688464261540642594993520424631577281077984278942244446266776534612440941312995898184903431893212829646845766101) -13385853291610595576947504757201441006088030688464261540642594993520424631577281077984278942244446266776534612440941258694475009177773266914325561849946396)+      (num-test (+ 195114404067053480147948948510253723990 -8373866462448797623435948949281383906369538962237624940506813188612614128993186653340202956656303504523161255703176374041758276069255591562198514767063594) -8373866462448797623435948949281383906369538962237624940506813188612614128993186653340202956656303504523161255703176178927354209015775443613250004513339604)+      (num-test (+ -308030589512186791277525017840002670741 -11922204352024596469278978325035646517433105521287613403902396944414655739824695945028308092245747333098422116078042326104667969967224788442970266049942774583538734406057081597034454910987815490244451193242377705191422489528853976486607580169986057592557285271953385769215318545520155212402919465580052078255078759756709086185424029620805084776442744700501748376290562843380642608395240491162047933014854466267084965223593172702334466729933986413870670083326499598274393380692146118979961818816348097032083332695128587696590646086980241100792624502607816103195636761141133903550454815591457829485684936036414823492160) -11922204352024596469278978325035646517433105521287613403902396944414655739824695945028308092245747333098422116078042326104667969967224788442970266049942774583538734406057081597034454910987815490244451193242377705191422489528853976486607580169986057592557285271953385769215318545520155212402919465580052078255078759756709086185424029620805084776442744700501748376290562843380642608395240491162047933014854466267084965223593172702334466729933986413870670083326499598274393380692146118979961818816348097032083332695128587696590646086980241100792624502607816103195636761141133903550762846180970016276962461054254826162901)+      (num-test (+ -172649878347923210775992373331623646864 22180935775581457002090790736532281654456312526625354262953960635330604551829750571440878712430708012807252279301365732385899228826740712544768476577874129759972563823209525283326887563301081200476495752033290851190327066070873711444930389093339915885090143783170994309089448293499799071372787520776773788274677288230540162485916160484352398851925328125588729604931589867889917097887951581817207079060016091919559509735997493084833476849835444339835031436580214492450731100723026312163752403946315983551266206214298679421644737804098691991631489261658890937663698502561036246447760919715595005106669653475931803053499) 22180935775581457002090790736532281654456312526625354262953960635330604551829750571440878712430708012807252279301365732385899228826740712544768476577874129759972563823209525283326887563301081200476495752033290851190327066070873711444930389093339915885090143783170994309089448293499799071372787520776773788274677288230540162485916160484352398851925328125588729604931589867889917097887951581817207079060016091919559509735997493084833476849835444339835031436580214492450731100723026312163752403946315983551266206214298679421644737804098691991631489261658890937663698502561036246447588269837247081895893661102600179406635)+      (num-test (+ 17539006966816771902104329685391462527 15609797782337099611892065465036826453911053690739041627254619195700021040383385710184052653282070244915503750549545390475671883312314708978681904377133928647935359080875691628246716591529028104762422990155477702994042953196747769893182153631482194578269859879402160062955490194674372351117284129320011166238130774752386987036267064693133554447596069886693581191241594745541512444806003236372840085705813835001957163976961730871756250344335996073970142337882238844723800849054637237549515249957267772181010402413375667537558243971058326641257721901094391380667244006959028327507917720426571969997513984360849930719808) 15609797782337099611892065465036826453911053690739041627254619195700021040383385710184052653282070244915503750549545390475671883312314708978681904377133928647935359080875691628246716591529028104762422990155477702994042953196747769893182153631482194578269859879402160062955490194674372351117284129320011166238130774752386987036267064693133554447596069886693581191241594745541512444806003236372840085705813835001957163976961730871756250344335996073970142337882238844723800849054637237549515249957267772181010402413375667537558243971058326641257721901094391380667244006959028327507935259433538786769416088690535322182335)+      (num-test (+ 244901855797156286376563377540855746602 -22138106346578776369849317622304392466030036563754663379976505966920461958652141160336156065177498990718609170201272980114106671808245437660234479124938853665375934080221740523696180221118540569603989748587853373569525751680828044059607889572522502629277877343410298879764820905044284757389006201848194571453112545228115550224254565141563427486518108434758694923122284117299374156393942906293546318323661938734959824887786185558612820887463537294120950912969343488704744978847504513710882720654330147775174336365363311173472002077960424794151168301281665765411704505095008907760396535767621855642720080219960822554492) -22138106346578776369849317622304392466030036563754663379976505966920461958652141160336156065177498990718609170201272980114106671808245437660234479124938853665375934080221740523696180221118540569603989748587853373569525751680828044059607889572522502629277877343410298879764820905044284757389006201848194571453112545228115550224254565141563427486518108434758694923122284117299374156393942906293546318323661938734959824887786185558612820887463537294120950912969343488704744978847504513710882720654330147775174336365363311173472002077960424794151168301281665765411704505095008907760151633911824699356343516842419966807890)+      (num-test (+ -119403662992279138748600939857239307122 26272999248235953724172008428088697264933069743507017434844709711501131900922919455931092196539942532993887162365511473221418376205773427597933886270411672062672089518774390132453916538404354895529975888201032175628249480896964400801763570333497287321002961557096975786141940970260074557095118887294558700145949117395512768347250531196100831164663613049206690894640391431616112104502483838173255614981302462548882276825096564828583591963617871547373532874400764134244496979962241959713525053686209002866840900623246072884125102845824992994967009109046451949348656842486048332953732384499190437432898387573320391878853) 26272999248235953724172008428088697264933069743507017434844709711501131900922919455931092196539942532993887162365511473221418376205773427597933886270411672062672089518774390132453916538404354895529975888201032175628249480896964400801763570333497287321002961557096975786141940970260074557095118887294558700145949117395512768347250531196100831164663613049206690894640391431616112104502483838173255614981302462548882276825096564828583591963617871547373532874400764134244496979962241959713525053686209002866840900623246072884125102845824992994967009109046451949348656842486048332953612980836198158294149786633463152571731)+      (num-test (+ 313963939617834410089002930298454269912 23286645405607099799151331553995799851855144387826191186590140820016670502830395945076644578998873585162998873396623634135231418574284200209367505115739462344028303923666952261030907434438322884189133236837089851688275865098623902644385995630973049587854251981548128145516004461191094062488421288607625783540996659060285661398859383778209495884203323937672739376151794507745282074538961033778823733980759695886879886017489555795079194346438911010371103435094677167286870898482214310646392174423422237727456012197253183422715313378603607058548706460095379882633958651034759773864354021315490712575535559549015858088608) 23286645405607099799151331553995799851855144387826191186590140820016670502830395945076644578998873585162998873396623634135231418574284200209367505115739462344028303923666952261030907434438322884189133236837089851688275865098623902644385995630973049587854251981548128145516004461191094062488421288607625783540996659060285661398859383778209495884203323937672739376151794507745282074538961033778823733980759695886879886017489555795079194346438911010371103435094677167286870898482214310646392174423422237727456012197253183422715313378603607058548706460095379882633958651034759773864667985255108546985624562479314312358520)+      (num-test (+ 2000877973959266893810594143560134441447453310844726478119781029700338468704683515329516333146806175216349912753585564808803731447160643580198590073658869 -17993015014355471903) 2000877973959266893810594143560134441447453310844726478119781029700338468704683515329516333146806175216349912753585564808803731447160625587183575718186966)+      (num-test (+ 5492930533666246223206322654398877802091439062008700770880939594548305919677404080859141226095489505872709347538974725998600861651942609010590873980143878 15372278140141207703) 5492930533666246223206322654398877802091439062008700770880939594548305919677404080859141226095489505872709347538974725998600861651942624382869014121351581)+      (num-test (+ -13405500833215428652808705089190188280715732437731292502890523313631564795139560159124390691283401484515088713758307366404145018349044148223082253439210893 -14793401891248640808) -13405500833215428652808705089190188280715732437731292502890523313631564795139560159124390691283401484515088713758307366404145018349044163016484144687851701)+      (num-test (+ 9945195259699924701593703207751086973468898794114625092150620088406276196469184233537941913755508476427888065765634203723512911676149274871082481174186606 8699133332160461067) 9945195259699924701593703207751086973468898794114625092150620088406276196469184233537941913755508476427888065765634203723512911676149283570215813334647673)+      (num-test (+ -1785165974800693006461065312083337532938610906605533088558498259067461510781028452552786542598361030690629530721209490413999022804146471920873844686294838 -13079925952361275418) -1785165974800693006461065312083337532938610906605533088558498259067461510781028452552786542598361030690629530721209490413999022804146485000799797047570256)+      (num-test (+ -4861207515430071951958387366611380234482792653010151054346367776006873932152600469133110239669746470475230906073865131648496652783311445471793936775767736 -9381557743227419896) -4861207515430071951958387366611380234482792653010151054346367776006873932152600469133110239669746470475230906073865131648496652783311454853351680003187632)+      (num-test (+ -6638723469626495957966112633999375479181736600737250559572415894485618850919815869703127084789143821420728194272094956858541960962483734293877093635361160 277811698220276334443479876776376776138) -6638723469626495957966112633999375479181736600737250559572415894485618850919815869703127084789143821420728194272094679046843740686149290814000317258585022)+      (num-test (+ 1983880417172931934469534542170437296262471214582817006917470485544552211448284732460451903536334682269123998240709059499894818265755197559390728940140016 -118940994129137705779355371753506018694) 1983880417172931934469534542170437296262471214582817006917470485544552211448284732460451903536334682269123998240708940558900689128049418204018975434121322)+      (num-test (+ -9354509264984586574958285335910611806441061705184818350015454221731287473282231343722010109181841005578131927454778025302197744540571159656556971614966757 120224841184491944160266976391113485817) -9354509264984586574958285335910611806441061705184818350015454221731287473282231343722010109181841005578131927454777905077356560048626999389580580501480940)+      (num-test (+ 4389359421234641412950681847970318834150108533025088077429496538447029921663033978550089607257809597829358374972237448178553189381274150213236222139873594 106674783386899772113212633712093787897) 4389359421234641412950681847970318834150108533025088077429496538447029921663033978550089607257809597829358374972237554853336576281046263425869934233661491)+      (num-test (+ -9319417879153488839579936799737117639058244394679644240663244688680826325564084529474537634510092069422987165268448907193562300482925125162731530249763801 192969103435503875767216559494769734726) -9319417879153488839579936799737117639058244394679644240663244688680826325564084529474537634510092069422987165268448714224458864979049357946172035480029075)+      (num-test (+ 1394404616168163951844558734723678125985464491792846741433683801962971891047718103736551854371207400145441134823994228143957746922511631911996296931168332 -211230038021470285136061932161632203274) 1394404616168163951844558734723678125985464491792846741433683801962971891047718103736551854371207400145441134823994016913919725452226495850064135298965058)+      (num-test (+ -2935941510094051560788359387128767361559188973149773593522440619832472030019457317998381634585179453958737810428870232715146002408187749944694186205812791 -1221176156661231926164756142840452419679061324806989304452215660535991083923207702827717652226257158321829748247784282139952864899457896871473184473608543) -4157117666755283486953115529969219781238250297956762897974656280368463113942665020826099286811436612280567558676654514855098867307645646816167370679421334)+      (num-test (+ -1338674579024795395027232680327531457830908239605718353094975139226848400289367913459076082700361212506196070727982446232782659114647371030398516119682505 -1298372177520411182435886041880377054374169787570856408996533471838082317927648953576721017727347029007573543972764860712708420553928791798580799809858729) -2637046756545206577463118722207908512205078027176574762091508611064930718217016867035797100427708241513769614700747306945491079668576162828979315929541234)+      (num-test (+ -2072456075229532951804023218627137969798924912365258263779029006567941400203608770518731715660383378937120213112973528605594220795605977413985543331908189 -9744489461776287963808523409593616918248399004543154581056479712028497082820841423941781438667661074968238703192056877665754560746003512076830245760254982) -11816945537005820915612546628220754888047323916908412844835508718596438483024450194460513154328044453905358916305030406271348781541609489490815789092163171)+      (num-test (+ -2570682164188734368809161664810917340861573482754788446510182252413437925852206735928397938304353826925422441004271229738766803460790995673395984247950088 656920705293329551826685120408221577679101260931105312141757138825917579070505267306626244216341686712802796891966598838285570807961966448181138356047523) -1913761458895404816982476544402695763182472221823683134368425113587520346781701468621771694088012140212619644112304630900481232652829029225214845891902565)+      (num-test (+ 7846359203342053693101523606887617345982401999003795257520576318451663998927274759872692123323796450295314377046602880394071105863527900699633560551732837 3683380639347829102597675045842249667669675715600522157867595962635108482512780509393310714588544837398923613138772339053021025559943198965234376657126821) 11529739842689882795699198652729867013652077714604317415388172281086772481440055269266002837912341287694237990185375219447092131423471099664867937208859658)+      (num-test (+ -11692323148567132684205145901751681947225824260005631214936266006610207543813382900867093989444659986091234552140689684476541703112098935301322850961583953 -8534276689564199122569555420819240948691777228327984555753862457592427992599992931175844172478864477440165366128106812103785256271256853749622592560655914) -20226599838131331806774701322570922895917601488333615770690128464202635536413375832042938161923524463531399918268796496580326959383355789050945443522239867)+      (num-test (+ -10734754884168724884333968138739681643742524619139397687680049322697740991391014196697040576174049452737571835233123127815762146577096625434481167057340772 17059878151450238567815178684522345445687980385106446646013863901583786249398194029757376950491550197185231926262467028755342392379269039238766592672298850588065335172902157386017520689203005559576263548017475991638498600879259882041932152385436968424098224966518534467302264172016376096778201462205990822825056602379115848799619564610033123837036507127427054121975400703490855123544706355545059512146550901507159940126280812512339749605195422987937677650572797378799103456094203126081464905326203083057134061673694975250599375795827437561275156235513192978645909947341297774926450637694325145427434486258223666250272) 17059878151450238567815178684522345445687980385106446646013863901583786249398194029757376950491550197185231926262467028755342392379269039238766592672298850588065335172902157386017520689203005559576263548017475991638498600879259882041932152385436968424098224966518534467302264172016376096778201462205990822825056602379115848799619564610033123837036507127427054121975400703490855123544706355545059512146550901507159940126280812512339749605195422987937677650572797368064348571925478241747496766586521439314609442534297287570550053098086446170260959538472616804596457209769462541803322821932178568330809051777056608909500)+      (num-test (+ 1982582032974021971225071139786536402936929744496433027195224299475980201425925452469321205602618940472354066218156609448199804973454183972974358405933935 -5591374624026484498020036332218412149978824230210339582240360391202660977358546150723165491729699122647688030937226316069237264083850854032732663284717882873051337566653841254365703461654061656817936193716386141166210237666314879751427421825450110467888973152907618520704486700443275358649289847595635931220181024199692771066498714511145489237541761266539978351840438236927937894376002981658065431416811632941197501676956304254109064936038146674412392128883565757325842468006824235119684861972224857533964558963441079998949499582965764591461900562931342373507763081479989957632695010603500633322408246084430203281475) -5591374624026484498020036332218412149978824230210339582240360391202660977358546150723165491729699122647688030937226316069237264083850854032732663284717882873051337566653841254365703461654061656817936193716386141166210237666314879751427421825450110467888973152907618520704486700443275358649289847595635931220181024199692771066498714511145489237541761266539978351840438236927937894376002981658065431416811632941197501676956304254109064936038146674412392128883565755343260435032802263894613722185688454597034814467008052803725200106985563165536448093610136770888822609125923739476085562403695659868224273110071797347540)+      (num-test (+ 11532228364136654310006206557545352284448588590560137249197311142901246089838098630841794341370689745410654263817911440601934362503092628725755210859171724 -25776236925500995542036591604259749301547568770017466769502569415611770276300787105037848049555500555975152877716727294374436703766730618054071617947449695177320842403963009384468257891933593584757723535299746543328292715942626303315235241470269740287031317322772461137186093930239744879822272349431389779234805703118929710210161489122272898252221025966631463842234537744822906696719691188223105175714602909117904182229960075276443648211003011686250829474364425483901920822837775032295913486152631638908227467242772081310515646217115760180349854601959031626524004201825198439309850266508687796415478396821644422350208) -25776236925500995542036591604259749301547568770017466769502569415611770276300787105037848049555500555975152877716727294374436703766730618054071617947449695177320842403963009384468257891933593584757723535299746543328292715942626303315235241470269740287031317322772461137186093930239744879822272349431389779234805703118929710210161489122272898252221025966631463842234537744822906696719691188223105175714602909117904182229960075276443648211003011686250829474364425472369692458701120722289706928607279354459638876682634832113204503315869670342251223760164690255834258791170934621398409664574325293322849671066433563178484)+      (num-test (+ -2603756427337798371354526130541868239006085657393372011847827118826669474695402075575479286172808099892726251004549675772420422527946534088483901153485670 -10844269742362409682236511127219508926736627172993604953084481596070757241623728297275447608738915355190715664012379562650777199088096670239050254578284071100042116609747208178716191571268815994455064584659920497876052406993834873124981417288518101426395560764186717660091472734401090302285129741058888303693710456902635092811413971399734306158050053239768185860958896447298052082493590498954512083131068867270078638929796561440903919430094619437872896595720463663570751134804664228918188923926951933302878771189484614604311920655871182974081898031051411394311700207305532216445616083858025977851570522763537300875989) -10844269742362409682236511127219508926736627172993604953084481596070757241623728297275447608738915355190715664012379562650777199088096670239050254578284071100042116609747208178716191571268815994455064584659920497876052406993834873124981417288518101426395560764186717660091472734401090302285129741058888303693710456902635092811413971399734306158050053239768185860958896447298052082493590498954512083131068867270078638929796561440903919430094619437872896595720463666174507562142462600272715054468820172308964428582856626452139039482540657669483973606530697567119800100031783220995291856278448505798104611247438454361659)+      (num-test (+ -5929887196386997518766568868806997104240129372360669348628384183712406620199102166145939206783172815805659513128544493795329100599632286529420772709366102 24544958491142793859949310604465694574872439331169358241746200808802938771527900616394258199996170862256988647191747967628756772368808644819831481350919782560499270148419601775750932556119448001824346026042068416905254113155445053931789404515589532235225580737103411251232560863878948880220469490014568323308965914171394449781093816607870593225534700167342589927524232815571862258490314644577819742372918446373756857848586825568514909823940075182825283229026250682015641747568282510036326125505522447591703308661608718100933027549520132308555240654655887041040427813131621391320267698106519650611462269033902177180035) 24544958491142793859949310604465694574872439331169358241746200808802938771527900616394258199996170862256988647191747967628756772368808644819831481350919782560499270148419601775750932556119448001824346026042068416905254113155445053931789404515589532235225580737103411251232560863878948880220469490014568323308965914171394449781093816607870593225534700167342589927524232815571862258490314644577819742372918446373756857848586825568514909823940075182825283229026250676085754551181284991269757256698525343351573936300939369472548843837113512109453074508716680257867612007472108262775773902777419050979175739613129467813933)+      (num-test (+ -8848084327536592532063677611386811805244460767433749071435930786126721080365289638381557872263825830664387392539638767251180242665642373539064690745095464 -15917950175678012281826361248776190984758236997789474333609547749168308439513527143790323694526378056113636462939674273462177686456811495629631337058042159570336251822399402513133598701991665209363955263097315081570618652783181494594400709239428597117944511110842795526862595552977665064029517628515465251448116061875878430407784298951946811321795808932206846491091803276390661869369638950672478828532423383951689632136029256108992610781912267083149156104328033893238864631158195280554850035949666897861529711006187241710164902350100555999894332438423857208747342184052953230247487231455921360593096823760117493579248) -15917950175678012281826361248776190984758236997789474333609547749168308439513527143790323694526378056113636462939674273462177686456811495629631337058042159570336251822399402513133598701991665209363955263097315081570618652783181494594400709239428597117944511110842795526862595552977665064029517628515465251448116061875878430407784298951946811321795808932206846491091803276390661869369638950672478828532423383951689632136029256108992610781912267083149156104328033902086948958694787812618527647336478703105990478439936313146095688476821636365183970819981729472573172848440345769886254482636164026235470362824808238674712)+      (num-test (+ -16314775600714318471451792035636584056297958597339492996728118376578145765736873313518831390349547274517050864260054903974054712997529177834428786007341762649083404743713562157667828894017440065599882523458121037421757904691003094608420565550031561905074671735751685371533975894842331113347413787808917193134135744321547478500861021485075363990553639161661734684228250909589741380076008551020384304303171431833670236949934603973673998262066558668396388979463892768199916011368116729432353268535563246463324517035331079693172060671712718486388759443825620676228470068291448236914050793177812037679396721657020438979754 12553426083939460917) -16314775600714318471451792035636584056297958597339492996728118376578145765736873313518831390349547274517050864260054903974054712997529177834428786007341762649083404743713562157667828894017440065599882523458121037421757904691003094608420565550031561905074671735751685371533975894842331113347413787808917193134135744321547478500861021485075363990553639161661734684228250909589741380076008551020384304303171431833670236949934603973673998262066558668396388979463892768199916011368116729432353268535563246463324517035331079693172060671712718486388759443825620676228470068291448236914050793177812037679384168230936499518837)+      (num-test (+ 20637030084881771176788188367974505419050866216433677435050410899110162793040751338330447574748263391136356400036001988938659722098883893353523409458775455519257672423829361150611806294256710309281788819450225670112435352092313483086404714074567539245791066202051788986426960935796927738180831688497683293306590464598379493141645539253898709000874685535467854788184424886911457134522632486730390913239660179785071885982403741669161655812015114272497907946919026898579927936299607156006210124954460880383605958519412435713868501997649784658832599101777001703519408664662715322044086646014163774269660274683400619225321 11620128128044940816) 20637030084881771176788188367974505419050866216433677435050410899110162793040751338330447574748263391136356400036001988938659722098883893353523409458775455519257672423829361150611806294256710309281788819450225670112435352092313483086404714074567539245791066202051788986426960935796927738180831688497683293306590464598379493141645539253898709000874685535467854788184424886911457134522632486730390913239660179785071885982403741669161655812015114272497907946919026898579927936299607156006210124954460880383605958519412435713868501997649784658832599101777001703519408664662715322044086646014163774269671894811528664166137)+      (num-test (+ -9838804688358141062268493389453191808060717708062736103828856866310283812230958467655270667206937622979717683919584610288962829724022506216738929136418489468786902364550847498615864720240589837282441807174290461916292258263929411081218952357662703079709351365960916688275651864441386750529258343003652300629003597744958152243494244227986280506395347894285277364095898602965258114321853474000520432831298793365139040664543928707100657375292032051256485942532600998813627925626928634068613637417702688610315924917761411247617905738119218110678854564441914784262998574445847209847985439514580300936248281049628734475702 2380166482232871816) -9838804688358141062268493389453191808060717708062736103828856866310283812230958467655270667206937622979717683919584610288962829724022506216738929136418489468786902364550847498615864720240589837282441807174290461916292258263929411081218952357662703079709351365960916688275651864441386750529258343003652300629003597744958152243494244227986280506395347894285277364095898602965258114321853474000520432831298793365139040664543928707100657375292032051256485942532600998813627925626928634068613637417702688610315924917761411247617905738119218110678854564441914784262998574445847209847985439514580300936245900883146501603886)+      (num-test (+ -30961575335426221869515496362216292453766907587859856766456625722888557357647164641922707199324601608700561081422636642523431947551124957385652791834855425829101761914145137205962610515642614866296480715893528289170482422505734612327038754622917335073993027434927547277037587173529054849390646376806910407207016292483185533697336599641898250465186168797820802225861771331652801064811222606773495565340386327294310913503461903243119204619412324538886439122443769008953829820425376589389335553937319588224864611583436327810214798652896733118881040503785110481197462772022447173744898802421806800203373153221004361953729 -10586442965055062759) -30961575335426221869515496362216292453766907587859856766456625722888557357647164641922707199324601608700561081422636642523431947551124957385652791834855425829101761914145137205962610515642614866296480715893528289170482422505734612327038754622917335073993027434927547277037587173529054849390646376806910407207016292483185533697336599641898250465186168797820802225861771331652801064811222606773495565340386327294310913503461903243119204619412324538886439122443769008953829820425376589389335553937319588224864611583436327810214798652896733118881040503785110481197462772022447173744898802421806800203383739663969417016488)+      (num-test (+ 8835746018617511846981408800319983340292665114153404569022025834059427359831684523399830234196625160662387716033871154398104436720494608541518837969397374272734698261557358249258503982414578618525420572597611597792132117034895074841909295420434392963714805547538976612884853497014341345150095544449860198192757839489063747595073430612069212219930749783824683135433987509303139260133564905961552149844964215891730262218278214035649706577154652729844092199333026620127958228847111442161350881527928460177763370427262298116900358910460957772350452949782281117704005514462730290063772968929608448642592954601418753021512 -12227722924075527556) 8835746018617511846981408800319983340292665114153404569022025834059427359831684523399830234196625160662387716033871154398104436720494608541518837969397374272734698261557358249258503982414578618525420572597611597792132117034895074841909295420434392963714805547538976612884853497014341345150095544449860198192757839489063747595073430612069212219930749783824683135433987509303139260133564905961552149844964215891730262218278214035649706577154652729844092199333026620127958228847111442161350881527928460177763370427262298116900358910460957772350452949782281117704005514462730290063772968929608448642580726878494677493956)+      (num-test (+ -5455184800550144006991157215735481579353213544152145628297990102571936052187486515129266239245491863623978659179559754999567936067584384479787934704340911556625153536160778495579370425428019248950494107696016864499055854257192071541354806671987402367524770228296322497224645429524493838356022616251290117624472061673033274133156467148770562815676767117605001434288573911556053311048284534341905722947046607192815465807736361991479044698448267471087552952494477144251510778491315012457514838113324210534577956298926109164909779987221094000880908857594198276812276890284008572664102792405452379662935026125770444036994 -7349798942312432150) -5455184800550144006991157215735481579353213544152145628297990102571936052187486515129266239245491863623978659179559754999567936067584384479787934704340911556625153536160778495579370425428019248950494107696016864499055854257192071541354806671987402367524770228296322497224645429524493838356022616251290117624472061673033274133156467148770562815676767117605001434288573911556053311048284534341905722947046607192815465807736361991479044698448267471087552952494477144251510778491315012457514838113324210534577956298926109164909779987221094000880908857594198276812276890284008572664102792405452379662942375924712756469144)+      (num-test (+ 27233955893140063612427006607965940109569052437681267421929959186535416115028420267622879017163568256526042146282241931623674996867133390355390677118211537487769195270234259640386625552763891339073878417517169618832945750393661600092643257470064376916337734385887099957095417541169462231630821139075814859604097878094729685589777579267192538715202397220666651307185763054526407234767132218634060693076054116575833737797189157152326979078121760900891899319809724675232853322526718686306470372869701173824664984405178677187081936624687293494821338781534163633206006387449585716391843039459733925494003066841874935048611 -66646390577667468207341453008390168215) 27233955893140063612427006607965940109569052437681267421929959186535416115028420267622879017163568256526042146282241931623674996867133390355390677118211537487769195270234259640386625552763891339073878417517169618832945750393661600092643257470064376916337734385887099957095417541169462231630821139075814859604097878094729685589777579267192538715202397220666651307185763054526407234767132218634060693076054116575833737797189157152326979078121760900891899319809724675232853322526718686306470372869701173824664984405178677187081936624687293494821338781534163633206006387449585716391776393069156258025795725388866544880396)+      (num-test (+ 15030400024888781078933103028897733817304421960545019199443871381537070197157227994520524631721701055962609956080413517776229513420814407790533237358129529547793422514837651333555776540939235592155512951229106778709351772195248438493792786143040421233061520515971787881798980515709417481015662862327435825812557205663033601853937647320838585333754027488605638576977560072206293290493215523194883494322543800546276353830683084405428005815296131527861252717516620765986589669237487765523936713749717927502645633123584240464131140829496052170285171610845098023517906586134613874506419828208611247177336492131262918439281 -164048419232636429449474429717211197442) 15030400024888781078933103028897733817304421960545019199443871381537070197157227994520524631721701055962609956080413517776229513420814407790533237358129529547793422514837651333555776540939235592155512951229106778709351772195248438493792786143040421233061520515971787881798980515709417481015662862327435825812557205663033601853937647320838585333754027488605638576977560072206293290493215523194883494322543800546276353830683084405428005815296131527861252717516620765986589669237487765523936713749717927502645633123584240464131140829496052170285171610845098023517906586134613874506255779789378610747887017701545707241839)+      (num-test (+ -10227062646189307616073129048534031298512434237226774743330733206156788005874968173984804649812506029813402205606562016228122184161577517837608957023376079537037472977098465137152327215807765130656192272994478964341604278041664840636982572214751638093860605132350960802560601354006634296348422600320863531059118477125143903734159707623839282511184908969206873548650544269932394344952983661665472663102992782521888857016369837211403335306200813816060883478434441858442549261115972947741929087886423170398410216855322384956160289855500229952405068604320121652911887067414460828300146993858360430784079225137421074839819 117460076430162201914796277915447781936) -10227062646189307616073129048534031298512434237226774743330733206156788005874968173984804649812506029813402205606562016228122184161577517837608957023376079537037472977098465137152327215807765130656192272994478964341604278041664840636982572214751638093860605132350960802560601354006634296348422600320863531059118477125143903734159707623839282511184908969206873548650544269932394344952983661665472663102992782521888857016369837211403335306200813816060883478434441858442549261115972947741929087886423170398410216855322384956160289855500229952405068604320121652911887067414460828300029533781930268582164428859505627057883)+      (num-test (+ 27989453264793973121573869640708223239762902243991948581280654553806618470632044367386680716040316895884976837122054709584963028986161694425215067648887944710852278135008221491665079705797192389681328802747226171436158375378499411314855257919224316919346771317457123252623293612958336691335423245293660257386649100685560072354549579281852792682734916555498283053758141666658137856828164206947320523255487437004565021167276952652515632644458005291855624829941937578229983628962137595011570216766689546500517528191189928660433013004254032861383790553611840534023221000900694995707453499030166286828319347894538505334235 -59175168207571178843658955348404514921) 27989453264793973121573869640708223239762902243991948581280654553806618470632044367386680716040316895884976837122054709584963028986161694425215067648887944710852278135008221491665079705797192389681328802747226171436158375378499411314855257919224316919346771317457123252623293612958336691335423245293660257386649100685560072354549579281852792682734916555498283053758141666658137856828164206947320523255487437004565021167276952652515632644458005291855624829941937578229983628962137595011570216766689546500517528191189928660433013004254032861383790553611840534023221000900694995707394323861958715649475688939190100819314)+      (num-test (+ 1178650930337394440162727078866515771626896502845852711186000991913866844090831426017480263676964607121490209778220339316756171449922437605552456088105443130477974682689512446683178356259305893852096425478878588001446154476458310269704392486398646169362313605456233489086567865316333034897433650974160168545492823208575634152241341906068149887959566983066154182855136114289266802474404127414747112706158621650063987662749553991791509795764642256261917497984177610694405881831052199417235241109412927893781778469398975117797578753730248539151297798807326284978255001046995523851829184120171969918537718488250577987049 -151873924489040812813761508259707631973) 1178650930337394440162727078866515771626896502845852711186000991913866844090831426017480263676964607121490209778220339316756171449922437605552456088105443130477974682689512446683178356259305893852096425478878588001446154476458310269704392486398646169362313605456233489086567865316333034897433650974160168545492823208575634152241341906068149887959566983066154182855136114289266802474404127414747112706158621650063987662749553991791509795764642256261917497984177610694405881831052199417235241109412927893781778469398975117797578753730248539151297798807326284978255001046995523851677310195682929105723956979990870355076)+      (num-test (+ 28233332719950979786871881804755080223325040620170668729385709165879717973040387558150293205758215739710262749733170837042434162049732587908182282319848154049410849721309988807368466228286699721201975848741931128639324322061892706638973259354962358866000024260698793885547287093369940035337370984725857550291339492871017395328145015077506882578124550084937438336881072124376107623716831044079223921566902242543198986921476998895559488862309653154914291349588095330683589871173449191854284433182368052817373384461363574550061788800329400860372148193491004593903732351395815409821222597665222975816418433744748143385431 -43245950360315656184924888243641533635) 28233332719950979786871881804755080223325040620170668729385709165879717973040387558150293205758215739710262749733170837042434162049732587908182282319848154049410849721309988807368466228286699721201975848741931128639324322061892706638973259354962358866000024260698793885547287093369940035337370984725857550291339492871017395328145015077506882578124550084937438336881072124376107623716831044079223921566902242543198986921476998895559488862309653154914291349588095330683589871173449191854284433182368052817373384461363574550061788800329400860372148193491004593903732351395815409821179351714862660160233508856504501851796)+      (num-test (+ 17311283930487575047109155431670372891723312431004343097275158353815289445461275098157423001160013464866170709729134076291306322952612660169010483426086431377525432637844274608988581691477819008626983761905899834444008235608280930166913911248710072733217113558125600345343437000427963292980921009445490627620344145866648036116660335905940809860199697939729919140888034303887423527841395304960072549430314367914315102150378504502158659627719016733307736583749830415574905929299482373462584995162798576853564481617711234957058703455021082855018642616999836886763535412642684228990890160568207941504887072856663966242787 1954009743321912552050341299974626734964446274711484506734354360114801426013796892421541915293157994203607853436799102383078659985249097057923578528366737) 17311283930487575047109155431670372891723312431004343097275158353815289445461275098157423001160013464866170709729134076291306322952612660169010483426086431377525432637844274608988581691477819008626983761905899834444008235608280930166913911248710072733217113558125600345343437000427963292980921009445490627620344145866648036116660335905940809860199697939729919140888034303887423527841395304960072549430314367914315102150378504502158659627719016733307736583749830417528915672621394925512926295137425311818010756329195741691413063569822508868815535038541752179921529616250537665789992543646867926753984130780242494609524)+      (num-test (+ 1135960177108146621604027872788612991247811085764456406834564014092038611848908717507207251239454266163702244932570537009884467598603226302482406831131219148530146321028801515381981782506355042255201016953375149829517466449677312249611502599434850555618739830488706171667035140895674806873502543300909514568759918040129665855731078258004983486524477103833885001539135541445685573269814159175744401893663504523858005835387122082112362666991112899837534230326730196110477118156871579503345757821268248575583821695674912517830056856597644827244194658166928026249459511837772775196175188368236573504643083995409774002567 -5513982495816270388232134254127393284677692173792609278582774509636977743203029647121158805174638642867428501907786521939155900331399058909602425073976766) 1135960177108146621604027872788612991247811085764456406834564014092038611848908717507207251239454266163702244932570537009884467598603226302482406831131219148530146321028801515381981782506355042255201016953375149829517466449677312249611502599434850555618739830488706171667035140895674806873502543300909514568759918040129665855731078258004983486524477103833885001539135541445685573269814159175744401893663504523858005835387122082112362666991112899837534230326730190596494622340601191271211503693874963897891647903065633935055547219619901624214547537008122851610816644409270867409653249212336242105584174392984700025801)+      (num-test (+ -30369736932762868789456108597366835061749107555998091727589163626331595118680326568212941898571309672187038272915036839449380083450246957904300051802617002374912724325419651633014408152565340519439718081357147324136023867003917288524338643759680061563616479323818330115572573568245719292922176485298767387601922362893307843067637295955606642841006993776777666041277965868780958830666697755738164183356399977211227424725670822944234275611849032230010745799964550976844117943559190671369193871330514473741920389633762695829790016565565261170688485790141638094160105909405353382982945608773290740598479367828342651860878 3451570547959142767282758882796967240086418127970526029661337442068316209707489088420708984628065070358319478649952710478991064476168799556496237099109563) -30369736932762868789456108597366835061749107555998091727589163626331595118680326568212941898571309672187038272915036839449380083450246957904300051802617002374912724325419651633014408152565340519439718081357147324136023867003917288524338643759680061563616479323818330115572573568245719292922176485298767387601922362893307843067637295955606642841006993776777666041277965868780958830666697755738164183356399977211227424725670822944234275611849032230010745799964550973392547395600047904086434988533547233655502261663236666168452574497249051463199397369432653466095035551085874733030235129782226264429679811332105552751315)+      (num-test (+ 24749014370880469345815230363662696846133977441600857690896762642529872426102613384561609594131771018575590861342023688138502403609639138062665279129058939911797019091643704220495944170754490238422880589600838613701783818105188827633578438439212856537589855796204839275633245851474930725845096235668385012500773524750522781174430369067441632028068262240870795850561389232369373523415592833273932285308223863420210049445377497367753786125779044716949754454461623397410528064697616617917065021866397277409044449982605591256067763430930720398889239414812509701319783809830072841056369381573100589260104551934136733317845 -9461623592584966196513107657889418526847060851423069480904645009418813160370721071067349946095573698635859409908288864150475056170059858850823883834932131) 24749014370880469345815230363662696846133977441600857690896762642529872426102613384561609594131771018575590861342023688138502403609639138062665279129058939911797019091643704220495944170754490238422880589600838613701783818105188827633578438439212856537589855796204839275633245851474930725845096235668385012500773524750522781174430369067441632028068262240870795850561389232369373523415592833273932285308223863420210049445377497367753786125779044716949754454461623387948904472112650421403957363976978750561983598559536110351422754012117560028168168347462563605746085173970662932767505231098044419200245701110252898385714)+      (num-test (+ 19070246171469235561279483225919489206942407814032615339351735800304747459507922411906751965555240682457214768298108831815622470433175555196912899313888991765436434867025639919521068437191248198117664398275835972573354886915721765715992151871453808224011999677700078879590132676060988550961950472536029228350169237717222998397029428440792110955380302156159849645211726041489206565536560827557279129751110297078563108009278363910936720061216511798518178957070787710331228500533067546198458251241005176280410230146430275074766072259256583499095689284871987010372039977403712023630453400259082684930755893684499232318008 12330599952818018622104330691506128012101935028731995985677032980931398338453806827555760801312052792065671886621851470997557806941112316627790755867100463) 19070246171469235561279483225919489206942407814032615339351735800304747459507922411906751965555240682457214768298108831815622470433175555196912899313888991765436434867025639919521068437191248198117664398275835972573354886915721765715992151871453808224011999677700078879590132676060988550961950472536029228350169237717222998397029428440792110955380302156159849645211726041489206565536560827557279129751110297078563108009278363910936720061216511798518178957070787722661828453351086168302788942747133188382345258878426260751799053190654921952902516840632788322424832043075598645481924397816889626043072521475255099418471)+      (num-test (+ -20895998178036569919774658790651496115060841511658297683195804524712012347695091074325978179977718571444320688167469052862702339462089668992243209990795362064005869602003990235714500149401994013174762139297327430396441552225926368085284222509085197484452650071390132794942944512235132641643003294762547138305644086106533258432786768644384855008506026923783604514268955071498269812887794817192371944269611642901807443894686178438687102834127061425955994253034824027771176714559050403098437684091684851207513969915720607528045624635094984539637789113651579846373399975502788877555747414523231999341294756679330384323996 764238600803843266244444637050072967342049538611688895792923539838804953492110953673720766879606601435939162680753428779068917662740403667549850724878795) -20895998178036569919774658790651496115060841511658297683195804524712012347695091074325978179977718571444320688167469052862702339462089668992243209990795362064005869602003990235714500149401994013174762139297327430396441552225926368085284222509085197484452650071390132794942944512235132641643003294762547138305644086106533258432786768644384855008506026923783604514268955071498269812887794817192371944269611642901807443894686178438687102834127061425955994253034824027006938113755207136853993047041611883865464431304031711735122084796290031047526835439930812966766798539563626196802318635454314336600891089129479659445201)+      (num-test (+ 6243894672855694190803081952962387322599009058758027960092936187687064819462191583137945440936085088260632250436567758576422207449236613172605950116622271404444221039084346501796818945639456207912207604248991842124079786471250102192718092353598850889806607728696519257402580732995770031331187089424192803722612735557735028710899438934171272639518928194764526910590046378401600819132587804143949995694950116915803127294011661411525934100144319021440919928013617766507409909846670172516021888661284467975865076091834094160862228180625536450124272957206172214541444266874056050295270719541605687740822711659847211976891 11877496607682442993105675644902145742318375725225741293060927105303783712520284640625374957608051032540491531573337817824773543104969422017506696018037874641947740606655370938613842356322585858034851150595788166740174872996252792014218946552442572806242471174234462119454014379628228878122072189387777413014452140618318641689597452676091677588204537830401725113931418426919671512011822864583481449136550835952005765386885680701637038206002172218712504732572449659704181315669255320876647592649071711438131711904976335957846353867776093588236311654631696625859173554395714740218099921290128795607292259527492722462071) 18121391280538137183908757597864533064917384783983769253153863292990848531982476223763320398544136120801123782009905576401195750554206035190112646134660146046391961645739717440410661301962042065947058754844780008864254659467502894206937038906041423696049078902930981376856595112623998909453259278811970216737064876176053670400496891610262950227723466025166252024521464805321272331144410668727431444831500952867808892680897342113162972306146491240153424660586067426211591225515925493392669481310356179413996787996810430118708582048401630038360584611837868840400617821269770790513370640831734483348114971187339934438962)+      (num-test (+ -24023960171862805266003610953999097357395283354964456554686635290239019705581779621120391229617494503580661676939681517550103414632840981987397485411400553792707518662609532504246677658012933762605038799352109564432278094548068984563394926376371580465135388578139331334464060067790936072127680597181415407099723844313625277987147283697141407959289588588489162704824409673099509423520008795428217612706997355591985894255450783091681112776112997887084157623388943538145736618168104404283342039105202585543852590302154958791010622670839015475427693311663800177428904406869645066988663292128104453773413982185343111560886 -31939808827732134714870375774276102357277346245583282398423150631754622253109692213928642228787888509211781331649081002266227303203259124984426497846441848502574293640959494009564992092503141598640200823656998243767453860939156780549404892392521391484933772285520949470194562525777116137058001008184603332597820522016200623301007194309404025522056113671560767212894303567191067178003014955596425115379852712737129325098876542459702682095445350281859042779889411325882123213577906096942649941285655935053362468972482748617111598313960198743596285343178242282172686940700127068972627110105953098737923773182254460772630) -55963768999594939980873986728275199714672629600547738953109785921993641958691471835049033458405383012792443008588762519816330717836100106971823983257842402295281812303569026513811669750516075361245239623009107808199731955487225765112799818768892971950069160863660280804658622593568052209185681605366018739697544366329825901288154478006545433481345702260049929917718713240290576601523023751024642728086850068329115219354327325551383794871558348168943200403278354864027859831746010501225991980390858520597215059274637707408122220984799214219023978654842042459601591347569772135961290402234057552511337755367597572333516)+      (num-test (+ 14513652183174940741664411990199277445706189147726874603036586212536012746892966848269748909379750612027025331446918381470766609543142456872580466135425754204680927122749772612276850998180593344389487924747722210296498854143380696064338777945015153982467675141485724865534995199700908286263993697988986805404864429385840512740226775506122190698806967785494289035976495492863456705096841250592980439363856397663738211335801835896091823148249303370609165910779981271035234045185574995335952208702661648744928539539455138167482396767268362221492607154709559716065850417221174683768503217544145599044845325824451589309835 -12814535978730024053359592817368712576084646962861720729844389627130663192435154658607204342320327460695280260731620465435530495952836598646143907272825807563512741964987882356778796849529260646503692618525570185450780889283642116889481314560395290434301143877809550098309214046129802023655714098730144464028249594406616074059558969757405392170810220921023905546104487938441503430332099605473144930508420331873995741851604525954472341693863067199617721032815462094767522339305487934030130207039176659398466616780628644572276059410087128533031562978399689702766028716401176531098447698206272762966470643604141938670152) 1699116204444916688304819172830564869621542184865153873192196585405349554457812189662544567059423151331745070715297916035236113590305858226436558862599946641168185157761890255498054148651332697885795306222152024845717964859738579174857463384619863548166531263676174767225781153571106262608279599258842341376614834979224438680667805748716798527996746864470383489872007554421953274764741645119835508855436065789742469484197309941619481454386236170991444877964519176267711705880087061305822001663484989346461922758826493595206337357181233688461044176309870013299821700819998152670055519337872836078374682220309650639683)+      (num-test (+ 11356479761814008572465147431830778885327227506593483181241437802252618729479905490826767363633131720717461693888023278837835457496021519184903984385091047829540007466025527592005114414671285638168997562037691602144751434208304408870143450743278437854754504713023422097017723330207792526222436928747286558205279330508360438281011315147578105966454344087225699378388309094140949428028313539634103047841948634832398526343605363013644180832752120081735152285507591096001749463421326282317713079361827765412853023201330345752038722069405404812511739634687282327711258974520622248165974215116400638833123609666501349513623 -2451734542868054449539778460457497703609327132304922810342762480808881050209276687756391911546806187586640918078231508181876445466503459873508196878629364924241891220686182517218825181707207808769770392864734466652524094735160185556148554260517746279303022469784592528209667497664672945900929888144529727881050106027775707933311860110618130543481573815538047460723253898548348335762406437618625388229555824532715231231491787570056329865617082709588903922431713098922691537317839185452018617461891748518176708607861270770493263960554805373552348256747200291438630960804647686832667981625018361034564086859426490014044) 8904745218945954122925368971373281181717900374288560370898675321443737679270628803070375452086325533130820775809791770655959012029518059311395787506461682905298116245339345074786289232964077829399227169172957135492227339473144223313994896482760691575451482243238829568808055832543119580321507040602756830324229224480584730347699455036959975422972770271687651917665055195592601092265907102015477659612392810299683295112113575443587850967135037372146248363075877997079057926103487096865694461899936016894676314593469074981545458108850599438959391377940082036272628013715974561333306233491382277798559522807074859499579)+      (num-test (+ -1814184401790217165873937825605141478060935014868566665644215718762341535891730598045990231798382966074312671040257824056876679135909008140059087311700216658095793352051583071432744886316274989901835606602224927350560604355249919901932382803472476702792978322468747380191775778902733911968522382089332819162367884984027854067607561808704316828316820133400099093450636968732151876570835173932998599031643640476109466728761033062776578175554441947411139184426213290292577467587355369954997241091769769542810051228504545831588488726789173405585678190671534386784806998695797717346491308862362775748058331375692317599945 15466182953987394334491149436346080039471412309427279110582769586053943302670765125931570041904640518032832554998553018838321871748542118021556398569294085708441934948186080236498081517178574839977996802813431873543309853609838200338534343580791382510179184571852290959723696010410340740895530535423959476873857191548113125728667781953125153120447892632916574768078583174099545013854248664119997703948998871566374080719541931440495888606776561795893839624084254684939434035018741535261951124673664746010067859317726891535170781460914710499572006592206360512398012457295755926986236618644330364227754380084585899275327) 13651998552197177168617211610740938561410477294558712444938553867291601766779034527885579810106257551958519883958295194781445192612633109881497311257593869050346141596134497165065336630862299850076161196211206946192749249254588280436601960777318905807386206249383543579531920231507606828927008153334626657711489306564085271661060220144420836292131072499516475674627946205367393137283413490186999104917355231090264613990780898377719310431222119848482700439658041394646856567431386165306953883581894976467257808089222345703582292734125537093986328401534826125613205458599958209639745309781967588479696048708893581675382)+      (num-test (+ -27127130599753372624001250456405972983012981437652156246797208697430661165612459362971759027335854588888552031022264244768883843080959804690580574272908031271224646245152017114094021048441971097191444782106551075175878815012595015584723250801765859461211934306789890718268168352614164589637346918581658850565274510502652089457352942736418509881708568727739912127781455473660768550022762222130489047215089836402367851853412705556570667960548570630054608024914653686223423908494006675057953013815512203710764854485332282975729323105427143207127239069826750682633272289409910001698385240596625059970587393681128674617278 5719655139276246085992066702308194672442413085748146924567717361937179810269300239821879673460959112727066470468217892213025828988023367028158410455624528688729907493639908638553730770145274142147983721694721139760883483821883267129411125364089207412089113869427479340283853501026803387874124668123626271531796990801822527792189514551888019206405597994403243358155410088320317141454525417323186389587327532772638942220300149829241141659063128602316305332848477566686425551944956989370838072872906293845914921103561360871571846865478762953536949621421094416539099628942010528483544062050170673327754206501716239719529) -21407475460477126538009183754097778310570568351904009322229491335493481355343159123149879353874895476161485560554046352555858014092936437662422163817283502582494738751512108475540290278296696955043461060411829935414995331190711748455312125437676652049122820437362411377984314851587361201763222250458032579033477519700829561665163428184530490675302970733336668769626045385340451408568236804807302657627762303629728909633112555727329526301485442027738302692066176119536998356549049685687114940942605909864849933381770922104157476239948380253590289448405656266094172660467899473214841178546454386642833187179412434897749)+      (num-test (- 3872339191937382556 13437882608410293981) -9565543416472911425)+      (num-test (- 12702320881720530101 13823645380834800545) -1121324499114270444)+      (num-test (- 10222969257152373972 -3454292165863475982) 13677261423015849954)+      (num-test (- 591233951053628288 -17639978232337836611) 18231212183391464899)+      (num-test (- -7878405903223218778 9050739027069287469) -16929144930292506247)+      (num-test (- 11347120771894057376 8443917396834074370) 2903203375059983006)+      (num-test (- 7831959259127703467 -257470007821066702597399141202130667973) 257470007821066702605231100461258371440)+      (num-test (- 1092406341647857980 -325710450166845666190895573961860069495) 325710450166845666191987980303507927475)+      (num-test (- -4220606126689357919 73461013742902296577411907972196819778) -73461013742902296581632514098886177697)+      (num-test (- -5112059189225304080 334306213789148650102245018234146620793) -334306213789148650107357077423371924873)+      (num-test (- 3093346224554776175 -204967241927023874963787190016588249299) 204967241927023874966880536241143025474)+      (num-test (- -5735747638156472357 -3881750746805128137401544408305666047) 3881750746805128131665796770149193690)+      (num-test (- 17639095392510638323 13312205908441007415860933757605397223142073616822325142416364932887680287063250296996056787873086490231950036662943632990219865746131453861285495087665017) -13312205908441007415860933757605397223142073616822325142416364932887680287063250296996056787873086490231950036662943632990219865746131436222190102577026694)+      (num-test (- 16304056910692545233 1463591032326743052350022746892396184459320617971409440301562638996633667625451301419074212369365394140737678584830314878769698416417465834928609990708982) -1463591032326743052350022746892396184459320617971409440301562638996633667625451301419074212369365394140737678584830314878769698416417449530871699298163749)+      (num-test (- -10347586523508777315 12614325304787850623826535169596975975360455924114817820074336137897280818245940873677389644701038550150832199897314137414727161192173691528917744363375331) -12614325304787850623826535169596975975360455924114817820074336137897280818245940873677389644701038550150832199897314137414727161192173701876504267872152646)+      (num-test (- 16875252323587344863 -10230183557696638447600885112945653217398839137450096120772416948425622105048400944465287395231588821521217980407867153259741079758527788318592431794213674) 10230183557696638447600885112945653217398839137450096120772416948425622105048400944465287395231588821521217980407867153259741079758527805193844755381558537)+      (num-test (- 8574302739232756920 2945205250727759066959418729185252318153395797902208079569164623770839848878181416073351760975066439564334127158302281471631001294503759011790017443478716) -2945205250727759066959418729185252318153395797902208079569164623770839848878181416073351760975066439564334127158302281471631001294503750437487278210721796)+      (num-test (- -17657597319577965851 -470389901349206124503884936612357721199915776516939967013182926735009022045917047211666512521578494339222795740836335004070464944715357800461845632614015) 470389901349206124503884936612357721199915776516939967013182926735009022045917047211666512521578494339222795740836335004070464944715340142864526054648164)+      (num-test (- 11472336850218354926 16764018932433717867649699977474298016589762238077229911249331402108995850754999065988360217500238643747316139204767820295123085026049273617874157749889925712672510963712964034497935503076689670786498045302562704435768723916334451317158760704743066709581593570757498670622547878516907127632802801541072452593999435195637193819500375063696114131057474475407791672955417184592088612921927282233762919112197264895445408873539746256555444555901857369535350160665235184955438709679669964546134487688796078142789125799020704969226557493354453298489954288702387159956161243151013189140749021799388406290339231792790773612376) -16764018932433717867649699977474298016589762238077229911249331402108995850754999065988360217500238643747316139204767820295123085026049273617874157749889925712672510963712964034497935503076689670786498045302562704435768723916334451317158760704743066709581593570757498670622547878516907127632802801541072452593999435195637193819500375063696114131057474475407791672955417184592088612921927282233762919112197264895445408873539746256555444555901857369535350160665235184955438709679669964546134487688796078142789125799020704969226557493354453298489954288702387159956161243151013189140749021799388406290327759455940555257450)+      (num-test (- 12682607562584942903 32133619583510009354538204193505267426986629771080807813988708187761849276650847958886764459302043799013813125903744946349479743277662066609741649009023451783267511140245797235200413941774959851628239089013586399425314412329003636059313583335807925401822165199322334470452126484173417518861322963430951772895619791799137157183662289329901964728384697377777905235894234370773419160283767144177627084271804319157013765325677633945370597318765372346484383325176768117059688792498687750479618961541872574768601477738410497806623403054372221338126223825515939164627992974469102910882915893925327931884157735553718792115929) -32133619583510009354538204193505267426986629771080807813988708187761849276650847958886764459302043799013813125903744946349479743277662066609741649009023451783267511140245797235200413941774959851628239089013586399425314412329003636059313583335807925401822165199322334470452126484173417518861322963430951772895619791799137157183662289329901964728384697377777905235894234370773419160283767144177627084271804319157013765325677633945370597318765372346484383325176768117059688792498687750479618961541872574768601477738410497806623403054372221338126223825515939164627992974469102910882915893925327931884145052946156207173026)+      (num-test (- 14621880654476679971 -10075923784619510279100488003620810539888599376089081798647754628017452762406215094511315867213396543200861274584884759429891242650999761503100661310915213260386281412125687376866399124849043409890009033179987278297335571911640353059036551139958369871790768643514550179661619387008678118363266091945225880595898524898713646458647465935791224159084684209727153050053537752111696883536364966526666445737103854446009305531519860527938394412863332757413309423156200192973778629503534709731073637828912608835085933003410694216843775182940057891552358942312728978810053715387504707194992816961400377579655168106377696154728) 10075923784619510279100488003620810539888599376089081798647754628017452762406215094511315867213396543200861274584884759429891242650999761503100661310915213260386281412125687376866399124849043409890009033179987278297335571911640353059036551139958369871790768643514550179661619387008678118363266091945225880595898524898713646458647465935791224159084684209727153050053537752111696883536364966526666445737103854446009305531519860527938394412863332757413309423156200192973778629503534709731073637828912608835085933003410694216843775182940057891552358942312728978810053715387504707194992816961400377579669789987032172834699)+      (num-test (- -3220156644655019630 -8347829670073174550775641165362740628312221836466572623516708794243074870361401136762432100726575330214254748615114820602945887237367461962207075265579588481261313345359877816874924645801358760718027997416917747796144940020489321523749233377708490614979453376328244189926517907474704635785063100359787580409065317918203485474119227673185211436285930586838616288721370975925191964611302275354365110550116042403226844820172448647475637867255305805337047967053177320593337377763657329816935516961201488840745892529800883680912275812320160312651894919502389242002380151562481051684439333368396132543667539444686619670713) 8347829670073174550775641165362740628312221836466572623516708794243074870361401136762432100726575330214254748615114820602945887237367461962207075265579588481261313345359877816874924645801358760718027997416917747796144940020489321523749233377708490614979453376328244189926517907474704635785063100359787580409065317918203485474119227673185211436285930586838616288721370975925191964611302275354365110550116042403226844820172448647475637867255305805337047967053177320593337377763657329816935516961201488840745892529800883680912275812320160312651894919502389242002380151562481051684439333368396132543664319288041964651083)+      (num-test (- 11628988978410243120 21091260149209133824278525560739673446778991946138130571540201996950100883736332286627324787663044982195445635023357027423513202277912840570399895946346028843517588470258087913846945044832851780108963206182331994065720076983528527849542421619745503796476103034657238118665288185878258232226731582201217795631247916614224227701409259346052937919425072595891571572960468193421257458185693656090215937518204243652916583730260295885562094977775951577484951577581277292356830523013216949489797535362720471761788697932265967910160407593278848113303674799017334692501935041730808945554336564957621028111014116286675587727714) -21091260149209133824278525560739673446778991946138130571540201996950100883736332286627324787663044982195445635023357027423513202277912840570399895946346028843517588470258087913846945044832851780108963206182331994065720076983528527849542421619745503796476103034657238118665288185878258232226731582201217795631247916614224227701409259346052937919425072595891571572960468193421257458185693656090215937518204243652916583730260295885562094977775951577484951577581277292356830523013216949489797535362720471761788697932265967910160407593278848113303674799017334692501935041730808945554336564957621028111002487297697177484594)+      (num-test (- -15960716439913426281 18799211173341989380260980155501104944815245973352765317821146163884181375747259542484535639646490774929026134833947975785613727050541297797675705933339289016115326958150660323801621778641184271728990164666383865587422591755046779736996211052149338115836473967202556153668963815595875844414662034458693455631979862997316049580586739835122770408911308146605671192538040301857163633538268589024651373766021087864982140201615461513687698136663128896835597598904095187715456109340116329587986878167776146023396961265667934659006280575496363066974484893764810659481361856335795455814679851690737943592227795474197104696127) -18799211173341989380260980155501104944815245973352765317821146163884181375747259542484535639646490774929026134833947975785613727050541297797675705933339289016115326958150660323801621778641184271728990164666383865587422591755046779736996211052149338115836473967202556153668963815595875844414662034458693455631979862997316049580586739835122770408911308146605671192538040301857163633538268589024651373766021087864982140201615461513687698136663128896835597598904095187715456109340116329587986878167776146023396961265667934659006280575496363066974484893764810659481361856335795455814679851690737943592243756190637018122408)+      (num-test (- -181065640455671431985325539445069267017 14120143334024043377) -181065640455671431999445682779093310394)+      (num-test (- -91295299684959299024846233061686623774 6891102275697080803) -91295299684959299031737335337383704577)+      (num-test (- -252582289949155881579950873916766853744 883304029266526072) -252582289949155881580834177946033379816)+      (num-test (- -10104159950635417603045689770006558103 17251490913777465304) -10104159950635417620297180683784023407)+      (num-test (- 288463495341489091297108607960869684860 -16376960611483226267) 288463495341489091313485568572352911127)+      (num-test (- 204661965092367792468062569536290631004 7774991291341524479) 204661965092367792460287578244949106525)+      (num-test (- 174559967167400201536723778015754014369 168183438971818617783400303174116396891) 6376528195581583753323474841637617478)+      (num-test (- -253300708624436983509156598368557395374 -77166863757693227553099778725240875400) -176133844866743755956056819643316519974)+      (num-test (- -38587765028356074196061530813295290944 5999161273284748726648331130480323187) -44586926301640822922709861943775614131)+      (num-test (- -236400856885875891058508662756360145662 222191413471626205952456600591947275777) -458592270357502097010965263348307421439)+      (num-test (- 212937903940173587742882129816769611096 336470165768472077447806282475185249734) -123532261828298489704924152658415638638)+      (num-test (- -264812595676159375893264580577855253845 -247068943830535581577267897204259299723) -17743651845623794315996683373595954122)+      (num-test (- -1725732715479127274526681751197327660 -2279805492899538651574406423954277869507456204136276822451602661149698386520868702017367409743272511010382761246500508887739763323997191435566266331339917) 2279805492899538651574406423954277869507456204136276822451602661149698386520868702017367409743272511010382761246500507162007047844869916908884515134012257)+      (num-test (- -220007189346579184019349894240059989979 9116030813176547770422918633286023943039811682891023288884273747820892639481842291616424036020927750322528731882517057595815179415042385175627374957565803) -9116030813176547770422918633286023943039811682891023288884273747820892639481842291616424036020927750322528731882517277603004525994226404525521615017555782)+      (num-test (- 139683266109784685815165642637380856544 5782493350903499652295971390391981928106911831248674750993968151944332845911526084530951283012280786005612601970108688202931002414214353708335212597807345) -5782493350903499652295971390391981928106911831248674750993968151944332845911526084530951283012280786005612601970108548519664892629528538542692575216950801)+      (num-test (- 239160165978290709841254489756277328273 5152132850125501873897264811465207492706871561577273155117982457627773151595716641409297120994045059130053034927464958986304380141364542178714472948085275) -5152132850125501873897264811465207492706871561577273155117982457627773151595716641409297120994045059130053034927464719826138401850654700924224716670757002)+      (num-test (- 315772704643232632782106484978382006176 -3689252327480456512393153800679864208480329729627292260734151097785848947569336194072922395859496552999163037466184616218582046814434719444842678248982224) 3689252327480456512393153800679864208480329729627292260734151097785848947569336194072922395859496552999163037466184931991286690047067501551327656630988400)+      (num-test (- 82735713197488344149642668226610301853 -12473025194535761005577066561696471986140205263843017221991729197337093872383371857001077050460827652296473928714097816492579684543651922277865558518876774) 12473025194535761005577066561696471986140205263843017221991729197337093872383371857001077050460827652296473928714097899228292882031996071920533785129178627)+      (num-test (- 63472235942371758467270296983419551089 -7866520408163137968600317959735552406794938230345293650627055135268307695389903092041438746530663083967329111232451176014649873249349534808700483360707382397988918594143264031213181385790969271527978925616276399184489007642142996251807222768397530946779296600805549276528669432847672215219943599871223372831999133812100481632278022608906065923652981249057846548868473376683960144009223047416366697876553049362242497225174860431577034875737250719899362881567590934060155436179316063810148362442197071642183371654740845983314705249832168923202400873364289483910868432511677656218937984504828452980698439495961392749596) 7866520408163137968600317959735552406794938230345293650627055135268307695389903092041438746530663083967329111232451176014649873249349534808700483360707382397988918594143264031213181385790969271527978925616276399184489007642142996251807222768397530946779296600805549276528669432847672215219943599871223372831999133812100481632278022608906065923652981249057846548868473376683960144009223047416366697876553049362242497225174860431577034875737250719899362881567590934060155436179316063810148362442197071642183371654740845983314705249832168923202400873364289483910868432511677656219001456740770824739165709792944812300685)+      (num-test (- -284018520801241078671538235859630240269 -5529748211779294240854894683633173443789067073881249229985499707296461959655918837051490512357840133495603640185675483847478587849599477020706893805485599954539589062532211767295361120129440287144117406526027552427750375526095104163474774446716012360038076376952619723549765229763943818011605991300849052030142173100367582906381575666628005795818339029350398340616624791399526643991489247585213423174803853961438830286737553181353007081438503238779644371968004083452645077716952159339978836669723137339898471600546912430030276920763475622536295311290657163861398519747560279682401429552174530714298081464588450842581) 5529748211779294240854894683633173443789067073881249229985499707296461959655918837051490512357840133495603640185675483847478587849599477020706893805485599954539589062532211767295361120129440287144117406526027552427750375526095104163474774446716012360038076376952619723549765229763943818011605991300849052030142173100367582906381575666628005795818339029350398340616624791399526643991489247585213423174803853961438830286737553181353007081438503238779644371968004083452645077716952159339978836669723137339898471600546912430030276920763475622536295311290657163861398519747560279682117411031373289635626543228728820602312)+      (num-test (- -171812101820192353275910956459431262142 11401673303315394031728944442295528921842441448377692701102691446500671963119794838260543877466107345474902885032629120622020177051592733148817057943390167845763358795044702079370835841331467130719834250134674578757640577473495192331790176510774020541399177011446664359866582351045889299070080989390219063301859447807907203943168891690028442190793548699886572720360741686677780644932612683647303776634496172481504075784427704287335805355801794320914944330891519283383694196486986108936857630373759865062862204149003789919218681050221366182434949855054760827976853645027544605870235074909890698574792562001595287630131) -11401673303315394031728944442295528921842441448377692701102691446500671963119794838260543877466107345474902885032629120622020177051592733148817057943390167845763358795044702079370835841331467130719834250134674578757640577473495192331790176510774020541399177011446664359866582351045889299070080989390219063301859447807907203943168891690028442190793548699886572720360741686677780644932612683647303776634496172481504075784427704287335805355801794320914944330891519283383694196486986108936857630373759865062862204149003789919218681050221366182434949855054760827976853645027544605870406887011710890928068472958054718892273)+      (num-test (- -243638660221338112796448050030955119997 -32214383478080953899491069562585164652288236626686985994647827422262342469970423345510055643470262764747630363450204055220886177681745412924556264758690138113272748656941509018308925555317383307928766093730384151056027828368474245304944063213926492719166086055718735381341569379006804236876950175122702350552198046290567043195716369691666842524594399597143281611765509174168738392889075290806378316647736667077047013214732267367344808724905727602402784621437141760604478301412768904784950365257469208085143467704875589485635570084387755189599791857576855454112556762755762408826226326879491415484319411662301650468948) 32214383478080953899491069562585164652288236626686985994647827422262342469970423345510055643470262764747630363450204055220886177681745412924556264758690138113272748656941509018308925555317383307928766093730384151056027828368474245304944063213926492719166086055718735381341569379006804236876950175122702350552198046290567043195716369691666842524594399597143281611765509174168738392889075290806378316647736667077047013214732267367344808724905727602402784621437141760604478301412768904784950365257469208085143467704875589485635570084387755189599791857576855454112556762755762408825982688219270077371522963612270695348951)+      (num-test (- -126332081511349770866908261827634312283 31497387372874133218238910173378055967910722258532087598053588964599898753455370244114881403020152175272452951858324158004662566613339529101292284073176382818309096142522412043073218657587031893636358434796164444941535757484360125937835242214199979245499374972029624710574236962978707708765065292759037309958875006017588240959790355958632745299212449602934380927677385974488564420550408281673927387615657765312151272852486266800510090872812376232597458154951925709496664568906509814364388823105469855516803225244972466742963619633076158367569109107733990828830121948130235858799809203410103682003414364238243553515261) -31497387372874133218238910173378055967910722258532087598053588964599898753455370244114881403020152175272452951858324158004662566613339529101292284073176382818309096142522412043073218657587031893636358434796164444941535757484360125937835242214199979245499374972029624710574236962978707708765065292759037309958875006017588240959790355958632745299212449602934380927677385974488564420550408281673927387615657765312151272852486266800510090872812376232597458154951925709496664568906509814364388823105469855516803225244972466742963619633076158367569109107733990828830121948130235858799935535491615031774281272500071187827544)+      (num-test (- 219979452670016849533060110266815720199 3900115048441644499033281842448985956665866771934663536385503692700586024397767816761943054115584011069129310718114010862034970648115172218305599786238607524420973404711138276011261135403209178420948996472570042497859127324157786975578751148348046315727383390370594954695454631662061021971027739429505825056455676233533511412589936865597034183410893428831818716136282201523804692574965779771140320669492229416601369453681528301333865290947482219850340728455965391492610516639151652595539203632139883064874286555941718154489936421274731413286355640404192677546692090304496817063325766995908926108582896362623757323811) -3900115048441644499033281842448985956665866771934663536385503692700586024397767816761943054115584011069129310718114010862034970648115172218305599786238607524420973404711138276011261135403209178420948996472570042497859127324157786975578751148348046315727383390370594954695454631662061021971027739429505825056455676233533511412589936865597034183410893428831818716136282201523804692574965779771140320669492229416601369453681528301333865290947482219850340728455965391492610516639151652595539203632139883064874286555941718154489936421274731413286355640404192677546692090304496817063105787543238909259049836252356941603612)+      (num-test (- 585873325961105129055557280004608765382109855007674169500308242261038324959928764512890600512016613154122762798104714052579267789493643522748210870974797 -1855792162818946202) 585873325961105129055557280004608765382109855007674169500308242261038324959928764512890600512016613154122762798104714052579267789493645378540373689920999)+      (num-test (- -3026050092505200332789765255096964033685859497096213532090644235603419347590512426830117415222669642053441336442247132403948783838396746566100575461602162 18009081534399282710) -3026050092505200332789765255096964033685859497096213532090644235603419347590512426830117415222669642053441336442247132403948783838396764575182109860884872)+      (num-test (- -11124638695599888462310706699308855434715251048597328942409434888923094027849143412724699165971400546471660924330688750607774759764580214088920441698992069 -4827559068742614723) -11124638695599888462310706699308855434715251048597328942409434888923094027849143412724699165971400546471660924330688750607774759764580209261361372956377346)+      (num-test (- 4950293428090696283711882613183655723616682297360442241017758383241177602498881186549809051670562038601658285833496694108818253845693871318067007752043113 17597810481352184048) 4950293428090696283711882613183655723616682297360442241017758383241177602498881186549809051670562038601658285833496694108818253845693853720256526399859065)+      (num-test (- -5733769947958740467479139247420201065087494801172241127791526686385518674532830661413722661802560247463032020003355494614502034002778775472609306735864748 -3892174127829225880) -5733769947958740467479139247420201065087494801172241127791526686385518674532830661413722661802560247463032020003355494614502034002778771580435178906638868)+      (num-test (- 8320894458193427045187598554188178307429755504967209344418448624882517461814957461249858674758807195827056824653471934409067429988676743031117653237018365 -12861394200627120797) 8320894458193427045187598554188178307429755504967209344418448624882517461814957461249858674758807195827056824653471934409067429988676755892511853864139162)+      (num-test (- 13033402737450594044106258936169013897237368708138118260402180886096095497725071502601849887805439844083105685971731015312020770945603825344926844435936044 236396022362585261770052671762207864597) 13033402737450594044106258936169013897237368708138118260402180886096095497725071502601849887805439844083105685971730778915998408360342055292255082228071447)+      (num-test (- 12170667278114656173974716189098171384426379753661081475485441559687661443127166543908925678856145097632475832903680828294561265828775791256812588754280222 -276673555533799047589626400978981416789) 12170667278114656173974716189098171384426379753661081475485441559687661443127166543908925678856145097632475832903681104968116799627823380883213567735697011)+      (num-test (- -12755594876262399860618168642932232021734362385933348033134635580177924615701078617214764415318471507488803810365565826229169313660087149542130819663319659 -157671440495648010763311068579191828684) -12755594876262399860618168642932232021734362385933348033134635580177924615701078617214764415318471507488803810365565668557728818012076386231062240471490975)+      (num-test (- 8664063140780163008577373335591938905735059211566906376953760862047748343846207426667781783874718320339071949903053785280430612875488847226724390758938740 54361107931665215623681874454167019934) 8664063140780163008577373335591938905735059211566906376953760862047748343846207426667781783874718320339071949903053730919322681210273223544849936591918806)+      (num-test (- 3699576825118349347309026261327541749454660339251578894574483235547605815416603169143590292164644149607672871236942391817131531474661895913650810587431606 -50508350367572393968128467319633674717) 3699576825118349347309026261327541749454660339251578894574483235547605815416603169143590292164644149607672871236942442325481899047055864042118130221106323)+      (num-test (- 5626548453644136572409808769267055618695663227750732922630041368983808478347120771651822300668480671524976882745306794511840379704578900504784165956486985 170502882789371639987361620116696459267) 5626548453644136572409808769267055618695663227750732922630041368983808478347120771651822300668480671524976882745306624008957590332938913143164049260027718)+      (num-test (- -10859007735074693411217019392659638207496329895257318665547454149984863458541990037760564769787816800806064437172810158051442267508476778676439633382657890 -7558060977666720080449823996328496253877735754811271086853901493753796001778345391546991917892931500169890406340928835457635973812901681485438886367096185) -3300946757407973330767195396331141953618594140446047578693552656231067456763644646213572851894885300636174030831881322593806293695575097191000747015561705)+      (num-test (- 9842028993407961669727766131360795288615020071102475108883839785397865740828387076847892646234215787999498419839351470775471313077046438080666908734795616 8259939762466350877481193620364896193464602165170783019804380181692322874550956777598992104871440502758410340359413403619753571535498118388286469082729503) 1582089230941610792246572510995899095150417905931692089079459603705542866277430299248900541362775285241088079479938067155717741541548319692380439652066113)+      (num-test (- 3122315115429970622394662815735050825423438028108957393747131991771456957037829402044934484343765915727397519247940959221091465331254497476137639859816450 10737995515603450913722681305571315249864367824351372254572936648132763616823019940208526402092654554035074813865303483747097673960803093638463005072804384) -7615680400173480291328018489836264424440929796242414860825804656361306659785190538163591917748888638307677294617362524526006208629548596162325365212987934)+      (num-test (- 11618335890332522671268040181306950825004789685088262996478365976802329054158653675768163009290064139158450983598701977173152384425333441365287895694522192 -13130287008197231017935223399369698658354829835061356451363818961959486828237111511740029441613108087354987794332115218978284937263725126538295501305403242) 24748622898529753689203263580676649483359619520149619447842184938761815882395765187508192450903172226513438777930817196151437321689058567903583396999925434)+      (num-test (- -4829477140897377009195646150061276059814366801005389903693533021027427566117360765323647260121062827801190746646296803957067548167571028717513392985791293 10716557117391614298810040587314742187092120526669273567183969821384063434473189717686678450880765426943205955814024872764413373364846268902370055526485180) -15546034258288991308005686737376018246906487327674663470877502842411491000590550483010325711001828254744396702460321676721480921532417297619883448512276473)+      (num-test (- 1560421244904974852620371975782132605421448226892487453928759432083522187778803424020804578027100625536441377609275030418285893555753560195716001014786650 -11797558308994912054526619290334311429749533070145154703018977152548370444659962978040151671210413666186432921816690953994784423526183449271023503069393845) 13357979553899886907146991266116444035170981297037642156947736584631892632438766402060956249237514291722874299425965984413070317081937009466739504084180495)+      (num-test (- -7701347923966912534344428538744620884561375267012102797292378941649984539207353887059064943586048644516121387166836442084007442716291792933061162738380376 5290969389374230541016502448421359606252744677802288901830045825873182202718418905866055323957065013553046698199939002159982374580735362593037515863844280108947533575824820196689891621498006303535207762625068798755031433921940066544809959896067184147997503827988613858484669349726945188167613248195147619673963531690938913245110754715059472477991342216448470339490385593605806518967792963339193162830698488489270925945408227996742278697477358272529028932771642478870844024835907350391770605391526921411004262446196112836319091260967898895009427182171643279100998182191816962677328417390867021108292139204864164048286) -5290969389374230541016502448421359606252744677802288901830045825873182202718418905866055323957065013553046698199939002159982374580735362593037515863844280108947533575824820196689891621498006303535207762625068798755031433921940066544809959896067184147997503827988613858484669349726945188167613248195147619673963531690938913245110754715059472477991342216448470339490385593605806518967792963339193162830698488489270925945408227996742278697477358272529028932771642486572191948802819884736199144136147805972379529458298910128698032910952438102363314241236586865149642698313204129513770501398309737400085072266026902428662)+      (num-test (- 9733743430220591762422540139212426729307515492818443460852332805653889275463385649305231919846970974905736816260992940027028218064265519723018527155353151 -29407855293830047984154639411082591337348779678279017647951764366455421210163494489475996514661359700145916243499452007595041420522019751347743105082745321262372977262641488359297167392118038994384136863563032667040671405618315550876997904307423736276844997706938133936081058323434935833614475654922773162140266784233792639117145232791514703532554345086520312281500696798706889025860427142771458666376271994240028586899592254884476941388776984078337603148583453255593120138178690189726206775893096279000909079330468718593887702543025737308336025198677457129910473491269839827087491228569718246503140134413881896746751) 29407855293830047984154639411082591337348779678279017647951764366455421210163494489475996514661359700145916243499452007595041420522019751347743105082745321262372977262641488359297167392118038994384136863563032667040671405618315550876997904307423736276844997706938133936081058323434935833614475654922773162140266784233792639117145232791514703532554345086520312281500696798706889025860427142771458666376271994240028586899592254884476941388776984078337603148583453265326863568399281952148746915105523008308424572148912179446220508196915012771721674503909376976881448397006656088080431255597936310768659857432409052099902)+      (num-test (- -276731217243271862683214238489380950428392903790808046630969592255272629537001990355375434170910931115552132394269672247616298060929507021008951190291387 100289083769237476480554074865040988004216167545459907207847010762380733541100608695693297149249375537088329431700364201275915507683345148401600569951338052791424407090330310974243070931256108167365334162914085216447196038922091547331474328250886730614683299908003398886233860613008266913065047699535081030427106800418656336608005860846045905149012346378286475449307630537665901621055008855374148058291266835796203075976592585729940879567246284967856356337849150102261744547461816282538319258966892339056695718919291240188920586288417893106046698069355647145603908383687239983874164793005765733782432717429040621674) -100289083769237476480554074865040988004216167545459907207847010762380733541100608695693297149249375537088329431700364201275915507683345148401600569951338052791424407090330310974243070931256108167365334162914085216447196038922091547331474328250886730614683299908003398886233860613008266913065047699535081030427106800418656336608005860846045905149012346378286475449307630537665901621055008855374148058291266835796203075976592585729940879567246284967856356337849150378992961790733678965752557748347842767449599509727337871158512841561047430108037053444789818056535023935819634253546412409303826663289453726380230913061)+      (num-test (- 8505070389896098095621766692413480203366379968950158493268895987250690600795955783113900096527432416791184386061684833478921638080978014176210898461637606 -16410711613672171332126342754193842244915477287016327757357714698751777287458963458682349581881560880814595167244857846847668988374679430572782121021084683986742283012573569894084166107235597351093334125816075658348307113218478800035703971671113417712009419861470917307849916674203301497919242668373376352901312309673053175315189945730756118172940886476343290174961420986113367531057713782438374928471960914578818951372282574754612716278516397754222547513576728677459134022062202283647690649100602260948409511070624300011106517649666031530376191755817891213910847547809248990517666613043010292627100428536737652546738) 16410711613672171332126342754193842244915477287016327757357714698751777287458963458682349581881560880814595167244857846847668988374679430572782121021084683986742283012573569894084166107235597351093334125816075658348307113218478800035703971671113417712009419861470917307849916674203301497919242668373376352901312309673053175315189945730756118172940886476343290174961420986113367531057713782438374928471960914578818951372282574754612716278516397754222547513576728685964204411958300379269457341514082464314789480020782793280002504900356632326331974869717987741343264338993635052202500091964648373605114604747636114184344)+      (num-test (- -12618010259109779267590315037969998053964054382853891516547435925972388025118492931596200697357628900783311183940584302426381939302632641549019984810957030 -30500906828861638007306362171210132987300359439962044769219457463653547834815716264412200930088623097530758080891972640000479943534665059199377729854850415258341537838023739964147532129877743393965857370995558748807382396090020006195649251292012405690725917389684473999400905751109361754679152179983739269026226054012963756892488872262522587481931950410504651253101938824790285623805566521723062029033001745636445860437154344665483641408727637784045030118212476306906983993748299291616038887011943864441807818857508443930272872365334665976442185494702520760793786640113779099219233665607521784524244604432396247693263) 30500906828861638007306362171210132987300359439962044769219457463653547834815716264412200930088623097530758080891972640000479943534665059199377729854850415258341537838023739964147532129877743393965857370995558748807382396090020006195649251292012405690725917389684473999400905751109361754679152179983739269026226054012963756892488872262522587481931950410504651253101938824790285623805566521723062029033001745636445860437154344665483641408727637784045030118212476294288973734638520024025723849041945810477753436003616927382836946392946640857949253898501823403164885856802595158634931239225582481891603055412411436736233)+      (num-test (- 793528769616879938852241178439496352527042950647521648629732169156958768358523029837406526207126598190786120139491813624819360632811627576064199559812277 -7357484069649002655190557040768215614708659708788999334802985986235721030962928900092675952032143512196279092521450986819067071570862007086586132687661085824939677603953832219860573980632016025218580608321648907608385784471745482257672314890331358256478273312255285010343369949412955387472116587504557483184506548209831317705115523967163525846685455369176657510129844566195941925821733027993620517287411895496215426174909366458092382652675628195464969405904518323018004882611048769247228828875493680284766874334247375868318795940759082324831733175858991629741478124633015067484305547002438816473086042218906532116413) 7357484069649002655190557040768215614708659708788999334802985986235721030962928900092675952032143512196279092521450986819067071570862007086586132687661085824939677603953832219860573980632016025218580608321648907608385784471745482257672314890331358256478273312255285010343369949412955387472116587504557483184506548209831317705115523967163525846685455369176657510129844566195941925821733027993620517287411895496215426174909366458092382652675628195464969405904518323811533652227928708099470007314990032811809824981769024498050965097717850683354763013265517836868076315419135206976119171821799449284713618283106091928690)+      (num-test (- 30958566711373255787092081401292877738974978442987704470984765018293851031728996862405055424093249924047528792113585028592262445810946419909807061004531455817427671594281537965628880611732831524185850161910304038646992464838306728350704966234151134620041799373762432970330864023007632010865749239024802839173884778578927209741320635135275002489733299806669933393428518104197594560039136096527206600870299327752296492029012993590212340409989598323540081430189567580333356380487749078595746626408529223195894600223743978246922817054226858311823994547784553612982586322603593335538875728113115443554199017672360091721648 9164115638960783470) 30958566711373255787092081401292877738974978442987704470984765018293851031728996862405055424093249924047528792113585028592262445810946419909807061004531455817427671594281537965628880611732831524185850161910304038646992464838306728350704966234151134620041799373762432970330864023007632010865749239024802839173884778578927209741320635135275002489733299806669933393428518104197594560039136096527206600870299327752296492029012993590212340409989598323540081430189567580333356380487749078595746626408529223195894600223743978246922817054226858311823994547784553612982586322603593335538875728113115443554189853556721130938178)+      (num-test (- -22540807692474380279530794404584230073523360203115293035869063366926380719566516089428840111682263403627532047214106171892715667227836310498366393991106231487046533598391969789120283294510723096483520917309134391072655861112766764278247568027435618337967113341863713181603534251049249873125130781073437913954718595729437608729446837417196899902194261111827656247095442897532040935029872731410799530408713850806239149348700486268275019296069828199088780767614008685960242354118969741283398882689239770114582524756296906388861630890288875920861344939520380841337675934551587994259348267613541166769237154904791412049964 16928681651977808800) -22540807692474380279530794404584230073523360203115293035869063366926380719566516089428840111682263403627532047214106171892715667227836310498366393991106231487046533598391969789120283294510723096483520917309134391072655861112766764278247568027435618337967113341863713181603534251049249873125130781073437913954718595729437608729446837417196899902194261111827656247095442897532040935029872731410799530408713850806239149348700486268275019296069828199088780767614008685960242354118969741283398882689239770114582524756296906388861630890288875920861344939520380841337675934551587994259348267613541166769254083586443389858764)+      (num-test (- -5403850875869356031749551669837202919756114555261706106905659104903792701565965475066159243529680606410723686422444947172225540145977333194008702465610630608545009270872541652430806931212184915840724378685979865349848151917650322286497417985248678815214889868576385900691591784772762893647315325310416150353725001943778473686980157692817497562783521120544549784746647104651038037129984152623720529803205580894126664077380391379306511348324442512538418658728022685805514196592544294177914956734669359073791151050869328577099869772182315103156047405800398706114122356939316464974680113324979723289916823063616573634058 -10755560408227106818) -5403850875869356031749551669837202919756114555261706106905659104903792701565965475066159243529680606410723686422444947172225540145977333194008702465610630608545009270872541652430806931212184915840724378685979865349848151917650322286497417985248678815214889868576385900691591784772762893647315325310416150353725001943778473686980157692817497562783521120544549784746647104651038037129984152623720529803205580894126664077380391379306511348324442512538418658728022685805514196592544294177914956734669359073791151050869328577099869772182315103156047405800398706114122356939316464974680113324979723289906067503208346527240)+      (num-test (- 16201587974698660164372991183566748501003872177894450603471850345714117528335101264234127789041855420954511595895378320972957964222386731614839583078498685801156670229700092209313747849610762975747730086443186821337319452128253859293962343891549207804191088925361935683615063225197130192492652062735684739784075955094308092423304262201429421582566117390598395895220976999990205945523225411701169301910362640419341608407294018105959688929256136725564385243617240412649023368133778798063226772467915584333795357813292935080009919284755332034998122912861893282865727947810588086156919649131720183722427134042574317487793 -126159569916621842) 16201587974698660164372991183566748501003872177894450603471850345714117528335101264234127789041855420954511595895378320972957964222386731614839583078498685801156670229700092209313747849610762975747730086443186821337319452128253859293962343891549207804191088925361935683615063225197130192492652062735684739784075955094308092423304262201429421582566117390598395895220976999990205945523225411701169301910362640419341608407294018105959688929256136725564385243617240412649023368133778798063226772467915584333795357813292935080009919284755332034998122912861893282865727947810588086156919649131720183722427260202144234109635)+      (num-test (- -9976758107386398142455037422077809088581080675608340830198269021688955930541332630075972471934165382030070969307731206728197760190279942894255740733209190331510591013089699837164445642396864912572863786290237335963836376543389815671640509582958465164874961381137096877288362944469137669502842448492172241151419831252572392809173900377271652074261706120638052379886108764460001026094198502028776365675088466580595870167840105746912975236851293882732079317535103041585285239081516202482201377111734010788198635874359396626004300532752450289119192633850562141516671742961938277967783337559307443617308447853505824391099 13449070890444925581) -9976758107386398142455037422077809088581080675608340830198269021688955930541332630075972471934165382030070969307731206728197760190279942894255740733209190331510591013089699837164445642396864912572863786290237335963836376543389815671640509582958465164874961381137096877288362944469137669502842448492172241151419831252572392809173900377271652074261706120638052379886108764460001026094198502028776365675088466580595870167840105746912975236851293882732079317535103041585285239081516202482201377111734010788198635874359396626004300532752450289119192633850562141516671742961938277967783337559307443617321896924396269316680)+      (num-test (- -8570952518585194406209873586517687582701183275108243979199329595605282282125006489076327154374449108678257552384372919282846744626955206382078850958298637157198962032090439427286914716782317030245513658212430127586764421559372214829010306717557679285031617989735914399954286846456953917915955558448774972943731602144914068097214910567329340361564904028964471241318105967747431610163083002382821902859161510204381788262611298660559327478615315484763561786397041779926288206767156863141140852268323253657685018587945456372648431446464389004257999049529945532453598011773843788498650935959375182414447893892341891463988 4431555062692055371) -8570952518585194406209873586517687582701183275108243979199329595605282282125006489076327154374449108678257552384372919282846744626955206382078850958298637157198962032090439427286914716782317030245513658212430127586764421559372214829010306717557679285031617989735914399954286846456953917915955558448774972943731602144914068097214910567329340361564904028964471241318105967747431610163083002382821902859161510204381788262611298660559327478615315484763561786397041779926288206767156863141140852268323253657685018587945456372648431446464389004257999049529945532453598011773843788498650935959375182414452325447404583519359)+      (num-test (- 4117976000917214601143188578494558474138167055110060832594841842655428229500889876131794484851166401425675703592388271925904534237338595998991043982676292549088043959446082382516734793718348862105938692342851330680670593768890094290655852108130945387988863730762717733881418314989528719379494082656897158942547008663543153236129762264443358316776532465284014215413819415615612452225913947961681691310132286840303081453109375175436902292224029179426794714036524361081174901146731799945483243427138748119832116750910126386838614645397770107366925613473924955965862778639046707637382775371488874447622330992324750207465 329466253508616383200261654231797136951) 4117976000917214601143188578494558474138167055110060832594841842655428229500889876131794484851166401425675703592388271925904534237338595998991043982676292549088043959446082382516734793718348862105938692342851330680670593768890094290655852108130945387988863730762717733881418314989528719379494082656897158942547008663543153236129762264443358316776532465284014215413819415615612452225913947961681691310132286840303081453109375175436902292224029179426794714036524361081174901146731799945483243427138748119832116750910126386838614645397770107366925613473924955965862778639046707637053309117980258064422069338092953070514)+      (num-test (- 28857935543824608075326348244201981931023939250259142606733822094071772153858420201297951828741003977413353359215638528196235956061529059419904405354390715114239219947402126760298132539402386106279333968395498788354937020337343839325588433318100331044091923709732742795159387846354148919054314582749477292946200912006940503778924320301062789466388997936618573519744795661160190636101768486096961991215006236190655062992372061052426455063703038765465688361316141792840153608145888307784845264037109867657483109819380082597605481013612040648149090345778910883349230476481347645708269410828528742743794495302359380494607 126536164564464424337714470705049463978) 28857935543824608075326348244201981931023939250259142606733822094071772153858420201297951828741003977413353359215638528196235956061529059419904405354390715114239219947402126760298132539402386106279333968395498788354937020337343839325588433318100331044091923709732742795159387846354148919054314582749477292946200912006940503778924320301062789466388997936618573519744795661160190636101768486096961991215006236190655062992372061052426455063703038765465688361316141792840153608145888307784845264037109867657483109819380082597605481013612040648149090345778910883349230476481347645708142874663964278319456780831654331030629)+      (num-test (- 3146199586408378667812619157270468624370984629500707476575291934586478540055436137993431548830607708293475788354970610669452058906009873485175438772484599603993015239438297747261356407887781450787482447252615210880612867127689283653562498484594955015919746443263740095372831444793239911996227663006098501180972347442107190398034048225264564325230296723559400768342331039755765597288518435463475921534765025262262798267314969774604439319964638461636007229819888743218820584570149249791727508891676067767073852694327748467914037392778283816153183422263956621516748627574334199731850712255885395479903525322397561293553 -169494171680584797187706369710105239124) 3146199586408378667812619157270468624370984629500707476575291934586478540055436137993431548830607708293475788354970610669452058906009873485175438772484599603993015239438297747261356407887781450787482447252615210880612867127689283653562498484594955015919746443263740095372831444793239911996227663006098501180972347442107190398034048225264564325230296723559400768342331039755765597288518435463475921534765025262262798267314969774604439319964638461636007229819888743218820584570149249791727508891676067767073852694327748467914037392778283816153183422263956621516748627574334199732020206427565980277091231692107666532677)+      (num-test (- -17024716654716744558842421452239026542281806678754026383430912733874686056449261218428541803113383766132449624540209841726047308927951820311213785345168358108138304716549475322223600292513384537980742126687035576531330089447100646214364923043445903103768701639992829171572718403272488931980504461938688955457870904289239032709146514866818331202329982821151580491257491540240579366183525075936339515949345815704583685855315810611089822402567649542290589282153225725537026309623090382054078872576985425957096858376112688308214148412270019118710904983829984589093557307164347051152307499446188262820058714564165108542508 -26845770031559702758807696432929071597) -17024716654716744558842421452239026542281806678754026383430912733874686056449261218428541803113383766132449624540209841726047308927951820311213785345168358108138304716549475322223600292513384537980742126687035576531330089447100646214364923043445903103768701639992829171572718403272488931980504461938688955457870904289239032709146514866818331202329982821151580491257491540240579366183525075936339515949345815704583685855315810611089822402567649542290589282153225725537026309623090382054078872576985425957096858376112688308214148412270019118710904983829984589093557307164347051152280653676156703117299906867732179470911)+      (num-test (- -20875354448001792153279041347864644172439177882677780548397567327274288309764204295853633150227327732322157811413794613378828291977852467550695289535036337326494269114787031260705326469002279939986228049380615128280814933748700667874022724707001736732724010699175779382411342385842744973636495738468838244099596215421975861650998954057316519632062827510021706536194961332185926551767127180751211669386674770139039516623606727799489291663572125587356845055646322930167536458093283930082765496058330805117442824718962237069840252138957395570892073194575112213410604881673785921789655406716271370732069643455590690035701 -321447426701397438572265325285879998363) -20875354448001792153279041347864644172439177882677780548397567327274288309764204295853633150227327732322157811413794613378828291977852467550695289535036337326494269114787031260705326469002279939986228049380615128280814933748700667874022724707001736732724010699175779382411342385842744973636495738468838244099596215421975861650998954057316519632062827510021706536194961332185926551767127180751211669386674770139039516623606727799489291663572125587356845055646322930167536458093283930082765496058330805117442824718962237069840252138957395570892073194575112213410604881673785921789333959289569973293497378130304810037338)+      (num-test (- -6750548706930727136186675393752693335334383613941059024795513640678178119089262068912855951615043660442324823673049951182143778744824110223137384940032268718291241014850714197673735719784663896993460156686600813524168487673234842233781654493200950459723884918456280719440022930492599128086690014332139955274261568563155723011697763382009890186816226119314994799655369791620499988988986590903148198659095740939986627235565633349906453726759224441608018598520571182643709143072528030332708598472074166415467718451869993686505339408706320298338691467040585228617379086727764240955696690287600957842671916189752415855520 132223863177855649509430852484092802671) -6750548706930727136186675393752693335334383613941059024795513640678178119089262068912855951615043660442324823673049951182143778744824110223137384940032268718291241014850714197673735719784663896993460156686600813524168487673234842233781654493200950459723884918456280719440022930492599128086690014332139955274261568563155723011697763382009890186816226119314994799655369791620499988988986590903148198659095740939986627235565633349906453726759224441608018598520571182643709143072528030332708598472074166415467718451869993686505339408706320298338691467040585228617379086727764240955828914150778813492181347042236508658191)+      (num-test (- 15737797902964168014939893286340956118635524170934156177365242966267432695262586636031957242055461736359478270642576860414422844075672388559647477705484719667060463718865742735598799928335211410004369240278699196301127699945374217439676378682879115442203681638050752745036508637214733712716867800216723838016099572951915042604603457902610639317648800296497583507890473114507231814851908526534709496988648572353272479026750068932474334642929727977996779536604912743446197670724757690108283368934769626461285961947257397454619164856011847736479229692086038931510067165282571276049292116713101550911614590774659556899356 -6114512833799784097991148713266650451765474382378581896952003894922931741133332233338460555227243451198289670274036744955599177213449957470212981501678055) 15737797902964168014939893286340956118635524170934156177365242966267432695262586636031957242055461736359478270642576860414422844075672388559647477705484719667060463718865742735598799928335211410004369240278699196301127699945374217439676378682879115442203681638050752745036508637214733712716867800216723838016099572951915042604603457902610639317648800296497583507890473114507231814851908526534709496988648572353272479026750068932474334642929727977996779536604912749560710504524541788099432082201420078226760344325839294406623059778943588869811463030546594158753518363572241550086037072312278764361572060987641058577411)+      (num-test (- -26633154627863501044020127597209297142657179797586777727331879111280843451446814109347357601013807189824906954310855123313836812409388745541128842840054310853220032505914307470215180950497357091093642400638925719682307925365402618310180378684705799724964274776149984064608716300479893889145492885897234574442542501896696821902329473018442082678749291668341477914681413039643187020003425962922948452894682558162414623956491734656939841377698702802567258906642912449969621455596132708975438173455827361542712483153981422051943690720556013580161324856788091093465837542336129629269227369781823515673967591796132853515009 3321161637038961370471515250185392889390643163295535903347391615170504064647249127732639364682803744773593849851778894972403397573953564801884397178069327) -26633154627863501044020127597209297142657179797586777727331879111280843451446814109347357601013807189824906954310855123313836812409388745541128842840054310853220032505914307470215180950497357091093642400638925719682307925365402618310180378684705799724964274776149984064608716300479893889145492885897234574442542501896696821902329473018442082678749291668341477914681413039643187020003425962922948452894682558162414623956491734656939841377698702802567258906642912453290783092635094079446953423641220250933355646449517325399335305891060078227410452589427455776269582315929979481048122342185221089627532393680530031584336)+      (num-test (- 27668394897866653012794531261739800318882766882548843941974485394983434533400277607364280566269718161470415771058329222680901477416257843578362127708934184467195154000133252468684612556324066063725677629160438683034201285122508880444372096430021219637788794365539396242345208611990491721052691567092029622640533057073151980959055665792776356282961971341363712186503783566960850166774438868528799819047163739437906559674823146932668464230936946321915236658512741918196732794332451120218658490129307932187658010681746557120172585093207839141764683325214902696969028472942954863209641597556494684135445935915485525220911 204625459185084436546676461283890328511903949966691877662249903659689934813784661695047569885195881142676761876303280806728760511429260843727967794322777) 27668394897866653012794531261739800318882766882548843941974485394983434533400277607364280566269718161470415771058329222680901477416257843578362127708934184467195154000133252468684612556324066063725677629160438683034201285122508880444372096430021219637788794365539396242345208611990491721052691567092029622640533057073151980959055665792776356282961971341363712186503783566960850166774438868528799819047163739437906559674823146932668464230936946321915236658512741917992107335147366683671982028845417603675754060715054679457922681433517904327980021630167332811773147330266192986906360790827734172706185092187517730898134)+      (num-test (- 18944451653774463090918576081661764936021793389045063662102219434278236461286997354190032851092512146937346521704215170240383659165117708716738711782597164244188741818096207452074083439983059414271417130274747048227795964884943105011205424198661201055104372863019759130697888820715782179466491256695453118035286889359217448004524564796840711987314064158194625731263591557915838970249677548534895064545467992194029425250039951132361639559343536937119283951538321037694842089561504643350632756961329867761604760788760440497535611072991056505806805291706178639395690245460397975614715123591611301423752799666149495108752 994321141213369910357526037382331323092462599623554452705525887587326552002660849455542761618020243106424015447778226642816634338781654345001677083881111) 18944451653774463090918576081661764936021793389045063662102219434278236461286997354190032851092512146937346521704215170240383659165117708716738711782597164244188741818096207452074083439983059414271417130274747048227795964884943105011205424198661201055104372863019759130697888820715782179466491256695453118035286889359217448004524564796840711987314064158194625731263591557915838970249677548534895064545467992194029425250039951132361639559343536937119283951538321036700520948348134732993106719578998544669142161165205987792009723485664504503145955836163417021375447139036382527836488480774976962642098454664472411227641)+      (num-test (- -25075128489482657321316021943980016828761861550379828525731288423212311433274066958090940464803020097932875912251380196071686918459370667428905844496548191635733867314315152547202859654044591981512687559437417616479425752991419002108503390319869665933757684966460526631533822984311725217788657567199485442486045019468844265484117570385156844404625735176559901986920712550964238722824122000259551821135404274194791706113272773768366572120227974096419295159271316157215551931810740200836725504693738229444336470213883741520460842708733150362983831267583568258736572295448486287825894301201018490203520738439038977754991 -7402949251688548738762242219263594861535354011996392637087346760786292549376145193266590582054224293289596877537643409310483743293801574030358189880866069) -25075128489482657321316021943980016828761861550379828525731288423212311433274066958090940464803020097932875912251380196071686918459370667428905844496548191635733867314315152547202859654044591981512687559437417616479425752991419002108503390319869665933757684966460526631533822984311725217788657567199485442486045019468844265484117570385156844404625735176559901986920712550964238722824122000259551821135404274194791706113272773768366572120227974096419295159271316149812602680122191462074483285430143367908982458217491104433114081922440600986838638000992986204512279005851608750182484990717275196401946708080849096888922)+      (num-test (- -26509487378481600038412836495388065888781507388737194948728047318975269277448073484403390476243134990463394380967295356958474984927721196047241216945988250219075749832868804186657201899994373052648345989716938779173325348547767647529160988985542438998030764420175306438858518207072038513664360905985908879070216069156102379349899544471658754952888660878997691670566078979940005195987259493512159628198906090101827331841914429358969184839073862821059400943312264269215878469013316796620921077244799814690434355127994011220041638393750697699141479399553359747084811371804524490919966410379714725200415331414459870271869 -9247155945465656153397925559476432992975541781462281935278489123804934847762489500833913193183733932905776020790478662969835879365116238125565077744775032) -26509487378481600038412836495388065888781507388737194948728047318975269277448073484403390476243134990463394380967295356958474984927721196047241216945988250219075749832868804186657201899994373052648345989716938779173325348547767647529160988985542438998030764420175306438858518207072038513664360905985908879070216069156102379349899544471658754952888660878997691670566078979940005195987259493512159628198906090101827331841914429358969184839073862821059400943312264259968722523547660643222995517768366821714892573665712075941552514588815849936651978565640166563350878466028503700441303440543835360084177205849382125496837)+      (num-test (- -17010604274474750006607667808593883725990508452473783283717890546525148212376267233909567638545898628257361383837671935903199638230375408397752251127816717091041943873728526445398525706450929660366518707254053655364610471112296477865068960744948010561798109833411657930112293904378353445961131058136287425064317621271289456901138718557297733713446119244533144377470099270824020439428168481914824420861176457152299497728390918971852021025089592998997807574907789524112450146545688385954763667980124432645276563626082835790429598328230426471161191074551543308732791287559033843466623138171520961684959997180979203053477 -17319079025684619178510812811805110270463447771889107440996086020812918555191263705580533644731591929176480040622705607552852994906782176254877135818109655911838591767583157894999741648979817400330572419476101372927546509769818404491634583907246692993992514876697330603464497645633398167129555001859772111887143352351860130929715392173452396253437927361301990735683539169040916027268831202732178553152351117118606495416985612909248422655861312689027789401950549626643389790516560291620711705848717875304929186131258525831197192620523261738944873398924939726689336762464320190834794155527335576391767307110012289717973) 308474751209869171903145003211226544472939319415324157278195474287770342814996471670966006185693300919118656785033671649653356676406767857124884690292938820796647893854631449601215942528887739964053712222047717562936038657521926626565623162298682432194405043285672673352203741255044721168423943723484686822825731080570674028576673616154662539991808116768846358213439898216895587840662720817354132291174659966306997688594693937396401630771719690029981827042760102530939643970871905665948037868593442659652622505175690040767594292292835267783682324373396417956545474905286347368171017355814614706807309929033086664496)+      (num-test (- -28362352496476494327713713233021518136860402239251781438945998574753662942796270292818595738100959519541952077905620088422871490191217157269435052965329201030095268586136492980900212955645939325800541690754639292707053269767151001292253701853012092829784482071789669480438026889625605099744553642207773753943711175375843649210118677569597324789367425691177169929576236753018329085700397911235750600921874606148324025962628852167093806152864269874177214562322576097931390470469397118268354868919899638376323751276807304678316688836173746719723312665764603485606350244811113608471530958617108833879194264695174468397461 -4081062111675377984305281082755054920741203741273067094307824323728798665450292976016160959354997082250970415737745853292134965575242789548167162064123232363464302136338349828801951197252612093077640695564825095503535921549690447893467349156939791370286866987224201115453216606688305427702274940837032716124925028835914047967887674858015919302546781010326385758988488478290741665427521820112231266659657169118374988259423444686317389869729817643396097464874333968181509317307320406521221309011946212308190273531009796563611621389720223920155554879800901239072885025170342349379379336047732368458185953903872634982504) -24281290384801116343408432150266463216119198497978714344638174251024864277345977316802434778745962437290981662167874235130736524615974367721267890901205968666630966449798143152098261758393327232722900995189814197203517348217460553398786352696072301459497615084565468364984810282937299672042278701370741037818786146539929601242231002711581405486820644680850784170587748274727587420272876091123519334262217437029949037703205407480776416283134452230781117097448242129749881153162076711747133559907953426068133477745797508114705067446453522799567757785963702246533465219640771259092151622569376465421008310791301833414957)+      (num-test (- 10367142604728811799331249565431331488313655422005202933702176605382043644320209814639311439871418581341534233560256605231366966869093495784665834232350567124110194965198962966795893926025854156729633358240069116588609932539289897499402463770167927610848388138020589286461244557962368497723086593344721146859584146431437967506007518396464517349944129896971137720357645026281243138165214047233258394590454775153944241555543594427555914116439316287902470043292624597940465373006598913770411505099332700167695871387948271302951230983772351549087620538875967635100644404345317626621438913980275970160864401622986870735123 -13323117602411502623386235160326625769048477819798659261203460002048250420188223753407093545503703207645050883770850457071863684414849353264890601744588860687970804808452855795406182324143949747985869939791374195222513169904228914579995165180964917538177994190229733465224857616114628815752065632238207474599531507602861647623695058640735949593381112671690796335596142010430124683781417828023076027476816068202219709673411776556090962187853799456968290579708094595903778622705850818245685205707447012659247018940946510378371952655457988959551256869060428488498330109152756599450626641948447980234503249330875085656261) 23690260207140314422717484725757957257362133241803862194905636607430294064508433568046404985375121788986585117331107062303230651283942849049556435976939427812080999773651818762202076250169803904715503298031443311811123102443518812079397628951132845149026382328250322751686102174076997313475152225582928621459115654034299615129702577037200466943325242568661934055953787036711367821946631875256334422067270843356163951228955370983646876304293115744870760623000719193844243995712449732016096710806779712826942890328894781681323183639230340508638877407936396123598974513498074226072065555928723950395367650953861956391384)+      (num-test (- -25321281404861286799950777949097462701962113587443565138655462269365151737118518315058035825695270231347401755128007072923189452859397209062457461602335603630181865680063451525170253746137368267674863889514153713728814272332433431604233690200451816570240227260445028630591376891139306370205846627093813889699170594185178241812081296510140572331372738998993116117098817936927692238682202717231675283209016857095739468507690090676681400453024293870135659990528969837132054786661560150259115734877162158755858653364070279937027014730947342216816307219127474721622123875699701715404820384545693058511056735799834754890692 -15870257059811626693754498423136372480069134596343998984549199283973854570508228359295418026089909378687774627821225399931314225867711515277913855368473873536462450935842786002269065816311054834857109074848803122494252885020527074586145467185882674518032764708782999568002770206995683800833252068328835778749976046128872525287656002968632147457840467536682726059599593635219947081138082647985895437016641903078766878782632503812736486529143041369932038649270950453231711525943737962179463585338023463992816994328519710963267459007592689204838965317062070771191372220277256094361390952025057574056586665509010902583686) -9451024345049660106196279525961090221892978991099566154106262985391297166610289955762617799605360852659627127306781672991875226991685693784543606233861730093719414744220665522901187929826313432817754814665350591234561387311906357018088223014569142052207462551662029062588606684143622569372594558764978110949194548056305716524425293541508424873532271462310390057499224301707745157544120069245779846192374954016972589725057586863944913923881252500203621341258019383900343260717822188079652149539138694763041659035550568973759555723354653011977341902065403950430751655422445621043429432520635484454470070290823852307006)+      (num-test (- -10064759312484387184876313010284016458560725440641239737323234767636591183611201479885347260175161165340917225306019885202675573016295152797559983194160634880140345743489989007821872426587698574795394887035658449467358615185057180305109018898637903449135520486663185036663238956537895356325733583128141439025002140924158670346599492383552938312402521066705186885506193758499006001382444818328802338159713646715901977137011576113434170842422373328479181457354927400927267448788528116619711184792932525071391797130057189079431487557270366699175956757661488296856660145077706273571985222726397848614141194988258117115194 -3689074607001776735792882994440038588887963294487080609346609068733026224735369468180206799966728461935654851527895876039403151156669223687679382665269013769686991783531091821265184956524448064027733731862929686596729449196238312997460578818232100254940830907672953344544031914926653652310468671685310332327057444910423081752028857828828473637496272809899061573593874011995802487442092326045415689987885712749026491545159340468151000027397821404233369034594141219014219707193746581364791219277489927025992135462852894714639406751538919395016165215641239054420028872350709704191189169571752512626755385998505584006855) -6375684705482610449083430015843977869672762146154159127976625698903564958875832011705140460208432703405262373778124009163272421859625929109880600528891621110453353959958897186556687470063250510767661155172728762870629165988818867307648440080405803194194689578990231692119207041611241704015264911442831106697944696013735588594570634554724464674906248256806125311912319746503203513940352492283386648171827933966875485591852235645283170815024551924245812422760786181913047741594781535254919965515442598045399661667204294364792080805731447304159791542020249242436631272726996569380796053154645335987385808989752533108339)+      (num-test (- -4621513851362114851854472268081584822344822740665629177305004335694395719163541988311496405455186973857145245414214464449674464879082042971313025249648887349614046805778335573547862191522938924075560443632614665169520240664970180760364771373836023824195690134618554368845612471858027311791638881380352344527105480173917778084361560336490212845414303819150625355111300877737042696291233444311426721588476948565949641149735838580313236869041013210454558557732497012037162735013212361842433337324577522358968152852532145622765032318936569346015498130151789662274686368870963891262060214274101000058555635785833724062234 20283847238128227963042817384468009365120280641032764409860857066215336820785816567924217697745867082423864450685360959383940995237907453126362378908108545669654749698030305432673477271848544313029448526561606175059997663752601262173667861202924953502866611309434183496911206954880840674239880495147451496219568787221129244201657487090244435562896841733049066453539864301122516559479757096183362477594406691085946787803323712522074578611082872627361465163804239673539339633332349145205596371287028267780080937728455742966681547897652607170788637996317683436193829274172400558140357237480809582038468874094877651383053) -24905361089490342814897289652549594187465103381698393587165861401909732539949358556235714103201054056281009696099575423833615460116989496097675404157757433019268796503808641006221339463371483237105008970194220840229517904417571442934032632576760977327062301444052737865756819426738867986031519376527803840746674267395047022286019047426734648408311145552199691808651165178859559255770990540494789199182883639651896428953059551102387815480123885837816023721536736685576502368345561507048029708611605790139049090580987888589446580216589176516804136126469473098468515643043364449402417451754910582097024509880711375445287)+      (num-test (* -1412797070596191471 -15492755620416346417) 21888119755986895161222137392796809407)+      (num-test (* 16686841096925954110 1491135775021813104) 24882345731730524499708005167300657440)+      (num-test (* 13262412958100188045 -18379071970155621919) -243750842254847872704698616507823758355)+      (num-test (* 889503034794263569 -16600674457216690894) -14766350309325860687849239111838240686)+      (num-test (* 3148165694020236318 -11771070679825280729) -37057280896113409834434531491271315822)+      (num-test (* -4443818546267181727 -12001052312087213799) 53330498839175802532024121011435050873)+      (num-test (* 8305259347214213793 -229351169208067535459370186456659711595) -1904820941859811670566233132773219565154696335396051029835)+      (num-test (* -18273334758510166901 290047155020180552782039318570071650475) -5300128759437251944808204783222405076790289915320785927975)+      (num-test (* -703280433697652940 91110448009482115063492795153459771021) -64076195390496041906141380919369524419358692517527451740)+      (num-test (* 15279634596127882146 -220998726467849290098339792307263567896) -3376779786638352686104608499923871317791563686466157184816)+      (num-test (* -4472497681184076830 325612942672822430032905460436166528379) -1456303131067722058341139305566346079551678140995111358570)+      (num-test (* -6180420673489141029 -161157288800853703711204405567379740552) 996019839388256252540244286609069684717518686623358308008)+      (num-test (* 14044956603588468379 10163190459901171254101452124764637970005230126310661589196828892266636678427020930101076689732526935899135126391465178494895371156141265424428405590113790) 142741568963316278148132287599703960511135825069792278910440475692913696263448088587778211787403889397993501704943449376875999977937418748662459138952952917221024170426846410)+      (num-test (* 2133283347509865817 10577710515843519541178984366353275630877942729579274295972091544607384358263130633386329706527832990861547566574369528634541156662300858851752195966167381) 22565253698228972909216255630133478029433774404794962869038558824053350969301054394347471181756471783852326407546652836376109109470959746153989521923555764579738243072315277)+      (num-test (* 7812722507014599311 -5055959518947106416800910724733658104378582281318226107212861190073091017493970778425583956006925004399967175604321778956828368132273155364830637407968648) -39500808728232764770485117356353304373275127104839804121600969932458363071148383405901570717732548020267052999198017578112731079638156026910705662052515278317807704170401528)+      (num-test (* -17560801708050275829 9842515227842383346577123873881045824143545509071137371075701856197189100217561683579562062872293951325890789283651221922663521213150065638405410634222129) -172842458224605375239887212582262805312641302639067963604956593404910080268476692854082531021580381176489626536608405283010496488558204787140272050713264572452317265305619941)+      (num-test (* 16743386830114877156 7347065846171565625701636575261347705942035850951855454324853850791855951431141198155170102434274509450315416946729031216385536668189501958761688618635668) 123014765528775807847206414290825117502032199391400884957413813554539073118943905948723779020186281150198999824020769031248882909461419778092564985979904308229718874140000208)+      (num-test (* 12697192948029671719 -11416780209809507417142822520376617951137069007568339428552592261458272400645205700952156716454820410468812274673183389934216970221062627926131479014990611) -144961061169197993494569769162151457365959287966302572862364500950127981616038900865036521107816831702945678695331078399461327412574397914795455218447174498277798426197230309)+      (num-test (* 17005139720743105479 -29990519259587469661876904501488342396062731024702923152492275204626478246142153608222329335341363164148761307659972897552084842238285026253664841395295138667328930482145590159132144957515157474957872335043653264146346772142483721767458961320947069718037828473530001033848282453826154763424789967441239969918856795769965946388666154136004597297855416503729657013008165049478441197537144135384444157408972370236442813734429031404855591324183846423588871065272526864866155918285777640819778251612915859290336548446745308788013234099839998683451658620461972798204104633072664604846231692505409653434538208644416538994256) -509992970306921990341332390474393215554862069848994183152714032617297815196921655222705396130464246880845576204295466273071779248718654338767559016551390771145212884412809612574391658668778295682412755916528976282396155832617323980694289208942491001345059122414240884660276842648466533488559879226195446807748573906940273568334343093922652142252689341425941673567630236228358747411926991658260241924294146562230425295426217833820067881064577380516936937782688004146531121831211284735538742160763820814174631414364095096099434285754767091040812242751724012532803037860394426031234340719537172735695313262283511554154662650333168783128624)+      (num-test (* -15877530153400521290 27863984127681242643954505352420303514833683768731313003271701952957204538094398204984051331105594788039352443762851136101330385230866919393696564428736685568762923746771275677491379334452751710169529933675128178840986001684425353245791752781476028565228371147542431713985092322787978914276414008774443194161599919167210582437024618824616489802661351916633993681556274980075051797120207655478780052593534285265078265845445633803877185868676955831374479850746658711791169579387317321983669227930929736238215792068273805543745311609083833407544342964285215427999724272264458975101474080574470499647168865409458531868592) -442411248181132450919255517905812929771246981404050821923231762557171158858876183536414772404562764742655092127161703706239729646027465795612501446223663310668879007072125975886873343449629108246953385822769744013416908613100114754904323190537317463286500657291202287742354250227377164455244103312266617146454847578457073139633297517170508179596166314955134347046515455569689877574427319658085169791949003021426613961459610227430636932814700361914589752207776142403364490846294795496119883683491811246550808038342285518518431538295199537270236275774546666026424361019715280652576803278928827199810150387207105149968313623040090578323680)+      (num-test (* -14162897687527555611 -23016403916121951319848021112075986869602408568431399211927062304968548663313037929311574133954267816204873252195499803324830278637331653769648377216095499136975244697758388851688873078022850203685120154634090802825656419418077380419130449990938627982123188424119187922828250625318327074513352279785514062876718714640725789938556578327139793467832731546881422469843509318627826856881082450937188956068348931459011923844607158528494902828851692203126881727638511348944908726926619613375594042390434147948508706733126737304560579515324106834237197081860910657003346633962662773394999353766192391746258372744063777808796) 325978973798843759388794644178802841408656469654887121096165875654577046313115917671847505813174070119516580105483409446057747653173640660143855580491229746795572929387698247460831363721394707501497262525550824977473864621747159715947297817600227665840640555029633517390896890601028716769035575763283168066843141870124768085499453574902575378368669494153555135898430469356384416638130459557518713454927909937610851489821263029886989981438507377741962130296498574556444168140838201069779040087521405032426995145166201901368032136008107323350679784004016321425234898132080844200202007395427054392280809376612533414505539109579739614954356)+      (num-test (* 10844738523441551664 13010289169828379103330191247192587220592807931898339555723704078985668371901953113936581573750666143303899278973814509164982887504269303358034042953769514772858989849512527461308415676004712388964136857232374888643347097138114199889581495448978914022318770898259317738823514820591042321773469959130347470144905381758960436645008051488666423115693738341045851119808222048272924385188356021826450267608127588500233526688704136268009202730309974485584784539415807259862449203760469406037505772435323036790641520939576046423540699016607317147689982042035523118533555744274806239272109508745089640043900389441390176681340) 141093184161152226992592021994885140117836445291515772908453669279294934817987511015413332614094493905560980363483549300117114491702466085602279965168041684355125886388302948336158133555051817733078300668260616983283027038746214728386770752826764135491650323133831923154477800324207350667020747545837613879364064704092093040155243919335078139087599906324684688427176309081290932504214653249366429592335409761783188358003723753633106574740731573467850133547164922532633897844647383889253777956821171583261238607289172489135768839436605233457738153233579088224808850428203888700116300637190661108848906846940291749737998056247719674749760)+      (num-test (* -16402132873169057380 8202725117980211375579199554494319645475746305836527475507064811368616698686329266053570766100878145903342129595869654087772486685252653587846560946850102095086896668181099435964053041678323706849735936082196618754721606824996486473796843333331029865501790248862590712245450877098960007272754260813822886287008295409755783478345202299352891066800825979067590290793893933819913530599309037639082839491869155044147367415785329077864525961799400923643936705317921900308490987828345313709179960659814100113658528990241758360711799009722683007157350272749544178688961738222930753008443755881419398858537860612954576778456) -134542187307192759584182063854799850608007421111316277594191532129597970622559949723743396309231347084450105499455916612009290113746722460358793168839937004812915757145655285798961178877391232945062437277255128401572171216279188126380587081673725314534095093062983435026047851041796084651601813918099532876684901239903769891552275465470747567830660442193995685219383258617057944010709906130655663966913354414611799232001438943448374556294933488875450563987147224709383408815994320229340710143082135667640802837699940654151297907451396297241124380508001357553893328703788960812706653503939250831164194874527033594779746890593262611805280)+      (num-test (* -12094905083549825231 -7303327854122277566083382629094740392048421584433028903125893639493993705575691832165314461496849401726460344615713884253150283931509897329926825128629833541892164122168618243719393446304446866677253728405617434021389128710195093788280203239300086905325641224801020413858421914412156234316517981228056539721130386645649016559425091470643854813419057026759188125291655398451427686659900364573485593902992038773538760663063071699966278379037038361219424927031644750173900916227834573604566165762753650347331082640552394430002401423199016978155236550541225512734287851807727860645247391524620773399994302380387697957581) 88333057189654571362020288527489792875655269960629008914349561689924145109953656394378545526256758871407020025766992398117775520525507898420898102744530402370720932219749861094609497366188371774072368034971851022164946370916317410415503705484491514312339956381120953283812334833067601825812118392757289250628861166579446800637104996060739031010579056633535166403083327528575504427815713481850979373113173151813491831551023902022537957860211597622343157802805275942920911544696695931809085743355666792408029743911424760065578742910735408262758198787195579745280191859776661700139596074108035867940154338953640690242795671183308201526211)+      (num-test (* -81618231044418675360403541307856740187 9751573706924018395) -795906195858402819552264165081526765614024708979523739865)+      (num-test (* -167600745660011044249531125104202473984 -12960244919927910377) 2172146712516287908809731894157839567367040369214826131968)+      (num-test (* 90306383312124738690336097936949488486 156109477991590792) 14097682358164298866835386043901377722456291173827620912)+      (num-test (* 126202800261728727198105694812165074067 -17404362862588500316) -2196479330029905727399352310201914876903532806486592905172)+      (num-test (* -80093647977875266525946940496137725572 -9499399805878278852) 760841584053111508349403804472960020663660465509267203344)+      (num-test (* 304052889577333477963637861956318521374 7233536405885618691) 2199377646072361697737485358722028853038393128548297401434)+      (num-test (* -124787646062877233829165925777950698937 -125798384154373172164515376683173327013) 15698084237137783175768362160964949930745617334715009097620154581879012485181)+      (num-test (* 259623502197082370239517374851053110076 307089583871541575627915295134832918432) 79727673252974285068387698133566605944659309374400074880377824560177225320832)+      (num-test (* -245358177397026033963771466683003477163 -285087883756432161967673595037725276963) 69948643556453419103498093570621669430956866597291662675473644085666220495969)+      (num-test (* 46731711386059374483493216849082745840 -216522280665540473581476116002923812173) -10118456728713381305690589407461434638634240429858378588644634276171257110320)+      (num-test (* -301422430661955757433852743238845048860 -737194742467573013847855072675441356) 222207031145790358162820429948896977201848379524899474475604149595884654160)+      (num-test (* 109781582310220385246795023904554278713 -273317662617851276579672019029762858338) -30005245475518685175699313262818315773200953201653075289648004177366787958994)+      (num-test (* -312236719893391897821327608828679767006 -661158307192284418474080017860142217763949256471548515134335997907628404839044913830388499435166012788226998900468665646723366842553747501004752506346280) 206437901167986463762021023207669068873036145952740267172145693855475451354717023377588805030022300923600718715029262618794758202955817341818233889201852381575043965927328029955969846754837680)+      (num-test (* -134379788461141842858846278268259347105 -5535479645589936472405910397299739073641612836770238183712206042659632410776896398062277742229906915852933418684231779996404071421767274180368154310128427) 743856583805332082970350662728998610690268824090148728726850517499798631519601137183443104910590855501252539324674812560702657332874686395923181633958702249128106139207076314713649515720653835)+      (num-test (* 278271843790644800793473851247546123375 -3845690285506025443856370771250487683891303505653819308540635173436088084480277686684743918745832832765066355874381847690771330587033980524869033600561589) -1070147326395532917564114389205677334125034378502074943828571411806344559859053091006175486397820822872698474899835730026158782698085673635033947150554253148685482702599776833910878579880042875)+      (num-test (* 22345490710865165412267189692679994671 -13168094845644809414256057134926669929759930873747535851687323456073141938879368460977723280750841588750507348317544461824280674332488497533955177541413394) -294247541053147552931885013427268298282376074124656716577088212043667912662239091316191145352314750820026626159649861330384837204227899202392764926604802655267738710003310052268554637728023374)+      (num-test (* -223445051950608517881717261787296926498 -2609806601119499724524852022247741111662431776874117401343811680374867931883996125145979162937751368655661775097445043144114599069842524778189198926688379) 583148371568187658089071213924575304457465978545376486297236105670932990897420147110485946155066725440999079357995678147717407410446012970360780626554347417807723098476525833332400212113766742)+      (num-test (* 12604140228725912459681435851589379433 10671266866958584640992033560488052420339425977492420594983497264069815016478448589306666811246532193922229713077112601565462530332258877522384022088660628) 134502144009302626262781543880199144227907004673612064586081220538754991037447647926963488301214672345398823354945333417956344119228084327815583754032364976497975702972112644238248704660063924)+      (num-test (* -221289678591114384943252477126208006780 20020996887149770966522122735176842174467884990518978494604707026520269232864200848420530223248762875769520715632742683760311747174524709550334825291720803698613541109690224185041740294906022358446325921538593105347423518731748623037078340006459454656405997570119591344894717789372844612253617591807770017562530034107842444403952657949565007792107071767260484233194674888488789619319597151367813735192433631007526015463229060702510632792171187339118004038505860316305860704455466207113207893106982258864355430481457640304138738182009363353560090082819036973601710432437342931523433079941958203038050750205966472435692) -4430439966231074415853738608900692925851705818190624801199561884242897308817127146763274284287396980593383317678766559004881552228480591814939402896201244425805503258878061459604511214900528594870260206969839682573246490602076070316760182753341371682323914671418233629420599310422437691170629449435494697829163966912842611408632129590129483811802031178053300073562716917597174161526976287351465154825036851645956354853960835948518860624747958440181683978083391663149733813297698623499283645627889274004656942800842013709298338912226207338477579862672216831422765369078886850523202897989792734789430796029206661261129141144642117177625405158700499049991760)+      (num-test (* 180785619668676509441152734583033930295 -11909038209406834057075682058438206007134213485822042209417443270921391661498900475635417780140585878716264253792335317341527677051828500780153492153490249297998660274828986996948999762620400587091118252205695562417522111840305140989214300921122857271717052213225664738544344394774362885331856170636862181712515248810239601812262573113794334115259873527539564296101166439562124016438281173202196876398090029995104489712272260608848551754611421227761245487365953257890749115194455096508613617028024932657498899001119282498614739316599704645009607294747043489655424155986912576002393048535846081096337705941547991821928) -2152982852345560218506186041143281789706715672110278207735389192913214838321097754496849942223194392302524369156102301165660674797665128931611291246607346536492650554391248756408556789391955568308599431054809433808337036546281323840555452571430884302696950144068129601527530304907460164571704857360215834011779559395577299313379666503707563751314135201994045874159291100986903645360754621200008830207429980872071814202801994486961737459218017354210479544121100423399040398021780750351097082070296255480707530391964970754186799748521538525274241709676878827522138880241734356460339681718690408853314007343934035505873192699052380699509877559455199604508760)+      (num-test (* -196121729286794751535600080816329923561 31755463535476988506639447113088283661031267977524968610501132544098607201258848456920865390506381665724254592728643925608893982794532243733117636645689751360224314774452374503339856173343683819017479955914451013484169313685311530532055735999039466721411777061709328450052490025363788971916050033904534189719389237878257877112162843506491071470067738867693853480174965212750301808781573369342701195147083717623066339671595077736036738235636996351642097684597005928843274525502529735435418805821748637387888409663397547514467435322454217015563134545731593492200855670248739786405074231658957946422903165662016649229286) -6227936422881500100190187768375947805694946596622670066116457374856427496311253030141271922822486386675428302332027411428470488965226898801659352566022706152307022438261392466548357753526474097246042956052374187605144719189465046544498482461077851578811186829094445089366592317045580466302238653533114619908864036973070346979261546801894831273337217021756025770590122176562027129481076270727248949609326868225755958667670279949371399535144788247565199415296122873444199709788941984099349149684384486618280260678252604631431089580057102263617056951788273430713908768738965854953667135156866028646584137788146112300214498814212865170902491169332389942607446)+      (num-test (* -149247491509558553673630984739524508601 -9241905448313719916485289537122695595500213295294799660583133638026091750542612875183284894676615989153030773719811347110864468582634048542108726080717551794580656021381515769591713295631818532114918070215760259364277583650102628486861397602958930509695263902920994329409932518607260720657755504091822028630927071374796474717671220452208310602827254296323761245420486376569048549643478954846020045263141546849795367522490793641049509748005893155533480849922847230018411440739584477452313387881413141538766185123978087175960946255649923135634987656065468774634483495944248865774633962770893338531522570776854773975281) 1379331204929344851843348280532786532350930013132149419346606977890849868537539899667631713548510207947097949976792337278764045110931774279794402312944786743575421497528669859045492875676005849752425421867514661792129580445000023570590786705609341859529483054902802038173138834528021423393677908655442991197348183257271932188161681770513283703502340499171444058119260228931558784004778969491586252899270869275893402714040693571919281494643765571068045362364213060063345212881008657925426024923296369533374671614852576576041747836643356665301762059898161073609265572267138950725010661453917338098901465732991316661901878681888138048552901254914604845891881)+      (num-test (* -246070233154436622785727814428081917418 29761582253452470642591719346200231425423204062498655510037025199574178834762931489817919404889920159374886981199608181795387339523762458361385170203883094308920011218315748466148953320570427838912637152446837553950810011344492780712558515815917745810385725989241835877316836808088478276603934260581342710503593237081689944686263274319354100341139245512159619947319496638082702549196795236216458749363904150768879765280332386830831409591769966706351022328535490587838695167807967607003680703048770719240872629379640571077329748828739281770075441660330884779539288220944313294762143588847790653176774089774033399559617) -7323439484151992757431054484912931979861244043627630118213112440051387392428853497035249623931234821362770902740177541812170377563064854590834087655133962963430877452052749127605572395112726398103244974178157574726551814002744001021805127518246639418981066588073652668879613252372759895389345727455380224104332342029151667860553645106555190741775758687650292791318963679857313030729683299101577207875499929500963723267185390425716927303375831321783415003339099100562942730763231688479910689887284950156875532151104047755803876078837921949287811575034368641167438367411569736575067233548122814012421044943430647665260439418887639347030312118291762161708906)+      (num-test (* 203826295936164259559522643510940430939 428315860474710981601019542870649234168732095026625500771233691514247613083810271191136212287636290276352210600151884730196161003906066671915478570992925366265552107746965374246537358349673161970290367972281768471743836339191023211359427335141701167253694144280251188008871929010775436125645541749886873478179599464478734149706121117222690271210887178499620737860802605991262799781279373870647695125320153193063528861104479576369448865373971847676465682752435142074973627172566791961541105525781297462635428308325033717669972726101583722868689418677558787287897456521530400671342257419067050354522203242849353639864) 87302035331271280954456598486072605056704393103691656908943847729634903654600322194677794243221825233700566108459784062758955025931450719283517278054268553004951352280583820782976072352456972931479389375165173986780482062859853305469143408707179895843295115510597584169486406323435925707638987591151227843652210256611991940374072593149367903739596883229844326054223707236369465710416960023659329202073724249764308867733476242261506975691004092043954515337899900837434270833782490145948781128533218641649564543508314976001614187701395586824982250794852925954991265270537649691628899148413763865280007928191637215283244406869662872539567459561720369352296)+      (num-test (* -5899540498246269366107488541138263797694914692322476860852796858749106720144552037986906792251681094769894732746138541066810195167688318229720888479512583 5834015210744942902) -34418009003174534626858248456163154666511779871358190892629413477534042866009573638264296461516598238780495750056279721797403178867717911762916049857737963922333901125535866)+      (num-test (* -7558198374656605586076446665394545534375963428962439959101805545423930654069723860456022097647139432324162475685494459942871728608277717748075653794546685 -2079670855873590264) 15718564882684481784074014915267371190416032453294568239793060140651422710113447422494938907375595456199203928496644205320139985222135619659630853564447794621716315309474840)+      (num-test (* -9442744083812363570102321552182535031605446031706376100893354933468482520577272174689455502380973733378565213055641110431767353396963744600184737808983381 -7204974197101757391) 68034727473703353914019458883709211780958983263702756416891835054494728840771498925306650413027883039860202168095834137357212487561983607389479135319040711944281262212918971)+      (num-test (* -10658732210276096534851972646242288663170038580488752611749460640657411087860047053151548660331707024718100598181073744715506934778234716535781332588396176 9193953347013373121) -97995886679587166046252015742839992974979220158813197140160489510432960510418039749924861744197553021702396544307690217470606424904065359660871469041838900287446937257585296)+      (num-test (* 3330096979672637104536573277593029682675932033891010715180474877149733802060455951241981993421466123791200840797318740359792251505430948855600408060492000 -9413190658845804679) -31346837782105095097578725347257193539696338226258990009265748336528353873277500144838721882313026604404426563737656928378230261942407473822851842589487713775609448642068000)+      (num-test (* 2224201331350479188470378485954814766783857696988331736807430786504130570570323948774102396158334805040994159865821844362926631687258969480929122732089195 10226747830478556903) 22746346139936030910929166328517425029735137934434969334578972386859485783192993228082340012742115893176871887387993591191632260444955081663604449277961804869872353878963085)+      (num-test (* -12394770820700925077767705800588617445613665027183406054209162910642613421436080064653443098327137503596792411463268187212855350864330592654862321763110243 336135860956209890623046930607725140868) -4166326961171213704571179876442248501325782360170764344978629523457550315208845439497110652079907652744850691289494398473488033083739905461347650605270023127087625641779424751335704552988710924)+      (num-test (* 11792778994619176404079667787533709801900490264171877873621265044313417667869688303207909681289642260521608966405181881416781694320672906600599581862090088 -197661229068721548419113517262926820105) -2330975190212228827672814304508257223671550753091700552243633152084831515892056240354560520878171696176381845689952044935988868477421447557890739834031207059212175922089523097911477486879619240)+      (num-test (* 11608994516281296345925963401821217560860934641820086911326880657644311461955556832927259499969983808078591149768068360172431078248807463030805586293656663 -40654941048774156019243747229920736005) -471962987694958552110784676392477007070112288398143925079396435246284471999814508543057304008480666763661066976653446723271982094424149279649226771823800871458389214002872916339341019732251315)+      (num-test (* 4821517917539756801293776911844480642406562140007084392649374723119190602353617113036081438891134008988421494142194891002983491670246762173236312873933599 -255528396376819316172341014108564420589) -1232034741571035406264710387186737842510579499938716343220834781077329515145216794636313459582844773420679078031627466542930137302257934575129329529129776153159694412903937370462708576694469811)+      (num-test (* 7638751115643228563298483305056828584775811590562130101723525925933790010789130133831569153863129513189315440899053288261039147463032870669035935364282061 114438828287750304954799140618669114911) 874169727255956505920153418854946321208907128396839975975317705220623267360648189969313978740314703015845506506608054761304647627635292132043887080298168302864314697920637105700927041824911571)+      (num-test (* -3653826017463740005170218884285271512636869606149686475539243914909566619638259666405831445823138528809165270360144267462878986866506114069923299116957450 215752050445782448772085819939961259625) -788320455239949216234629350585027855111249573063377172522422069903710014529292638311216050777840734448624510386643245486023092483841464815987597578151663227035102742664709136512524899527956250)+      (num-test (* -43242564273985683175827997542883970694363047476880657467026050730764924897992516355909421962249292250047896135687573746158665836208681548975073555418266 4424346097667245771102179669235543742385176589624011161914909311078645828684936231569739522607200308028372644149306431599085361996722603718517735348761218) -191320070498733614136284309000213964486426347688040889144514933290125387693498098446328694172047943298442181705949005984031677324306763731212307716485454004382079159622650481983102917517993601466178931324415483972311904823997211920702201161092866663969163567426868740120661073974542958600768774774949607988)+      (num-test (* -5093597555679260616199210906198149266592665304134802327659606846977583233938836318559188141955851256260954289429418183711191354912372372976165948043123133 -2240632735861652612028397136046974907251405868353380459030143407902436514978447480884513019736738955326732458088791830752499716417751919868492224207936623) 11412881426559848135724717164530530041659963797467536748076144863846600718211858527283843975968920120508569299672573958424908957105703597501013710262110218780710678312197455759181436286391257283676806548463507528765947919856827004176416634630489598937924092540289712219714362500246928243091408698274649199859)+      (num-test (* 6049789822056553589237940133475342650218069231558204589924996117723031491205673061674252841792149409384720347601549237626288416453061224734057079515141650 -826416247951451524584060567988229017033981218652490450160817307801130685352465013890931297548015267655971295627931896259998420078888499206031390299169584) -4999644605638856588581238481465237523157457201817697008198975191261856978252081380810200468420738807464233192102972784271159116426108806200426852134469939032473362689081653859652824862066224063273799612269941254948709760659691148103622071316554194507524610166457990087959160807415102946877307193349131573600)+      (num-test (* -1175978338162966145239180473229656000174129248706173549637767835154921467129547950144109700900405904250603515318348888619371004435353505449762899046094747 8633693716102199391202401198009047492431980605560930404972542822133579985462906768067706391388213605203282586546130434156768523403030127356256666478340720) -10153036788469908062299722391986722149392791936544969945546931764708792252481931153733789787389051773529081688846141949513463792442701686406966696738286561777611293604311491896230769507535896070984747493738525389837795316954065260075941524322954935690803870500012809797698319359975893462672845329776468197840)+      (num-test (* -5083395547684319640767882199938390155755986838939007846911062687871291096073452055061784159768637502151635665247461348347470360218957222873087414506633886 10813098236568616588240471432239693891825284805405416395976866126102880121934298269375465735278296789484402954117593716698067735458182402220278016922449294) -54967255432446073625448401244836956268872685687128644401372608170106281377801209665004925733448944141633739594240156882328181133879414641109484442890809130544146420476457200729843868300396656004198615619691952536924980482714767859804902602805398865249514544806725162402291122143659939645240358379962457176484)+      (num-test (* -8944626200084865988157251013718979706166428261352840753194709093968177704853157211364231059892647813839391802007588961807572842923682104089512428902387812 3814836951264415657788614449012480613328314590744410079075164918748648723114236698412482309581077603776489883375576245233128800002373843611668945838558629) -34122290543331565327874124324135450224668275222811493728051290368641401807963502623692504750924543845019291736982354932620821594287780848608647686402233097059022704206628297180782771812500512744911371653368388270442874670230118309469599458827222162362901084328510647514081302476000779049412605744638457029748)+      (num-test (* 5186176030253526423885531264483408352469356233262336223619904269047786350470477526433506158542551137478071074193659876898065998079440819597952826155782068 21428324964794197485898135923805540163916541943812058590308650649384013587098638034673796533027113673143959572855470411726978105342739938341516634354246514986124789451866589211982659199267654387148420461876524076040233779391563396552267276880650559148637067641021059664960876301072636635299261389450890094318429077561092553337025096293793433968243940381587994428364726938534453507046761494257538813861046058298873206568935790790373886840765817404479239485444563488020955730741209738203470138117422899051269778988135668626686262669881048094388220931264751830393793846372816717368806996496715219806062282836392457741918) 111131065300898907482632501071313138589398597291097276435916516379173430095773463468344138866282820740991088290299992221985607057347883717514843661030457396422379155394966857856069231504805779448809986906434617741485942621643754096548512120178021034054648207248963478122178145159262707381679354401629366698488021743300737044695960363216253889163551918513521913593214414139637549577618641974388739304727218804595402055185824193445089425262833385286117064481648652550355832014346131722965510192584901901111154083186713580209077544982897821477349293279848852596241762198202012197892321827305803333334823616660229870976569043453639028059771892706354703750763908127611939169337399882784092285804830644630059487027413697220038110815990084742241055099963659761569486906596326424)+      (num-test (* -12615422028124847936088012564413126213419674293830655240645918456932358053670311316461359727921727680491520480380615359506308571290338231702217134487397730 21538722931308708400287621200994476771789912594554241036641406577761480056366647329031140922034590767810855360008375309986798226712928670905618807986829790199948665185268081173685941421700542631395958882077936923141152528333121096909688700106365468854487023847026564219531968849793109908193037522063952753477768381591929787242143631287330811801315216116212154423972654430356675401769729358415036943501470085182304183033246682446978634892995900678975109490698283226559860736462409705544079080978470202336645384768211440438501339641775269445439018148409151795830925198162301321965042997632479354427154223366199106583051) -271720079725309675925162538296715595434811519956795637977932956405490708202732964133816538801099235844279338645471102896234318181092598033040518838847055114923365599862266767493227393553801736813141780001130539648588341196802606083178208108557367013886856183999712817955194261262279080641101769944037282423238147653270651419282545398168930625797556638625301898893565965773914460998322350526545278664715332414172614761548301364063397364632709194713561073496860524124460861314674679928692398440036071116570829193414179054372604203478369755566003622621281005164747628075596444178089558747835994702060740334079222508147598079351187013336751322569865313532407367116553748939535664259669808534100091049960040092785009707220249025633808590643620557093069849490009472441113874230)+      (num-test (* 10381022953674450046578890619826448644067144294659610359943634722044183130638243233110364436029778310048006743033299956844491228999113516347401915490861208 -20974871685432829994714153210121536409377362402944992609230062091789259307033495284524234519701670462495676590513192861649457148897274608767543942797542628100823017887236899471151903799837558453043431373811892813126194662218472834650841742305925226558315372771353677064933578639099452438843500601586038910108679737480263349221244638463171088589123712367802373159421798288708123925853179931628847579314900787361946716531755600236755527982132768286927549323465697241340003870259800347640599467922823203446834792229595507968354687630029075884034263531531423883902851487995214646322431057626558858528344843531280263328354) -217740624416854507100100919338835880277259264187442792458843251425095703739537223785767883764746809214920580060316177442387941385712712426957388995082877226019966428812240179251716274377143798847348759498926420314709056615470455134468678662646006408843897699718742372199854223008996321568642038054564397441209859567556502098420151667437837356649730396360374136203172669776530655738388121236079327354422138744456395348910073462618440421257604563050031602590345028438897601523520973759458890228893913090702884911857207117714231568437403212806578764580006787626657709435954760239671948147344463295520930250155876010414461245194991189183956653772752290656063730950237649394743456230607077768595983629559996700837383822873994717987698780007691157576205450973669241823945091632)+      (num-test (* -3984492646329789478973994496812455855595578196959138558282015917391108383154917581748539892089090551298072688793487597623310815918942283997753800645644511 22199897116873160263914990610762123553075230334116099569358672964060004245706770678771431369917479502828754815568950371273785689812698287446020480951417047185190067265849637510591502642000414540862689426343523077229502494771352820057572619644085930901096534031496492870227890836816886496090287321502805172125273822231241073590840684742085641304915656543831190976008986490532066597410386596132766422026234488163435487889876791504407434387555507637783709991326338482319227500686541368087892665100076351075069628862376686619537655838590687615291898971286325099164241688147975845320979841704002364545072665891829427213069) -88455326811459002089798581395024759975871889172872668466370443703433800509268320055453743803627754859670391415348970278548381190662701716228279482045339649051139909543850883613464992501666524385524517648069873862957915620016943364950043289963237718026629805297916194484838158010754666017024585366330526135823515744339445036315966714684052345462172808299142368905939297220895721123725415007532441824406115746741972351142687017849809593982432484296719999502992792447259391592152463664807498752410740679664044620898308783634092355737296495489953554685938970593890496829484673393665321572846542839714620847185428664388282452532264810310019327395691530430185946743995669191791841546685206884247468693248673484055915613115527492005264289557719000245333079386593840592027314259)+      (num-test (* -10672574004830373997900438516438419278676753890756925443116289034080220708922677740383425352837266631691319394850521121221541344600832530724104047804922665 -7307684417326792807224298894786988180161884427390942431653062127076829842696634441114228528164049031680536693195116703321494895319862805505304314401000204515985676763063862569446064343853536464020413910728442475032187317639476018710375702206456631041987826826225461927793241495220512935434301833094232834266749666697332380140380619185254354273073522191066457437931022783436360434167505326773192959291779779370530770935758482422581712556111319611455306383173529090289274267200543081481693078804068524057891845603351773722737987393428313340760607600482724483853560340630587029610437280601010173185018227638972500038072) 77991802747865927212086621295493124451256238920588746597961055391511562690441964216934615500942858653797884925704270904527938466874924049039962754703188019915846345804228044693122758075602494985337649496117180241872910247079655077012999375809878184011356481981590430241786534827516536543734645410817621964035091467871491521760928486006653992134635010794346993161329777270345449763927429735191213854873362673179799811714902439637861750855639857969259787075469241319618538795721956528400353086156169058060112255274542232054021662809196965752800525093125763127895334967094763817500702626282397394521201385439419885607578137159972521677923972708827090645776826953976605193554447841693259586575931864396484621463004541561908426383260772786784541411548146173991869741515701880)+      (num-test (* 1420855003086789510813111205540636553863493314684153860389816109865085846062678305775289632805233481596171530412925552158799875183492757047174905459819169 13897739053062356545217161606361735964779941697726983959749295377836209520566715597422965426908191354971972501742952706730523748574796773473606175934144970768662226027157110240776527834790487577863781140089347362129598158760833470434895693782503529955845076709376071972727346128409008293671217324995682020009675316075606538241192607139905488719485728099428376369506685875348346231688684483781160648420909364963718027571565217314827671844485031440079254478598236877074793221578612249882886835580737423192061550370069895525711885220268707201966615936769696379335772521903910689934596134239331592980694745008817040569590) 19746672065138309742065153069587996891492444461032276894328314121573439684229636534026409362850111716212254549198595854140809664451286626009917828620279583631575940837712663100442879662416765138504151063632823014639305658882804073655537352377258786105147057375069447099908107785635606190515362082317465738205179108333064680370909383338688734129396788764959056886328471374018961975554190739706996184818378586233017775166959010668462907838359485424792026496574369912033757997469014639705459505746723512361959074802456098328538419933637295482429555127226978561859965498424173552676019033370307387047798600024901453757451579262061785051932535359410827170361533603618131510421439128567361259204833501190218719779570258541358012741265599985490513564378203502703406698160470710)+      (num-test (* -25117824099635104147178796272946098711514362630774369209876335291088434247131228189812265510495277875692804180473811834186270331245779845635089547499275113671007257221593872123397418355506777725721168216892830217596134983713752526559153149600553468865338887605949011743043425900799896245185282419637806859906582214420191794114207677635194054239563071023206500505880052007267243210206807805387341085613436600843317096291021780624738422589234020279836961194869688005260369009833026575446099544900581955685627511787510900479881434909308757027825050977932238481841909425598834367032841935054158448815026264505726593064239 7846111496222858966) -197077248428250572361351389692146917243277049539013604789802566767174747369897711991559940484392921619974209620152008632450612546796556905740493507885376190913893140368029841033442857949219716681475253727058707723386016055991276120001690579154370788782636181079931076758384034193266737114305362492836167078199155929937891579224024229182935372106924021709421948701131654358516297806197381566809357458374057189773041520552821330635689748583803171230633654728360451100477472934847975252390985102859262992904778849652221553818627134153578436315973777720706502751232660284910468721430874674021521629540714057383398858244828214000543075116874)+      (num-test (* -12000343217458212092754251360179138661969968218789048702097501439124892987400633614429800307263114371624489988815324366411323242909652002510513570900627875514001409309670202055060404640758548257776155562167062337394219073071639153822126554525439988062676648294108951003012550815746564810508912122306190725453386412796036693387315128514162061147675205485143205925649214342646148112549805850530430229663418469577245456944558387628002442451042105749848177325651852669794048215063957689756465788955050513359977166122710392613631703123491357791351447110169966270916789849428298930624807758982400706608788793481972190953569 15463017349709835150) -185561515374029078700596518575548896805308728003103939537818954646551372890610870275966055765608887701776880889777402229764948269089126750201922167386201171243298907675542965323275634529293654817279957832652909009385491998537031060285890512199675273422070784691446251899120095880199298512230290860589352290462643231396804350623684034400741386070220057232978556614620855818271117742675632435727751812101639747357642295230273344552327870600519422276996860893842363996198017494117619585153346745838853026029459826407782259598477529242420507010652705302341725948095720110508044256096963772599572721279996322424269691990173052929936294150350)+      (num-test (* 20244597897909303129995907707212050478823487084391413473821544089492035634291726811145005824559631386634261268723753786161463497881725871168747275110149007801865428978596190887145324535224079986377522166727137028753272158887188902047835658826867304220850429481233026043496635847568448251753504834367809877190895369288045026559783632709799678639927825194847005181499299410953860627694080906167346078299421796974815616608326704894611151743720515377248152215241639534004099341398238713597030368980166731393247619511322804984829747216779359780372801101821087516269912916462719248736442644433057333788741151270815989388229 17931151643499274580) 363008954869078360197158713265773114114991766614027768774402465306840646219477262855625957403406166192075865834283840624408916170935610374573318606346031792128003204902147985329385955814330782527184421959263266167048755628089412213360508944817963403092490479480264538027768728303095523018598016863928762335410109567604756183580676503045557867957273324581082608248341332512325136675167966306268035077761004923732568405295901819511346235524577361289712297365403327125212199451099538443576479787130510546755789504852631291774614010584650672707483555436445926222945298928326313943231688436271883746272589347954697213098866117569339490918820)+      (num-test (* 18134862906191691435095953372467318196853760384894170022863300447691250350836421337333332682828557871096554531436829166444150586004379181099133295174348038948038399079336722004125999533719492457544642570217406286811480006881054375314838605871238868968956868878182133492469763282800195060849734382249696543089869191257451321764806079423169235271658993054867624410589213892458246001270123109841429271429275464249821855221014782727398959126117031823977229309775211695677345378510417534328974531801634095862859684508240122911023047425473036305928743193594967362216559973174709883576295373749738633873828863608550295977368 15082354452174510460) 273516430292774638949326170314933525797985748367549139070674899956657807928629067317576809269188258819686207094298714770978509118959142516619521080722291318367607601498107007447014759288176261262818034997399866363248136237609824401265450913244758024085739876914482935655100890803279961929047974391299795570244708811454483314898873277493486428279875241232025231140855860469097028388778917980779775554139507550577255217032521719099071084956515691364008526064349956553916033914728254580848198941020806723485184338914882588931083516851849558411503129184026079582257756707601984686901646494090820169212279581209612798749779318126482639269280)+      (num-test (* 19213874382308276075905228027166553836726993832150876980655958901416537033385379180983129528081628446454583401834309285184752924794893846406622935494758142810049493348116192315865522516744262115026742103678965417868790607689989205765793528434388393584537260717130892518011447327847533083474230074174308157934463971640826422302901570010591182715932658037868980053012095115562188975692530473556182305847290196895478280679341869546292639446526021874910117953225154204035612531584978136604161393474554294315903436682283787080297348697922389355209790646124024053098888687638640826064745026930980189268652291562437512941810 3155416591710364359) 60627778016974262766014671335614995348970065077989108071534610098195400001445248886220725085881796599270026085183075312353388418711598523030563716616967792282609748819081238929738105086199457414615236966895805539596649555457494710621217412773036416007129418290246899690911654008867819945724649185574237527152410775686803449108977881160831441280833577932476667657759420192656716352190871667386955409426879693856001112340390304980532208752863058384169885129364117656404549585836664647784765508649117301622797243353610345828189312360124462238989888436478381583689386509617357901461416012201469794664889076397809504626996523928173064949790)+      (num-test (* -6561903839860415551587224953276060627466820222543175464705113686962550773423611522044145975606965294164125376820288981286542044306677764776675868357117109664125730405280822770267329297542599719353907954399688197248115043785617436343303277493146049939491224480136371029084354063731401026459653680017632996944506546122253686805764620116169065663214526857151412139439538335533979733329962892417175374550305659302592107472151941922230309227785266745974334776462642676959433923828440435340579340133192678341787895007461237846313005612116885419002449356480017828933592324336731295317076205553526568668826499450826560670163 14908715577157091280) -97829557993133908713082095435440645457469053259814412551982534425389603663024461131358343104414088618618030154957456050473312402460589893359522167472060177968099538846750606564761307960896264958539903740023783283814849937681270591589750181462708056758506230073751440847913386576449367635057595344744119561166438538811561109125506233466453974371464999669336530949393433719456191822836826214814780222021267726528396849558417851727452246676857867278196266042327956933753121947589485377148388716839519782819642328655117625818256334190717182923260613562191698788004591479576661108985313450029332968584240383859113741485244318702724563478640)+      (num-test (* -10378013547095983701124686671659666242518351347561698092030999302329372512356819420877395264401390796163955327080881297568412490286247154759694714275858127906305200295043241717769593877683535229411640745872559018085757273530771413156968541499388413497221629366848027355125816131586610997516488552323667400115617175682996681969687885201321292153656071894385242141321468096793766926179134511319941715949712230831768643024119693594235207988046511542691719002262040067921088838755337917414526554050602539873232518619281766327369577617796816586064895744680567067970817494102948032924671421242699225194947982378019119315136 30004910492448871409155105619400474385) -311391367570036811050052853596227388481520279736812036769684195465110674594690412517879149770622679377262288447706750813509857551308594851067359841826754786725926298013483569424123912020079066150719085450400229896983461212531213110847425940968466564079253939695853896434719530729030897976597410468081535234663568150722646854183317007227669132983719314653861536414057481478039579810285535699518386214012059191958557306338432321511585867535008319640705419431310336566447165302011113284064246284641707577414470505948868362067233709611758700034131461348997580441628136979257037186480770286846026250437141175360847735150981343952303257191661069675154710791360)+      (num-test (* 6311357747888359229575837883366949670125882865462293491587368290797766017168248637163030339387377997726585769250585768079027576213724941259801478313127113803503561717311996500019522893295813684259416551410025111443510215766297835872165689077882298506134885487991732718254835036694083204758447948541157893533099634169589161496492972953698758234452126564385255035294546278732684663873459439615228706684138982066055370429797835904846166362278557095045056472775166294675997320598469599722704075215700819354957397052721573993997624711445698656580401684113096559767093466880001548887739825916626416328760047783071058963451 -212654096583990292869707082365869207538) -1342136080095566600483524091094048745061145155430997807005186206704767933140306297188996797343723817220160636373424666345108189275851749622201429179882167381735732553825696482751584102093819432866729465599060815670807282181979889263381844726842751894916887860819210652174987999919869623292751389157233409465756974677789790982740267208982768450215563288024088369480574425410032306456026930809228182100949940216614156925537929648841127727165386031716586596638254705402653861723407930666152691102484352058909219619985877341630210918347460471644327858114815713557305185589162775699323253049631349906791700893878999711846225062306568467992135934882289075693638)+      (num-test (* 25104391676237653962996674810232896003857294806799086059884413856421530328279649263948893056601611073815235439115612155497964541323584159786678357898152394779494741995735881624055133443980324145256438160990490767324719276757840825641421547232460969806196141938571103617707677351907526127993230143577974386169402623023560579220343920203666762052525898442578990183400559087522259053245822827313206196194989095468393682721753147596892214609346047051670610252732846805143964713621673722554204896154742594858056891979146566683467510164875593192581407047920719605560716270697985110227952698114701527191421628561835164291236 -205991315859231724218751687295926841150) -5171286675233738337789203670843122752625713948587464573381323151628930998435518250812603433784823922283042037694290795352461861058217142213862777203850665369756106838860420507328654214723398688455622487003912073924323587826356928211672752672052670663842775836967587150049181838707784871641183683742967716787111671792311389517753578360293551031540853470719098360013225516593755039537796518619542838794169319227197212817921098393499332268929332950035803734983497370378852859829228973012039890600437082235032378948656232679080766068869430262740600476498399803176452431728914806536862849281928869092524387549297345184969051926149006293586531930828748109161400)+      (num-test (* -25971587288596053786734900662696128734726180676323130693160397208008930123341700520454723462226657743365779183466120836187720332442041321870351823609046027805781414454998487673927365486893294110931852680018706479684281928396163669935417207859889405108139261480861908067489849403284000981453574189898304616775302917687860062501465417706095450121596418236563421425311420755550335597318818628123183624214438801254105808079227429950505879366254661664881055965092586612702279548151277733307180663770432418397550642136953750720624507617115504303570076531620003848642167562950736271141440609700821621532583527124386811144839 -182748557863603655835821910989658558236) 4746270122419629115710902425435990509747636609113505336611751359043717100752575149404352359855260443259846554733621122684788488984010741203981300775978945529551335641218319619542248418128319220383298229263331638090009313676486209764655429828385994626323209879925281409485074778611946493692237774852428345451174837474328995186242262565013937544898941834362941815633750896882758939509605799422068815435202904271722442099465950700886702949580264958171808372530471918175963644209760378395316412115175988232945569517230829200985652504383431054550902852797293952515652017940918628980037316292352828228005975466732028971159947131994753006597870175664981312344004)+      (num-test (* 2117427896392849163304163145095251890404997781812823978967013619233450901604407363671467658244435728579079751353560538034596183240362499870272373308111405924505741579887345118857908796509418246599428633956038017783178050402412769812823236255234302205027282366926174916871858199918908361186936687654278623156607813451034087735179167324944824913226799346886951212979149617678949292799645035425029596869092844906629996914674904522806258932192931217652241231736891642224851547474205131131019084734780208254203537633402057673465583362982905095029133132240839391503135932501785844503813910210348239157828902668852795945482 -296778668392678698960782643314222141731) -628407431508980610909134894336322264939705333430111861505965183839156278363647883745193463537783397824947515214540990712455315080515980803996660089847066076833542492719707493333185909990202372284811233272987993068106356248349054482194817336258302692039392400931536481136340269417905505366385505196886218794044229758585631131853635721528813397816307666671727692971421531381290925317161326036075629905443938124481334173158440927555118173661486114828362551889594188958723424604273078091320087897088472418346754088900034854230711982602435635574895960156993014703292551046970069204857846207328434544990709459402656908170089318995291341536347275682867153109342)+      (num-test (* 24743327715258194976385899813930363006464428087412805068703455203318769863096919192538751530954777047772548306936907016751357570434930538612382851621309732767199276228580401695793317612267605312672263736938703887622824117576912830029817460033437752668221355377879837833796222831371174014543622739933433581963103361464022058091243110136610854806189138108937004805781857031030005354158991203388998364340053773883952742645161560754545458260688560269655272249435540890073696261770299845722705104648358053080678920468895189601731801025555650490534399590288852165862135571140382055044665678298182909026026068995867606241201 309156501491030456401354118244509785044) 7649560631695275371386748526795333430293346807872366006552933839286343590101586516802834568317627508914888989005968805867728947519409222814667350103434422356009252082456906520988877859152125402282765775845766265340707473525444185795403554160270722809642681642831847296672303556012796775586274347178092325226458743113317655523655255626670958156216225968018208281266858684283741496986683426354716284780229004376492833583965647875097951642088252875535823145900129967026856898970545720526282798418382467634180690243423325770596949644122541224189780082061715230852249880601371985342796525016176048518593825361248232406051886794538203297084423942036889326397844)+      (num-test (* 31345149697924857384985323414506591310628538098830133854928154990821019223495435414394178930529373634315044777562902565397455028894455733092896622048288278424884040917250546068175763309233883078972879622697667174865833277342334219810618450605650614585133187005110148963483824629405555603493157452295284935004578187488673124814714326405406894084902824045787647963172437833905574178160343833139650913077173865287057167288286708807322607983179910358234015596109655900840652230258122852488289951986129788952718105898226951651151495867246384586164892018870981480003722043190639707903266193064807571586900961788679579912089 2067227180806746570739122295766566373146995767544546241400900414826379465803168632854028593293108913670556431832056563218709444199286888840721753894461468) 64797545442006646811970698282511426059102976298051534827345388707272469591333019870381858263624490336448197115781363489554169207652559213486772008013638214870324260793199674746523791257170452738018910619029072942848422098770309928561867618844814267276213608306045020686764830302020953883994906997293368193331696747777630621086600981981357507299729947717565760536305785574555255589190221698706036770081438750974356437738060098906046001271392354762036427049946092656701257615490057677558059955825843182799904828201890893555678855718728417223845757559310912618029462136640226686626513375024547351747669476392735304999046232068947570708757930233036922714350584650744960478326257916948676866148362166017752159953504981324652709881831381637989229842766220141292801807437886652)+      (num-test (* 1965759082776833678304908699214846485256126608825750175641683294458978302204367346739996602241053060915897480812220051082619942907491598551933638540412113496542245474287364500698693202553692963910123752514310355402167440783023542848697962967771951714434359320001430281377747193083851165947498546085410216620013287853719686698746328198021011905482303248172483782066908570502837009924228011993318265674390462360820566174204659723461994730913995303015012684826295802887547970851558451858623353950391701673651959262042520584275132971807158231859672678070714276061110616753309305801080136339206017351200193800253572481467 -11092241138073130060021642325471345789108575712118027611362686690749327689527135459714040658411176246054106270789083336195599640521602432629024562630323934) -21804673765518097879589124792137157558586438669762099454880024920520894260754279593873244443852337739758694535682558790532827482894104906218015712179591886600693703465749571299271429989154199263793230178266758966678432691901731270899259065726530463438316383699558373053423999416350780342222940065486831353604365192968606300436304827279383661172824549131179471364227618431414928702407510473319879188990689163932586727702195573766225861364297410904859137393184592815970592502081722125458353280743087607273547490382023433724488604177909671497082747464946083901888849483505451426245881736990810339421864101129619181017696837017966116165703320918568645290788634265522956017905246042460811062666193790657969385648522736090098231379029903772234867701846824572274796526421531178)+      (num-test (* -4067457132547237558852016696244696525033953641638067592741078194074861352472861925779476293767777560910963786727886946479865734639031042985368829200802420611189793957001730656623744670821921724417176679009632346904384261431052972127975733031277489967119978909321422086102208644766894305071609385305464547231057263658903212521469801833214062476735046735467944834107695748433481665714184831786462886261252526036621257865158497049125410241033365487816324425563483999957660557670189397770488996359512245971368638615503320507431381893539767352426795415898379765583574977542068222040889423739693921998717145084904555464058 9635268828818063607505341812331931088336041632536136269505180222913464638532245578488168867093853062326136774925531196873279749483997619950077042084971972) -39191042921786100943542578352486285322085069425292685238158202937549417928185097567102615300826629615520476316505465412722375794150552330462353356124896483739321653441446703127728441315609093330694305784991844511900128172079464896650958648496336601612657347012294121239821167759496102233234525084695798195547141521849769350204659392602605928907953707277320590923278178152903602506284861018886300148663530071056792375593665422754923886137410482547324901798328311927545105456397213670390651819229021443747424183114992653572959318104053511452473611466305149349027962240989590453237778130260105665310067480846969449221473610614214933278048389171979184119355459010233147440293881252851501522689209874112819966647846701257081192324007280573826673895648273593609466000383382376)+      (num-test (* -22047771987573494284336211037167956208924595972749016352929724093971147687332865088249749580556015503923927321586913446367676445848750229391300778587369581738560634537089081840938984779012854694220894920437076215176060179241185151442003472788530160589267677502568156006531439509890061829154786579353177129190813899423306499631144919702707240832059008168851983259611724134448165201725432622521420667808597545410136493805873769372831833878868603946583848422310946469083400330960925084024624317866822897278934924368888332618046649078771617892961267312226309927786691384460940015979582201446635756024251269978545916298961 7481502540911026808093162425787184755732317118387068406204973030847892995155568099553397887864257088525242568880427634318737874025160499293315047534753494) -164950462146458057264341765173378248123415893870534274075422323606836246718538063890359159423074703472625232511667875897808555123518162244263016096627959208397334135559180524195701526029092734741010866589515172934676451385008535538102832400604699294088534999994990970130226363762230944961249818769566697211068918154629209895730969522747736738946126971914549491889482944152891334838234907190697109929512401661529882587076352559260375439428815896053844621297552401396168240947357044985051323834074355418902009161796886350497072010833513601114819625605048943438304411954380599728561071485061414856047768286383287807924135081902458690495890129203192613070824670256334683011083767124852354110322463725619194174195587835939047474059288568764831570274891727391545546467943319734)+      (num-test (* 22607201423790553279447786193696575272983924506336369475058795405894123712509544256099524616893423762658394830755129501447553593365768543361107397299007141714383407862976654294384881771985218996697067215804348472693636567074361380875512341556932579903687576929186215185312685712277482751425466251201421842248749944123326048360909954588266368306843116245625635467041934524547983478110533044085242847795585598341867070787331785945399446665919396062565614516404861115244243161694059679274045050270546536781907061002623188435269769778378780371158624481539046590932125320888745103158180784231722265376331553893647061533815 10075764395489719205294189472045365742345400155046712954334138069917417587273618147303160957788995022989479371576840422540097479703418600112174202202728054) 227784835187493343385594867881830022845566753253174983274076326016001091958812135049265213053390506720261776960833046225700903422206015373488419693650378821159134369608830936915027161415300759990632038898164509761337714774392506802504397626551196717184785586630245704512525844329038355790338277254618639554796026366029578805283659986085947726260520495140332204643887370987929304924491772630534558682402396784510750317396488402942581973350428066695976988812610467654886227733900635715495731445319565054848075104982244316563526232071957624002266648721592744376122065531440026836549316222728280595228806728872537793522244957258060730038589170810090676474272044568671474692128168357087077816573419470273384256552275636517940058764711467508281344270125535855785388198570146010)+      (num-test (* 21997874907846585575969651776904015812729615626636027149446399573806943459105370044846476738175828244018281160136531735881270437472624605280356112191272531838028896521621800558410217146758345955334174583639352151367532676985598470747138461153212653362188252002768647808852054182649808145379073620834551216386805267446360709820441771932135218282126427988826945094538034579367527908530151926679515746133600376612899354099328788736038811470295396365432559354070365548930628714861826464935305416998192532029724853617023971964507955475554955277722555849603716733374588174421463022213135839490633927005539569058361144905451 -1400498192750070094581812894241996480373581610489471746158083224360249880335094841398529960182484181641387946900090289855375996313447832474435929084180606) -30807984052781257825246153008277875918087659020905755686964119182052911551148620538090633516362197112383237624321406969368641524681503231262834662890145617622830207559490089313283375890353617292096501953380469351747504928597461154633889236826060654886877907382241867167198409355653371944304660938495445848950444683274236538890057643038410268234731745456035923559528706349316582901179686671568504971088561096469997823300883298811440849031903066114422309644669680078733839046643542078157684064686933779591609758494599988463628362190034612412739669041368897594110022347872452261447359402810277413572637740870748949093642723240662839444216981630862346445890780016393330114883270596630385367407921496982236074288475142085411632630374714528706189796772213264952893973677883306)+      (num-test (* -270155241925436273159477510619232592261228150696806729750247050 15545126743930076938536195287546926534964892301082800206802745964245668351235397 72127079799316080210744562119267314209211162112457416152560774669179705347659265 58427280233475514109627698916382980237252687770812483048907352594138577656301900 91336330475502063985843547526216808965829995610054777216888670176112782119332811 99495081134815818196404370468895496198561677002653930126818668800341380375657337 6904264296552316628911621065724553059847235903647375662685025031963599691416829398469283631386160328944460790101458427909545198569619131058877708293713734 -16074984786353617526516141164566295497596312655026144270863093715961484079732496604871734572736757225277596743795506589617891195569235287256031608792067121393492186703333733526879481948463529609113624075923052999494363547340563039654910799974388353472433635130983731604982117092991918514078659590068643956240711810902756784590442416249652077644077280371860780741318193975770906075446772544431670392964384669681404295839302410058434872964315897505894833409101781069230919347279857855594782111721176074849502391457684148683668165019969667481755384384017844104770253558111588611189351637275389688093074751942960310850074) 17849860827147993486644896214424106325295064110723402251474432199595968349198253682890653243676378684005650871261983711134190416277366473221365848417375107498764965893729640224952922241531788638514200018520970345581414705756736222535562338748426356003659523260330725662384208724142177900990027225665451069059291754155591197426279006090296512196415617974140965334686090032257444820748820516976632201388937358434205022475303705442914044454220818215336283948743042841946229853366515552653568436171217572212088935263340599371830215580988184775240338748954666846379831467518505260487989636951404886967842600777836444030434816421999334066711024026401362115623932221335906548647785232855815515579448393689650116225664467056283988125816950714780486880294535933597118808163054631168063568847830481653855357008353733414826165759079092633441356914450038756281940532159493763482047244493174370100586359619040444818634156576789665732998111907245928253704097384811414269835758656988678207624731164159069547745777423464124959379113843649940896359346515513936964849811155238140671698227057228045173997904545787593258286212427476788605370334985423461194148838623911634821153061693257996982252745844329344589168264774527631972524787804330730506700000)+      (num-test (* 6411564443509812216548163965666668398784964137255201222920640150 65325385402074288043601436729391841747319174569548241717675134253657593233436152 63305037198546989906433329294566491017476837189978173607681765241525113921707860 72383582945810879300930057856704905379805338886592055772943486702915907397618845 35525980101796892634292856352740658817031405780112750352735419884048051630180860 47579150292602967366908574298176357632207539947399443701205872093150879604391127 7775494633965874654516687741429737470333189902121089184439228657893110997221737422210698789286625633365548095171257583020272703565350668755439139356570 -7847653632223099338936161226557020783515367997970448568586056286591257384101422312757649765574456754668588904917800060981155642916520580540801153603733496143328839018174649200566737789874193483124577734129346933208306772618814806884416239295732454033604210880463262467564639515484363761639994642888910703066277724414372379965872478153546766131136324967950786993982228851928269842355632200589446224738709869729930285189047112131897218464505263042012855229737941639093204086147932759923796947642895167078971517834730472596647456786099215405165290569214043431009370032818978995463168133051136053246705694337584724712230) -197949741939898550383903354028842356745461597695099989904494711851411610441324234089773644533872304737431480244289438922163630848266242200711131210228027234579469457105291847132071566876246332653149194709623963836885480655282595345693084881617726426841183231475364991154699746506928116505297453355016975688761948609740314324443406930215518937775475617384099331839748494157863510168743547396262979908353122625808170296763676837551973930928848463398657587603606321137626467028732193151671337338929938959296176472483674270114824853018199281637976410726195357458134038379491704909997939715446657856320452698914513791221947734373322868574099599391493563479057703049036936132407025278683219316357543078875410080612067641232277376174351958080693019953378024732243763129075732499165068171168470237875348580987967740148512425201518758344757030205911031119619416763996490581551977913711646761182756531618786226541010835120092904291975494846126923510483263978074437667987560077422810120462938292680423746968095994108344184522240467647491991837793653579480334442342102339933473270535800619630342940590477752278184994533764839125736268376640933720554199782388890444619996919031351334561766248781813883867406045414518951152508504891407920000000)+      (num-test (* 1669833986019218156514274418186396165434871163342486930502417566 58528969848472951398118375496887849181512821636583415470809040929690124231959506 50098163184827557635697120379841225459445103589988345336880332217224622666020381 90445522698871905833766573423181067004916996574451008349087758531794463581708977 92366726802191504770638415639612204654473958526592425718659284841373421985393966 69096133232785816552402133765198624674167660496399099321713067612475604030259084 323971624832697152056406152359288553860210436839331005469891386690556929684663075996719803995137130737141925308417709520389528780839777347463558171582753 2635514624483961079560488004237441873979133312246005082134175818331132377114926863102436691793380965631848192666106793612266994709357524826644421074908075389316030912936338175907209987972553710900613011802455058538786723149316934049388525865455871552882282353445228425640452635081303490379594663330152071465360003249884180020993032086861074931796165970076448856988084523672973069824258299029863033098237556417571526135639288006133579174344589248428714474318969988990720790226604664141927030250855550010512291136517209169959021730625428868037074528890516086527430801590050720467893089085308995719513895962750896813152) 2413207990093478676325592386500172980330574558867366638913149256222218924700401110600319869300256745035993991818342784487193857053589994816247466074246569162659879368383295411190237107255160498774228460295857931362161062884154872938368166514128474751716517750517217000290486110198899480877593169193610813452614906598055909439037075588626529658637140089909227353944313408987644743661503976835580507054926908821206921014266535160031749397432350114673787218438589065861056449106115395189057409933330355574558853874223262465965933679584884152813357065227868165556818717270584803360466149860292769520737249610469675917864449261901859162854558012721179400237645357401213337423255109839806528503425658270050436129019270883446965562683284298538825840361267548675967778385927410390726055957928634152514415917053614892441910675109517307682075989998558764742821214685548219206933043196677521610851950501225469125512893859254575460130829051324112015464552874242522140166275233893076603452098841950130740353331198999756316969161591691095397245996664755249875720008141774247384884623389430842799829690618405724986702942913150258769060684255363816662231923570491001519802836627028431389746450987110456127797025006251203111629141890634728548553728)+      (num-test (/ 10105597264942543888 14352488138967388642) 5052798632471271944/7176244069483694321)+      (num-test (/ -17631701977702695093 3931860028646338313) -17631701977702695093/3931860028646338313)+      (num-test (/ -1606495881715082381 16324360910828438638) -1606495881715082381/16324360910828438638)+      (num-test (/ -7960193178071300653 -10280747961248435844) 7960193178071300653/10280747961248435844)+      (num-test (/ -11544909483975853384 -16041992360613233027) 11544909483975853384/16041992360613233027)+      (num-test (/ -5758820541298901548 -2596462557714095861) 5758820541298901548/2596462557714095861)+      (num-test (/ -13056342734667572546 46502284983183419157350605242474199851) -13056342734667572546/46502284983183419157350605242474199851)+      (num-test (/ 12668118634717482325 -338544675918656078399121171905238525746) -12668118634717482325/338544675918656078399121171905238525746)+      (num-test (/ -16738429327795346815 164053836541028518093058940786011794219) -16738429327795346815/164053836541028518093058940786011794219)+      (num-test (/ -9884600460121235549 -53914696297933680001835530599748561584) 9884600460121235549/53914696297933680001835530599748561584)+      (num-test (/ 6753521264659576004 71759828079371803409570464915096122874) 3376760632329788002/35879914039685901704785232457548061437)+      (num-test (/ -6072478784520825268 83641961138289700975241455431547940418) -3036239392260412634/41820980569144850487620727715773970209)+      (num-test (/ -6708950756971973620 -9847903810677323447803434015107261150885944735136350527205856921771320298384705376646797569973415403097847060539915279223391112430240736564839483430569706) 3354475378485986810/4923951905338661723901717007553630575442972367568175263602928460885660149192352688323398784986707701548923530269957639611695556215120368282419741715284853)+      (num-test (/ 11263779860755455072 2292311486393743282743453705144070351222990311578446825826935237655927864700827857707370158936582804478427014131790879562565658386819339761919809732496450) 1877296643459242512/382051914398957213790575617524011725203831718596407804304489206275987977450137976284561693156097134079737835688631813260427609731136556626986634955416075)+      (num-test (/ 9956488981426387585 -12351244248621474338537656633137999145154500022264356186225225426288301330225259889671144104952158102155582320296061124840400655528634050137479515338944145) -1991297796285277517/2470248849724294867707531326627599829030900004452871237245045085257660266045051977934228820990431620431116464059212224968080131105726810027495903067788829)+      (num-test (/ -14875992781716065391 4906952781757522095285156014969507916562921709689447567404076064849249737893410245743456952512717420040816186768213920574809530298070437840356629617118643) -2125141825959437913/700993254536788870755022287852786845223274529955635366772010866407035676841915749391922421787531060005830883824030560082115647185438633977193804231016949)+      (num-test (/ 16043178952268979636 -4962728781666935768923030490263743715131420507991284894489828489607808897271220927863958149140648859077934323268424257800724618076505149638049461104621679) -5347726317422993212/1654242927222311922974343496754581238377140169330428298163276163202602965757073642621319383046882953025978107756141419266908206025501716546016487034873893)+      (num-test (/ -14889985628902581941 3075736124701105220602924325296812116294816310089906623707854625135862902005059305428034753787024827094954645083406870532379125275086885405969947540175361) -14889985628902581941/3075736124701105220602924325296812116294816310089906623707854625135862902005059305428034753787024827094954645083406870532379125275086885405969947540175361)+      (num-test (/ -1719613957783789857 19860562547348050982501313785551054055826630539673708970554435103060535649825139319625648954889488501680865494719253019921780044205805557658109807483499994523398090829033362953135186523580359552555144614353929273831853529446536288544481045105104526669277307473478898498061888931858821517694257595658138564305517447595298378933983614114298000880741350618424855028965861930329619462261269994651112266861896630584883581092431090390354633458596611690990999635499563944625720180529318327647519405136188243979680965052005899543797270970540925042201315580510136864931200059448645464256385079735225156720340173280541113382758) -1719613957783789857/19860562547348050982501313785551054055826630539673708970554435103060535649825139319625648954889488501680865494719253019921780044205805557658109807483499994523398090829033362953135186523580359552555144614353929273831853529446536288544481045105104526669277307473478898498061888931858821517694257595658138564305517447595298378933983614114298000880741350618424855028965861930329619462261269994651112266861896630584883581092431090390354633458596611690990999635499563944625720180529318327647519405136188243979680965052005899543797270970540925042201315580510136864931200059448645464256385079735225156720340173280541113382758)+      (num-test (/ -10969623867482498359 1292477254230352575769754773488799598312602810841892384475535212194939033905139960602724737178675944133847094464739764817257836826367652752931492512753561670732296265459534230949226553571982695924178928914002527460943582374603078611662312521259541641138419845784008028215876048965254023368247445173694441960256131358058174374542730502334351759171930973722361567186133851896057677818979314942434199157003833234473048838906103902832115569853657335216793235394595479328932380393044485884605451918890395812628720641212850763944658735838941829604119213195707479940053016354291972875689927240247563236506479099606571912595) -10969623867482498359/1292477254230352575769754773488799598312602810841892384475535212194939033905139960602724737178675944133847094464739764817257836826367652752931492512753561670732296265459534230949226553571982695924178928914002527460943582374603078611662312521259541641138419845784008028215876048965254023368247445173694441960256131358058174374542730502334351759171930973722361567186133851896057677818979314942434199157003833234473048838906103902832115569853657335216793235394595479328932380393044485884605451918890395812628720641212850763944658735838941829604119213195707479940053016354291972875689927240247563236506479099606571912595)+      (num-test (/ -3716891004757979686 -19452372993227550502015765258932159656814363741878583541173956168837566077148160901999018823586675966076058615847408138956450751813058209394199427182041779436168298455103717521843644244801542056954603631432685194627158423459586845252167819811850263444712218938833443253125954475476481099092216538126519474183531297423759923656571895377587989169731023397615799830371852298135015608612181670362528239430952907458704415974164085176066242388561893721949244663406941558257051263727439679525692652639731850971185056484335828001005009903973037524233097329857690857731943951449292814500362180170793919266389501882641682782987) 3716891004757979686/19452372993227550502015765258932159656814363741878583541173956168837566077148160901999018823586675966076058615847408138956450751813058209394199427182041779436168298455103717521843644244801542056954603631432685194627158423459586845252167819811850263444712218938833443253125954475476481099092216538126519474183531297423759923656571895377587989169731023397615799830371852298135015608612181670362528239430952907458704415974164085176066242388561893721949244663406941558257051263727439679525692652639731850971185056484335828001005009903973037524233097329857690857731943951449292814500362180170793919266389501882641682782987)+      (num-test (/ -4863232114852441787 -22963038454503597269981750990033903654256693514059439027985256604978917966584414065892146187253799108250061573972673983350956191446047978392921074610323648301008272837432907303975548030552369880338022067315042332692023645592417869181836251486577977896077712912433381480614752789750181208326525834629219729662085632321271870762094800588296544243340047360684854239747242066367921596241226349790282723168222543448385227922748241223520686047460119733024390425165073367321644498280127168757335614077882325524816799960018589278475564547840614315473357481582710826551932681173443524724802157570101916268510464302946527662720) 4863232114852441787/22963038454503597269981750990033903654256693514059439027985256604978917966584414065892146187253799108250061573972673983350956191446047978392921074610323648301008272837432907303975548030552369880338022067315042332692023645592417869181836251486577977896077712912433381480614752789750181208326525834629219729662085632321271870762094800588296544243340047360684854239747242066367921596241226349790282723168222543448385227922748241223520686047460119733024390425165073367321644498280127168757335614077882325524816799960018589278475564547840614315473357481582710826551932681173443524724802157570101916268510464302946527662720)+      (num-test (/ -16248276650501285553 -3381199474840825715485713565301777938368574604710714363907009216856320913536015299178065264912798511857598595067318796576494480424838898250138649774858742984769125731728430552285782315111538920026330816414650913188340281906359149109963139438960274321560117812365241840204034925444652058916966934904097509799291744775242863360284348334605170437300543978049053839829106628489146216325576991696936733592366926096500684308845306493636196092408597450926695579897293944488261001228478152650490677071497874746121221519036861983646423005753475340900508665494162949119110128646472783016552527735050067363030838015919512260159) 16248276650501285553/3381199474840825715485713565301777938368574604710714363907009216856320913536015299178065264912798511857598595067318796576494480424838898250138649774858742984769125731728430552285782315111538920026330816414650913188340281906359149109963139438960274321560117812365241840204034925444652058916966934904097509799291744775242863360284348334605170437300543978049053839829106628489146216325576991696936733592366926096500684308845306493636196092408597450926695579897293944488261001228478152650490677071497874746121221519036861983646423005753475340900508665494162949119110128646472783016552527735050067363030838015919512260159)+      (num-test (/ 18296946401228630959 3302341071702763311560113831030141639804425031433511503765833897787925467295486187687396312611805794369889470239777040624530990622212474466940548049117664906468330871893337410618797113677420975837622378808494314918471282099855916016026079371666730617071364751834080179173620476977670099126230223862266413091012344741482772771219725893630556702028108027870656512750807359335108428687238687397060104669074315031780019301768744978815422943986587389425726602444937024004102212071953113581935989741954695450085391443134273670514145585869912689150728183940456773133212037846765421397201956541430155664614978559762638030787) 494512064898071107/89252461397371981393516590027841665940660135984689500101779294534808796413391518586145846286805562009997012709183163260122459206005742553160555352678855808282927861402522632719426949018308675022638442670499846349147872489185295027460164307342344070731658506806326491329016769648045137814222438482763957110567901209229264128951884483611636667622381298050558284128400198900948876451006451010731354180245251757615676197345101215643660079567205064579073691957971270919029789515458192258971242965998775552705010579544169558662544475293781424031100761728120453327924649671534200578302755582200815017962566988101692919751)+      (num-test (/ -60488682170925814337492051725122486652 14880088785789146426) -30244341085462907168746025862561243326/7440044392894573213)+      (num-test (/ 126617729996196635247771282957911941277 -7166506344996883172) -126617729996196635247771282957911941277/7166506344996883172)+      (num-test (/ -278675896803726074870988122161067771390 7744689831802931490) -27867589680372607487098812216106777139/774468983180293149)+      (num-test (/ -283351838662873779255871649630248958879 6912311315831153835) -14913254666467041013466928927907839941/363805858727955465)+      (num-test (/ -9715584046609700027352634666499181378 3368831995960494221) -9715584046609700027352634666499181378/3368831995960494221)+      (num-test (/ -137493547985106345282009151869389470397 -1916381539906956855) 137493547985106345282009151869389470397/1916381539906956855)+      (num-test (/ -328662747577960331872949773416436800743 -231069430804205460334599495337085157308) 328662747577960331872949773416436800743/231069430804205460334599495337085157308)+      (num-test (/ 213595640581249636406536485951630735277 -48492294677143227478357598229530842959) -213595640581249636406536485951630735277/48492294677143227478357598229530842959)+      (num-test (/ 85922846498729014445816145204889624189 193533957681757355413031965695625196813) 85922846498729014445816145204889624189/193533957681757355413031965695625196813)+      (num-test (/ 24053342958857142686054803491202486471 196417511107100936775397820630955772553) 24053342958857142686054803491202486471/196417511107100936775397820630955772553)+      (num-test (/ 102038936612518756467074084117019701214 -111946989731587760700903475996379168167) -102038936612518756467074084117019701214/111946989731587760700903475996379168167)+      (num-test (/ -3006867214208872584699983438179656913 -234257597822744479264249663225224173340) 3006867214208872584699983438179656913/234257597822744479264249663225224173340)+      (num-test (/ -279839802710533516603863620922251878907 -3244112647743502769852782626803305310331045534071805654982307107362388474314396636799597033636575215617240554815450017779373048313695795886893032630263219) 279839802710533516603863620922251878907/3244112647743502769852782626803305310331045534071805654982307107362388474314396636799597033636575215617240554815450017779373048313695795886893032630263219)+      (num-test (/ 123635964546481689465778244982425098404 7701433613491146708866098469269971554817017737111287276993583150548359764165526640986060909954451793171933304569726872785964805121981749276421956645830854) 61817982273240844732889122491212549202/3850716806745573354433049234634985777408508868555643638496791575274179882082763320493030454977225896585966652284863436392982402560990874638210978322915427)+      (num-test (/ 166158110049010486343321316578688184578 4093720847216792748840371965199135052196058344862447621818024731938681519017878880275303125899149558774718190527651555811733139227128378041055212888819294) 83079055024505243171660658289344092289/2046860423608396374420185982599567526098029172431223810909012365969340759508939440137651562949574779387359095263825777905866569613564189020527606444409647)+      (num-test (/ 147416259636838312272435267341375281181 -11266711292262839805944890501811605204323255169233519804446548849178247889563130015168799346120099052214488209897402054530713234143622703174309015777885801) -147416259636838312272435267341375281181/11266711292262839805944890501811605204323255169233519804446548849178247889563130015168799346120099052214488209897402054530713234143622703174309015777885801)+      (num-test (/ 102557200511608632541115941654031896919 3866177549962722728707550488877109233779215384377007088712280650225992470307822792085413087509167847767889824884877044539352696974351192629898363157976511) 102557200511608632541115941654031896919/3866177549962722728707550488877109233779215384377007088712280650225992470307822792085413087509167847767889824884877044539352696974351192629898363157976511)+      (num-test (/ 47794953079190110032282671989549362415 3802290983508829335098916118339496411537222492645529399519373082799614656011270200284796148989094312601047370399228868583158444769807910513767845541589667) 47794953079190110032282671989549362415/3802290983508829335098916118339496411537222492645529399519373082799614656011270200284796148989094312601047370399228868583158444769807910513767845541589667)+      (num-test (/ -169956065319483471022234920202991103615 -9934427489865644196610501807375648335352544234206717324511161205173460054921759084767897792996557220898467288533128078406604709773449948420404563411793533441010236017064154469575084055359823982786110746700747423674942932421964955746280671982635899487781780756099620799397239156211815110739544719746684712086075069101799537802834839550142629064374734870047412916259754010150500874430055034366305216104752636211802195447299210332237598443674867760860326529472901775427058078447963316168327741049511844237329137194533000697525539835371015163158135757326482343130221118201740819963770851200676279882978581431999960842565) 33991213063896694204446984040598220723/1986885497973128839322100361475129667070508846841343464902232241034692010984351816953579558599311444179693457706625615681320941954689989684080912682358706688202047203412830893915016811071964796557222149340149484734988586484392991149256134396527179897556356151219924159879447831242363022147908943949336942417215013820359907560566967910028525812874946974009482583251950802030100174886011006873261043220950527242360439089459842066447519688734973552172065305894580355085411615689592663233665548209902368847465827438906600139505107967074203032631627151465296468626044223640348163992754170240135255976595716286399992168513)+      (num-test (/ -83006311763073652927964071041666508273 13480787677843057038436344704360462056114592749322481662307876594244244638227291805757775026215166740035048814729231681821563443093991755779505400592913963236010573873554317250153995160235771659208137440518282824497744092608999871327127239673370293239927529076145825972430101380272357235582367639159280348164804218713823424182167974242317526959809443701996053548231667727254858428867000011055354779789221097183515832386890638024105232865079002765479933320220378271026425568216748186200736499581088153390350474814123049637951929317200314355414551809067125550551841102097159644340520444983020267926123546444838010089690) -83006311763073652927964071041666508273/13480787677843057038436344704360462056114592749322481662307876594244244638227291805757775026215166740035048814729231681821563443093991755779505400592913963236010573873554317250153995160235771659208137440518282824497744092608999871327127239673370293239927529076145825972430101380272357235582367639159280348164804218713823424182167974242317526959809443701996053548231667727254858428867000011055354779789221097183515832386890638024105232865079002765479933320220378271026425568216748186200736499581088153390350474814123049637951929317200314355414551809067125550551841102097159644340520444983020267926123546444838010089690)+      (num-test (/ -312626207169475064151212222217866488926 6989069923898656093413456232544365450599471748502878018530391549015151484336014906416216966193568842618920902504390187814247729346977677905224098932673981665869061845335443588666641982676550205160521286690015544764015602751932938178737949961754714143180917985455875095030469699198116593730005119922928175789172042067281849364217595912265452199938281052984802042194034638773435768458457616208103331213440768472281882976004050012769415198321241810008696147179275528426468408383757692656341606162350211696837361434874035354680073309142183699892959618671515841112321607728427286289324836870027735590091451421689980776552) -52104367861579177358535370369644414821/1164844987316442682235576038757394241766578624750479669755065258169191914056002484402702827698928140436486817084065031302374621557829612984204016488778996944311510307555907264777773663779425034193420214448335924127335933791988823029789658326959119023863486330909312515838411616533019432288334186653821362631528673677880308227369599318710908699989713508830800340365672439795572628076409602701350555202240128078713647162667341668794902533053540301668116024529879254737744734730626282109390267693725035282806226905812339225780012218190363949982159936445252640185386934621404547714887472811671289265015241903614996796092)+      (num-test (/ -151709660794612786408772973806200383563 -26960472721919005254400858042130056790831511338891584787669209989714807518625849812230185079206081782191501696661436514815190623849929065098497737155759771863508038766934134444191240792356114381746781342181881402424707118515655119761011977116554236461222788625158348668147995099157685699761135150772589445239536582228655532345059046596356954495360132444243748421428095867292294626357084961338288369883088525401649234025290736504802104065029036642533076183281468647642956623788270236516849523210698622687255735945678505925047193818483603361307498423724202227256505312543145618362906047473400380196192622607541097732443) 151709660794612786408772973806200383563/26960472721919005254400858042130056790831511338891584787669209989714807518625849812230185079206081782191501696661436514815190623849929065098497737155759771863508038766934134444191240792356114381746781342181881402424707118515655119761011977116554236461222788625158348668147995099157685699761135150772589445239536582228655532345059046596356954495360132444243748421428095867292294626357084961338288369883088525401649234025290736504802104065029036642533076183281468647642956623788270236516849523210698622687255735945678505925047193818483603361307498423724202227256505312543145618362906047473400380196192622607541097732443)+      (num-test (/ 138834496986391136939574372853300933725 -8052690543272184576133758511645801940246473546142520821850130421981395129853341888352999304040698251945886555605291324954368612109314080471658982022831338507499254609048475429862437003158379101603576571787302167207044118847876475134352180874260998595377014195145760071923429129767580115085764485254455919915567128572731355497418831212259648020550107573824886521471697331410754043280744066090848295906051303624846301488010249980896364883452154860562864255354208802313850527991005497484253401461375477060954782095047043919500670383372218536999834862885439984085848342867301834247551832677237328664699302165347765799113) -15426055220710126326619374761477881525/894743393696909397348195390182866882249608171793613424650014491331266125539260209816999922671188694660654061733921258328263179123257120052406553558092370945277694956560941714429159667017597677955952952420811351911893790983097386126039131208251222066153001577238417785769269903307508901676196053917161768879507458730303483944157647912473294224505567508202765169052410814601194893697860451787872032878450144847205144609778916664544040542605794984506984917261578755812650058665667277498250377940152830784550531343894115991055630042596913170777759429209493331565094260318589092694172425853026369851633255796149751755457)+      (num-test (/ 276499207940187081393841843387608369874 27347897028734618663428054896349668572244941195143856840032842195489553215406302254043947382368793914074147314353589439281000471813879502242851166670252197853998033813694814376228360691543987661407996785043637351295817024680721181205269262470473172181965930243852520386958529041036476807810647578694133804796395977642274699322030062940721165202488695975750512485574440928370802874677938542169620505668128224812441566912043326338714451629730522324228356364241376445033028898865300103247057378058702233150414643818049655628999871012383236520330575609745427181485617250755214922048672375947942288446974485524776744246517) 8919329288393131657865865915729302254/882190226733374795594453383753215115233707780488511510968801361144824297271171040453030560721573997228198300463019014170354853929479983943317779570008135414645097864957897237942850344888515731013161186614310882299865065312281328425976427821628166844579546136898468399579307388420531509929375728344972058219238579923944345139420324610991005329112538579862919757599175513818412995957352856199020016311875104026207792481033655688345627471926791042717043753685205691775258996737590325911195399292216201069368214316711279213838705516528491500655825019669207328435019911314684352324150721804772331885386273726605701427307)+      (num-test (/ -8979365591106781219797187096315899769868799444656824967426553299158070014074001230883484015880186603742048949313393413640240595706939311540002219411120389 -1698360947072008877) 1282766513015254459971026728045128538552685634950974995346650471308295716296285890126212002268598086248864135616199059091462942243848473077143174201588627/242622992438858411)+      (num-test (/ -12831814656788829919185319784994714617782749504716966706877579983082880759985031662545957372565411439648298939198657738497464024214657609856476819270030801 454910754379715) -273017333123166594025219569893504566335803180951424823550586808150699590637979397075445901543944924247836147642524632733988596259886332124605889771702783/9678952220845)+      (num-test (/ -7834266257250691217409788323211914445703052638619784568844628449769010091330019095736167988675873769434766592786720961949649685040028101508217441360672222 -428418418877192732) 3917133128625345608704894161605957222851526319309892284422314224884505045665009547868083994337936884717383296393360480974824842520014050754108720680336111/214209209438596366)+      (num-test (/ 5737805823029931079838944835405107564434908634489801628049345331760087020955028323378020396677249341204498685189403657652738071833877470777083253103936452 9588993061977446661) 5737805823029931079838944835405107564434908634489801628049345331760087020955028323378020396677249341204498685189403657652738071833877470777083253103936452/9588993061977446661)+      (num-test (/ -4001605821592542867351046644170905984672346731784670159062281252096012802838642896466582343641124674682428297533953704119505640938363392225910275838094045 15760991890495426717) -4001605821592542867351046644170905984672346731784670159062281252096012802838642896466582343641124674682428297533953704119505640938363392225910275838094045/15760991890495426717)+      (num-test (/ 2876630161532936743269451364955814480771395635620140205538288339793482694260173239474830738010159518887660000673207712630507802368373928478641773477534499 -6788234478844960330) -2876630161532936743269451364955814480771395635620140205538288339793482694260173239474830738010159518887660000673207712630507802368373928478641773477534499/6788234478844960330)+      (num-test (/ 6230070442453337264527950102774203962152836811174649694700041895216739851602598854067104967963392074425258687296947909484969927078206601660837276754799333 190237375887614033974333796608341639595) 6230070442453337264527950102774203962152836811174649694700041895216739851602598854067104967963392074425258687296947909484969927078206601660837276754799333/190237375887614033974333796608341639595)+      (num-test (/ -12098771374444180013224380531550204930654718468097503123335711776524055419889032578894177605164827523969169377266342179411916625188550162928371789854647472 -41681385674896602840749705069663453185) 12098771374444180013224380531550204930654718468097503123335711776524055419889032578894177605164827523969169377266342179411916625188550162928371789854647472/41681385674896602840749705069663453185)+      (num-test (/ 13185465843955116174925558412278612918939024395488172088108029202384613698982949554556435640011161663974075894844304583900497170806796813871943782330552768 -155202352609947911537719051033334010254) -6592732921977558087462779206139306459469512197744086044054014601192306849491474777278217820005580831987037947422152291950248585403398406935971891165276384/77601176304973955768859525516667005127)+      (num-test (/ 12784980722915659825738808684740823452025110516624579136271791852138148426775553817114893299569867520414470532361018804123866264934222335562072872489963044 -249441012384365373362771955533424187237) -12784980722915659825738808684740823452025110516624579136271791852138148426775553817114893299569867520414470532361018804123866264934222335562072872489963044/249441012384365373362771955533424187237)+      (num-test (/ 8517839393030302736298983538193047531846908718502576675615969705563208303329257882565359266876007571790337440612227785062203468682754778416335180236967433 -23101645464137481399279134347982485126) -8517839393030302736298983538193047531846908718502576675615969705563208303329257882565359266876007571790337440612227785062203468682754778416335180236967433/23101645464137481399279134347982485126)+      (num-test (/ -10157767522292361462005308817460390811646115952647174687477824271227382383351453540195549992670001314693794150879368708343715654899952822395459036505947192 -25611473771508763579433379623726126173) 10157767522292361462005308817460390811646115952647174687477824271227382383351453540195549992670001314693794150879368708343715654899952822395459036505947192/25611473771508763579433379623726126173)+      (num-test (/ -8580252632668820290302987230726290672170301642399871646484841866604753910447257372311950907045477729554307803379310475132687855999835211879267570997069974 5347050029330174629945013741349819215851040371727058829687387719215168997632386672310746837193930669173408831178932364105722911104309540550576485594530627) -8580252632668820290302987230726290672170301642399871646484841866604753910447257372311950907045477729554307803379310475132687855999835211879267570997069974/5347050029330174629945013741349819215851040371727058829687387719215168997632386672310746837193930669173408831178932364105722911104309540550576485594530627)+      (num-test (/ 7706102251141221799524762336156378964168657337573751909064577951085535246905735244239132983582998872001001594454632956803416956154262109939446710205558308 6334400709835247308796432875490978646658012545184955441452799118298109610816693049400832749087993843490999852355789914065232784070007399786089389453289854) 3853051125570610899762381168078189482084328668786875954532288975542767623452867622119566491791499436000500797227316478401708478077131054969723355102779154/3167200354917623654398216437745489323329006272592477720726399559149054805408346524700416374543996921745499926177894957032616392035003699893044694726644927)+      (num-test (/ 12609622044672092190084693450911157599596799695538449568681964257744962273690941575572590166273187189250007688411096790312605666562908125521094386992971478 -8237858212652788898158635047388584411011830102060269605835391741772914864422465141467281143809161251942948659243584296367296559912373856433388249393853968) -6304811022336046095042346725455578799798399847769224784340982128872481136845470787786295083136593594625003844205548395156302833281454062760547193496485739/4118929106326394449079317523694292205505915051030134802917695870886457432211232570733640571904580625971474329621792148183648279956186928216694124696926984)+      (num-test (/ -9988492519236282081446302885464711911055350309732728352574982611126604133339499170845224383282665522673248920309221355720665956477799939031063172954469785 -1878204914631111607000020160429571305542722711529281855381736226230242796648854769713662269068364131804626863789957256573308715572826753755672493154125086) 9988492519236282081446302885464711911055350309732728352574982611126604133339499170845224383282665522673248920309221355720665956477799939031063172954469785/1878204914631111607000020160429571305542722711529281855381736226230242796648854769713662269068364131804626863789957256573308715572826753755672493154125086)+      (num-test (/ -10729942326579120947061030583094707809945059776287551713953926998992375520903658867971835616518813070294302895655369081976222497359056962112544408591462495 -4917625712783289245414023733273041940212797202855299465496072729329693853584860839801663152618595377553772371725021213143455497822882736730281253858119747) 10729942326579120947061030583094707809945059776287551713953926998992375520903658867971835616518813070294302895655369081976222497359056962112544408591462495/4917625712783289245414023733273041940212797202855299465496072729329693853584860839801663152618595377553772371725021213143455497822882736730281253858119747)+      (num-test (/ 8114113595157517238445304590338354472776364877475201453112450680537221171989478096363668912966343706408770932684807802285529572133696646343108263717309148 5443953102973235688784499815692116502566847594605098596244123647428188581304528525010862185203718640610834003873728718183528722470626702382993497913086105) 8114113595157517238445304590338354472776364877475201453112450680537221171989478096363668912966343706408770932684807802285529572133696646343108263717309148/5443953102973235688784499815692116502566847594605098596244123647428188581304528525010862185203718640610834003873728718183528722470626702382993497913086105)+      (num-test (/ -7125100205152691887479515774712530950031072786448635736036405923401522078562323494262148946679985384635556474075282302608446439950458673260234175964199684 -23871420315894180764743988478670341498770583257649869670486332228804693253344466615199983955886679924409910043885402198203427975742868174334723967563526738510726448815413356678504144193747696164586135745786501041060322480940451156015256191962506052700295351077719851275026974629635679531161390660244641370183176979934485671396035404817388717005746812037357500295693454623478902942336087760288091719793968445716246099043828787040340339906538864570506773535078524092440112404847904632624419421052178754041718790915772437556681684830937503838434712179830722395832238257078212535157309743054115702650740005055678387806081) 7125100205152691887479515774712530950031072786448635736036405923401522078562323494262148946679985384635556474075282302608446439950458673260234175964199684/23871420315894180764743988478670341498770583257649869670486332228804693253344466615199983955886679924409910043885402198203427975742868174334723967563526738510726448815413356678504144193747696164586135745786501041060322480940451156015256191962506052700295351077719851275026974629635679531161390660244641370183176979934485671396035404817388717005746812037357500295693454623478902942336087760288091719793968445716246099043828787040340339906538864570506773535078524092440112404847904632624419421052178754041718790915772437556681684830937503838434712179830722395832238257078212535157309743054115702650740005055678387806081)+      (num-test (/ 4801495919363827077158204249631885157347198552733998896638174958434968555935827788499392382851493568264006507028024783408190862186734863708684652212703744 29234959990138609668202089052356468732793041824333219340488007351402997202222578434579705387840772390513345507274006495462445058795870182760749392281528881636623188890883479914921272700981309656920982410970774047916714087713562927554033500521877735827036675598267184309367127514966388636440710253467328441763131873309183205727440365838789320851968108312559316922678357314418486932673434031479515016224407618177089903730349114511598373251388750023508633761000320088841886505077453257141723747388913336375142897897501529451618927178835485127020789481918641637409265186365292847057986276062625965612268181771076051892980) 1200373979840956769289551062407971289336799638183499724159543739608742138983956947124848095712873392066001626757006195852047715546683715927171163053175936/7308739997534652417050522263089117183198260456083304835122001837850749300555644608644926346960193097628336376818501623865611264698967545690187348070382220409155797222720869978730318175245327414230245602742693511979178521928390731888508375130469433956759168899566796077341781878741597159110177563366832110440782968327295801431860091459697330212992027078139829230669589328604621733168358507869878754056101904544272475932587278627899593312847187505877158440250080022210471626269363314285430936847228334093785724474375382362904731794708871281755197370479660409352316296591323211764496569015656491403067045442769012973245)+      (num-test (/ 10769619761532897875307527770350128978615798426116103116325434914975512103385205123955114305107607195469345895102375220593168903042839441996791318999499708 -7224105715967976893083374742254251507019823877014718307738328810406361200631626366722837314776666720638271529652546975342143108973422364041422652163016078890272393678677152791565494865444430757858556891645947268886646732022748338160528677218733159766121781240328812893374941548395710123982510227501927393735585082736583984561348450061452997663109932611188779299623613963995350679177776686423432406091192517292522853783968685873925548901506191291253596763183277703635837071862492572256145656312023955675669362656148946145528559574994353884313568526553663370513565393821926602014407548325293145102073923450066319746913) -10769619761532897875307527770350128978615798426116103116325434914975512103385205123955114305107607195469345895102375220593168903042839441996791318999499708/7224105715967976893083374742254251507019823877014718307738328810406361200631626366722837314776666720638271529652546975342143108973422364041422652163016078890272393678677152791565494865444430757858556891645947268886646732022748338160528677218733159766121781240328812893374941548395710123982510227501927393735585082736583984561348450061452997663109932611188779299623613963995350679177776686423432406091192517292522853783968685873925548901506191291253596763183277703635837071862492572256145656312023955675669362656148946145528559574994353884313568526553663370513565393821926602014407548325293145102073923450066319746913)+      (num-test (/ 1505915608160301518246681692927442986955390537144107830770082927276722640395785957392652130911646706470337068266772174699405268120590454296080828168261019 31152879253507543898583880698200027990847289346701738353567402100527465991154555548630544962150902011282973749886327325250084401181379196961322399337408341296727915922288276602390334861175305055229766353672502691855637668618950047400571070157436221479289152631256433294884836727331457389922838951144187501751190662594278336543502171639899940796536926507796271202659224890656712231014450702948847764643603683153113663072089256293587951842007583210791100743318865647555912543508324790181772321217524164822106191538518498016236866957803105254555578252294418243701672226181762763332992886540089416888889135117147250495261) 1505915608160301518246681692927442986955390537144107830770082927276722640395785957392652130911646706470337068266772174699405268120590454296080828168261019/31152879253507543898583880698200027990847289346701738353567402100527465991154555548630544962150902011282973749886327325250084401181379196961322399337408341296727915922288276602390334861175305055229766353672502691855637668618950047400571070157436221479289152631256433294884836727331457389922838951144187501751190662594278336543502171639899940796536926507796271202659224890656712231014450702948847764643603683153113663072089256293587951842007583210791100743318865647555912543508324790181772321217524164822106191538518498016236866957803105254555578252294418243701672226181762763332992886540089416888889135117147250495261)+      (num-test (/ -4912349668310730778272626761660101328812783790262451913449395750351147048676353891314609774894027305081515542385381430403698808605768281804457186380542764 6582102431028556562269167182029950958541569095123705594954788174046339660437206159173417583841743892857066740116322758515837624700881569925244230209567223461401193316695082415261197843574563450002486582967745135870782254839990479649574452750850133306720341823136645982650022199634379361313745598455049448887744206616434903460504591098363901961758069797933831934878649993183747273660007900662110776570580293994733189753806312784239743585453090900671308673380802381312083077891736513388250097195232616017027333586286786139736783210630705878401429301217589001317082952461701571026008195534878902572422952568763551674434) -2456174834155365389136313380830050664406391895131225956724697875175573524338176945657304887447013652540757771192690715201849404302884140902228593190271382/3291051215514278281134583591014975479270784547561852797477394087023169830218603079586708791920871946428533370058161379257918812350440784962622115104783611730700596658347541207630598921787281725001243291483872567935391127419995239824787226375425066653360170911568322991325011099817189680656872799227524724443872103308217451730252295549181950980879034898966915967439324996591873636830003950331055388285290146997366594876903156392119871792726545450335654336690401190656041538945868256694125048597616308008513666793143393069868391605315352939200714650608794500658541476230850785513004097767439451286211476284381775837217)+      (num-test (/ -11503235648135220410087372678575470255397243144180272745183844970864347348074104828328211521698012119761674096067066173927209129755062269068090560678650614 -5548338218081690289723998288742945948643693817491921699797822887914665364835947234564530865119623677435878746610856459141463506776423054050179729345956931675338102809929977610828639446535095411122377961067651902947030310564736893080382424590568134091858634304377553326990788802662029347894499019277621467098333287442862683493159356014650672092060912274570436879076161496563079759704321556494898013269338428360856068237785049960484767969682269790642298701577934519452927652996671267126348627432295779183359417597868330923329974640383630473044712419371517153268338860560601603043892503067815822312755611206254762903436) 5751617824067610205043686339287735127698621572090136372591922485432173674037052414164105760849006059880837048033533086963604564877531134534045280339325307/2774169109040845144861999144371472974321846908745960849898911443957332682417973617282265432559811838717939373305428229570731753388211527025089864672978465837669051404964988805414319723267547705561188980533825951473515155282368446540191212295284067045929317152188776663495394401331014673947249509638810733549166643721431341746579678007325336046030456137285218439538080748281539879852160778247449006634669214180428034118892524980242383984841134895321149350788967259726463826498335633563174313716147889591679708798934165461664987320191815236522356209685758576634169430280300801521946251533907911156377805603127381451718)+      (num-test (/ -22964048032108117904633365483799091488990853392670636861794813863757795874434768543212887316456319246155824842161717179767513360050328383696194174741889496306018655333450647372293193335577883672679165775070112770359697627614883420620410888137853011387271594559450892054491963940112235887802995117234918878648066362268919389271696465517050425727202664230530633207566444357393843669758809938086228366322548799235049875711702216182219182908217345405023677260470015666831191434586902791186444958476491096759363292487221288620810273243009200212776634572092195691654105986099646006756823055390654876878195583529521482548988 10644501761877612307) -22964048032108117904633365483799091488990853392670636861794813863757795874434768543212887316456319246155824842161717179767513360050328383696194174741889496306018655333450647372293193335577883672679165775070112770359697627614883420620410888137853011387271594559450892054491963940112235887802995117234918878648066362268919389271696465517050425727202664230530633207566444357393843669758809938086228366322548799235049875711702216182219182908217345405023677260470015666831191434586902791186444958476491096759363292487221288620810273243009200212776634572092195691654105986099646006756823055390654876878195583529521482548988/10644501761877612307)+      (num-test (/ -19058897134776675884737764093896349427183484738023061956638485191239529906311503740032626797095131123523175909943402828257449376045336777553758951620699386266853663342003969442142858702229701661125904623724248177901462857013835790939020450746503125344631958534655024089231193396521561965297735217497608287565163852923704017958259400904834287026933197193592591423799328167149965328232560408884408251535373934831244856695227539243433290481951528897142697352526450162440279318507285454432916819060795455956931254810171588139618689138022062041222735056137988435900866680084665165131313435515187611756148824388549448126467 -8326067459929079652) 19058897134776675884737764093896349427183484738023061956638485191239529906311503740032626797095131123523175909943402828257449376045336777553758951620699386266853663342003969442142858702229701661125904623724248177901462857013835790939020450746503125344631958534655024089231193396521561965297735217497608287565163852923704017958259400904834287026933197193592591423799328167149965328232560408884408251535373934831244856695227539243433290481951528897142697352526450162440279318507285454432916819060795455956931254810171588139618689138022062041222735056137988435900866680084665165131313435515187611756148824388549448126467/8326067459929079652)+      (num-test (/ 25828007361450952719858846443651616751980622231808382804245407702688699228397920589229449608543284896555585501243582045708656531815385828908740757435341854996277769645696261182122648194952548457487178342682313459444433667556195761154944956714756269417591048771194019245925463541886773351873002480266654825771525233808830260734678788520487541379982691221386179066818743751876186761036101255542680066874888848011074569355779905086056095043888696435054884292698783753890317487209955316141370052511469715869816445031102161253514609763532756500340262263800747279044587806090353812452308490155782240390040070679663451429071 -16419739031141199968) -25828007361450952719858846443651616751980622231808382804245407702688699228397920589229449608543284896555585501243582045708656531815385828908740757435341854996277769645696261182122648194952548457487178342682313459444433667556195761154944956714756269417591048771194019245925463541886773351873002480266654825771525233808830260734678788520487541379982691221386179066818743751876186761036101255542680066874888848011074569355779905086056095043888696435054884292698783753890317487209955316141370052511469715869816445031102161253514609763532756500340262263800747279044587806090353812452308490155782240390040070679663451429071/16419739031141199968)+      (num-test (/ -1669696848499325185991294008037906453080648048592518700324899343297324898656645662186964240087582483813312797482298159224575128489696846451225871663856944749639170892311973606684486632224811435175199158920841554176114937196187087530038509898368755036744105403511353564606301040888877621412514452110348953863172547944175251415725815533087344857665837809749724257466399374547882097484009980477192931829030533366309859182367479867549644502538060694266048652224732348150866071381652452605392696555259221463464108413747443898588713629829490175098280805280460168541344102200890646453100478450456898359263676257882174308268 -3154577849943484396) 417424212124831296497823502009476613270162012148129675081224835824331224664161415546741060021895620953328199370574539806143782122424211612806467915964236187409792723077993401671121658056202858793799789730210388544028734299046771882509627474592188759186026350877838391151575260222219405353128613027587238465793136986043812853931453883271836214416459452437431064366599843636970524371002495119298232957257633341577464795591869966887411125634515173566512163056183087037716517845413113151348174138814805365866027103436860974647178407457372543774570201320115042135336025550222661613275119612614224589815919064470543577067/788644462485871099)+      (num-test (/ -2215504974719141921873290809898041836016933916943403987778356628123168736190963062169230280020568365292362281642280014010817115943641228422541948070912910166283758843455538187697141038676028739959626556519808411324617157646799936128314485433146912658200236754847332237438334421065771940922444296618134121662770699950019164632463150784605652351782139277998735272280336096528241168196650073301607171613955878761317417480490869592669781417658461696905996344800864447403426286476662235990122025654999230690604488053668524888833992415515434190712628587043474760836969696399229242018051635699746048823240033842587927229964 -11305319675542865070) 1107752487359570960936645404949020918008466958471701993889178314061584368095481531084615140010284182646181140821140007005408557971820614211270974035456455083141879421727769093848570519338014369979813278259904205662308578823399968064157242716573456329100118377423666118719167210532885970461222148309067060831385349975009582316231575392302826175891069638999367636140168048264120584098325036650803585806977939380658708740245434796334890708829230848452998172400432223701713143238331117995061012827499615345302244026834262444416996207757717095356314293521737380418484848199614621009025817849873024411620016921293963614982/5652659837771432535)+      (num-test (/ 24358677073350645219370308521851912760304925518671532565724702185818845784332554892130070740233218685874351979772556877899278790031132507391155876157108663291716896413773711734271947599485714147026138105714458778787734198938526335256418673319464023475137997251085298903419563039860433435847755093653670989129405749785476487449599232956305952768800154351414655365461746574761818724131185410194605648466196476174400166047788352670171627261342369793028465418799251589432585363577887467959594667618177199696618852093807640490831859585621198048572586882398004957371434677752931134884039120875470266936204172511104679441462 8754800987327220648) 12179338536675322609685154260925956380152462759335766282862351092909422892166277446065035370116609342937175989886278438949639395015566253695577938078554331645858448206886855867135973799742857073513069052857229389393867099469263167628209336659732011737568998625542649451709781519930216717923877546826835494564702874892738243724799616478152976384400077175707327682730873287380909362065592705097302824233098238087200083023894176335085813630671184896514232709399625794716292681788943733979797333809088599848309426046903820245415929792810599024286293441199002478685717338876465567442019560437735133468102086255552339720731/4377400493663610324)+      (num-test (/ -26302114071841994464108666310942614602208671348774320769941579409198660404735714925432808094014718434192516800374483192192707032773903982752997957629389083405320034044554226640590549491188742685901503166669355807243735533977994184111229208270447279559478659750835531593667003322059717930484363943660175452777363121025595100592911646539549735930625865256846706785601753749996181113742254145758187876411260965175520035400453360390392991183382425735199046574346992179663247011131958270717402007532256308394559029768974932620173103778338779940189812875680687510582798628982957687329572431433891809534332514765287899172737 196971971351558855568201373145365478995) -26302114071841994464108666310942614602208671348774320769941579409198660404735714925432808094014718434192516800374483192192707032773903982752997957629389083405320034044554226640590549491188742685901503166669355807243735533977994184111229208270447279559478659750835531593667003322059717930484363943660175452777363121025595100592911646539549735930625865256846706785601753749996181113742254145758187876411260965175520035400453360390392991183382425735199046574346992179663247011131958270717402007532256308394559029768974932620173103778338779940189812875680687510582798628982957687329572431433891809534332514765287899172737/196971971351558855568201373145365478995)+      (num-test (/ -25700334917103749626396366612061842558162882395534131493737229591609654899446089376271023701490708870843231350129849819430092002268875830384992877382393956173037794109904701961390126146975281052960293513473777226100954163054292968509501976296424278813632162404905591038465215586347229260479401862039805429711982871702185657527199220459658257385112793877259572278229045135617281858788415643567614198333459934599272409406206213115625226065750113120833933806486512117533453281522448845990642550827848765145774541658722594353290694745164913189694785762218575339370800538946514325662656804799046877175035545715523049884960 56325873113907570153638933263921340484) -6425083729275937406599091653015460639540720598883532873434307397902413724861522344067755925372677217710807837532462454857523000567218957596248219345598489043259448527476175490347531536743820263240073378368444306525238540763573242127375494074106069703408040601226397759616303896586807315119850465509951357427995717925546414381799805114914564346278198469314893069557261283904320464697103910891903549583364983649818102351551553278906306516437528280208483451621628029383363320380612211497660637706962191286443635414680648588322673686291228297423696440554643834842700134736628581415664201199761719293758886428880762471240/14081468278476892538409733315980335121)+      (num-test (/ -25716495567761925495340309269248196976121711927176026606462843116646034561721958499564011513233986043633061335866265799467020807570689498961190839877265773450484494789052182300993137822542881883769593344810286970036960228835955266304979090841345697560418139960733748874044680214388098802745248923989851173047158103142988835055585349795022662576576434371181693607267864646932929998659458265265400181839509356921460222604661909947838434113964465769102604033848276159366897885013231683417270877512514679528402888899725431524867260144325739317224922955028035417867933390409466302057857579158202739536568407090965929352402 -92089830031261826185903006947297196357) 25716495567761925495340309269248196976121711927176026606462843116646034561721958499564011513233986043633061335866265799467020807570689498961190839877265773450484494789052182300993137822542881883769593344810286970036960228835955266304979090841345697560418139960733748874044680214388098802745248923989851173047158103142988835055585349795022662576576434371181693607267864646932929998659458265265400181839509356921460222604661909947838434113964465769102604033848276159366897885013231683417270877512514679528402888899725431524867260144325739317224922955028035417867933390409466302057857579158202739536568407090965929352402/92089830031261826185903006947297196357)+      (num-test (/ 6427758281007308443295844679532867042370757542760390680622584758338041709910068192973790897624827722686313216884084305612889554116246627679267186323854642904894988936981064543865794245002470271142875081223308666588659587718561791667575945670118263124267218395749059879636505504607358472659126298770422135028955713148882314050530771750859372048576074912599265823577267962213046012777760882389021047579367276198483178024744924299929585515193595330026399302022065656106472153858484998010254767462854235008343139218888170221421046454280858208068658907389288543063912721882521711363713136166478126504226820360347652405439 80854661163518168674595213426641201760) 6427758281007308443295844679532867042370757542760390680622584758338041709910068192973790897624827722686313216884084305612889554116246627679267186323854642904894988936981064543865794245002470271142875081223308666588659587718561791667575945670118263124267218395749059879636505504607358472659126298770422135028955713148882314050530771750859372048576074912599265823577267962213046012777760882389021047579367276198483178024744924299929585515193595330026399302022065656106472153858484998010254767462854235008343139218888170221421046454280858208068658907389288543063912721882521711363713136166478126504226820360347652405439/80854661163518168674595213426641201760)+      (num-test (/ 1960728263483597985471065015024594804771170333646104429205729831998416939777820080209106943861368202560376682136488253096512360698625765514606930980274938979705620987031595592685578710084284618125325617453699875318678007463857705931376750632972266553809944621631324385690517092215690694024807784270742388108802858889381036105223858467345514041786882957807868961085072340965930749117411726729713477739990680381647988935514765113077094375924848051541167125595015542791382355149166582367766443782842193396221676952668624805183924877889696428989259842153378327156342464279071638070457876940165186524833987190050817072048 91266493124541431873557009470479491083) 1960728263483597985471065015024594804771170333646104429205729831998416939777820080209106943861368202560376682136488253096512360698625765514606930980274938979705620987031595592685578710084284618125325617453699875318678007463857705931376750632972266553809944621631324385690517092215690694024807784270742388108802858889381036105223858467345514041786882957807868961085072340965930749117411726729713477739990680381647988935514765113077094375924848051541167125595015542791382355149166582367766443782842193396221676952668624805183924877889696428989259842153378327156342464279071638070457876940165186524833987190050817072048/91266493124541431873557009470479491083)+      (num-test (/ 4941680418946960910262990974014623728051861920391294141439502190044830922127013115391726343950340163023958511659132792063033185693862678433421115681422259770928656196358763089894449447854011668445981430826871764812047994423858851467292757304285634515474652989618200442851239459073981986390515468331839802701176644729973346052528164203299481240263263697394061787580128379398464090163611942724580936445878570184925290925246112514015572149640886198984723311273144361235138411362294735799814160816806773736605477503201836095726740734281001021071803299510239436683913500734680524381145064985356627091311888606290704759943 291575320383555320391938911470370670502) 1647226806315653636754330324671541242683953973463764713813167396681610307375671038463908781316780054341319503886377597354344395231287559477807038560474086590309552065452921029964816482618003889481993810275623921604015998141286283822430919101428544838491550996539400147617079819691327328796838489443946600900392214909991115350842721401099827080087754565798020595860042793132821363387870647574860312148626190061641763641748704171338524049880295399661574437091048120411712803787431578599938053605602257912201825834400612031908913578093667007023934433170079812227971166911560174793715021661785542363770629535430234919981/97191773461185106797312970490123556834)+      (num-test (/ -17803449239532304707372697093467431202778585961066204978641168716990033159088600623106396534094218402005803618121159982050197012697237961155375180768349707725936023283589475384693590539312637333226292265409814019687105755522332846972859860649558844229320481883408457674560284773922666633054564243260924189551494368660033292970122831009582038986061326503238023206238467592238752824663935316307653075615249537594229930297642710570473007696494702367783692850946455203144153509057520651038068881755863521371187245025834292163874467913915588768778393773565536027848586260129438664753479013894698439967637389690509120223682 -10962227285754340409566802000064407225866105372406170304563353147415988225079632767886653994299800743521362563345682593189107807948342418743229049299449088) 8901724619766152353686348546733715601389292980533102489320584358495016579544300311553198267047109201002901809060579991025098506348618980577687590384174853862968011641794737692346795269656318666613146132704907009843552877761166423486429930324779422114660240941704228837280142386961333316527282121630462094775747184330016646485061415504791019493030663251619011603119233796119376412331967658153826537807624768797114965148821355285236503848247351183891846425473227601572076754528760325519034440877931760685593622512917146081937233956957794384389196886782768013924293130064719332376739506947349219983818694845254560111841/5481113642877170204783401000032203612933052686203085152281676573707994112539816383943326997149900371760681281672841296594553903974171209371614524649724544)+      (num-test (/ -11349783565099575757929584771389010505157850113880084607145768380886038854233583951229136273631022011781914171912628263930864052254964518914857757025547156428098062812984733912827827545722979442676567330004437902674729872754963478834939047061999292143602525229120558979819117729589695377623970606315287270030693151486803968345724658003068961239204812937084581894755863859944500186226990319892122692007317326534880413455575446314965159569830188583093978564829748603480193166063624130610256395632946002879039047154077629561745862713628266069928068634042545592328263646730943717246953000457159714049930890865576634096206 -5169948998417532948043886408019867395123131165917923418040862036041756675786217242743410895008311710518018466892169868028617239526646914529999134517417939) 11349783565099575757929584771389010505157850113880084607145768380886038854233583951229136273631022011781914171912628263930864052254964518914857757025547156428098062812984733912827827545722979442676567330004437902674729872754963478834939047061999292143602525229120558979819117729589695377623970606315287270030693151486803968345724658003068961239204812937084581894755863859944500186226990319892122692007317326534880413455575446314965159569830188583093978564829748603480193166063624130610256395632946002879039047154077629561745862713628266069928068634042545592328263646730943717246953000457159714049930890865576634096206/5169948998417532948043886408019867395123131165917923418040862036041756675786217242743410895008311710518018466892169868028617239526646914529999134517417939)+      (num-test (/ -4372008041495429462966226028389793326873997497126815043214338280101332483009650104005998792061125254101227371430911497751865710691604158789733634394053254604723940088324934622768312096370232736965692181452463495731681105253628558429524788376108667441329817524961077744083376843098018692898745743361309486938506049017980865957895278210133305721083115513131884239744064081819033733041876411992332060293539102545847193260167588667810376670587099064558298380310132769718526554738650709745767046942440481512965138461694790645096012018276362849398785863823724642554436182185786302301222529261914437437947741031113015699315 -13213007132248918651858333568248204618745148942720942572088217188768868803339938910599097839075045781852237705726227293430250507070717570662238736211897310) 874401608299085892593245205677958665374799499425363008642867656020266496601930020801199758412225050820245474286182299550373142138320831757946726878810650920944788017664986924553662419274046547393138436290492699146336221050725711685904957675221733488265963504992215548816675368619603738579749148672261897387701209803596173191579055642026661144216623102626376847948812816363806746608375282398466412058707820509169438652033517733562075334117419812911659676062026553943705310947730141949153409388488096302593027692338958129019202403655272569879757172764744928510887236437157260460244505852382887487589548206222603139863/2642601426449783730371666713649640923749029788544188514417643437753773760667987782119819567815009156370447541145245458686050101414143514132447747242379462)+      (num-test (/ -24003371850945507239307096734506644624830254935119140199726507920301383328662376914775504920527918338079792692943250446679097229950654636321252144129692109999375967030689211646504258922323499994340282315270808545865248969923421472430657741998787024263629527291510416193284540865950122841477102934165296344839654902079279846705581902668360663987722715177845485423354226653585575109653937253382583158263755381721094429734122004436184054214443676096492583897635497699417294183504529284810360226314491839533303380490277211336049582128602304906849999737224506976061216780230350942535246958957024226614847691329767208211525 10686139440491678930358521446524488461285005495304677740436234635584738003880529034339295291091217655777627375148264449580064000634364863951333061091724053) -1263335360576079328384584038658244453938434470269428431564553048436914912034861942882921311606732544109462773312802655088373538418455507174802744427878532105230314054246800612973908364332815789175804332382674133992907840522285340654245144315725632855980501436395285062804449519260532781130373838640278754991560784319962097195030626456229508630932774483044499232808117192293977637350207223862241218855987125353741812091269579180851792327075982952446978099875552510495647062289712067621597906648131149449121230552119853228213135901505384468781578933538131946108485093696334260133434050471422327716570931122619326747975/562428391604825206860974812974973076909737131331825144233486033451828315993712054438910278478485139777769861849908655241056000033387624418491213741669687)+      (num-test (/ 11114571678097117920369007866358540243142633567044843952020632081573546909920632543585596494530749645890342978505657174505155646987551523455565703297238406590291026899487431109110746657023874064284362499621762851387854720746040865741433394111425240861542892218169985953747711593827913014379823797703717216676877313898809377467394109623799717556800777662963842899812297087284510893865429864819927951428138755600792987191034272014681606301885821862650098620488569288170357746018556395309910262410994899971436293672676949544989196526035130226777567220128838888396668158456237490064462262193759918857287915854681904206680 4808076329737968688023887165061921594706561818755147855784713748545995818001333418509444774306288638038607173052166709335820929501845348060033808100812677) 11114571678097117920369007866358540243142633567044843952020632081573546909920632543585596494530749645890342978505657174505155646987551523455565703297238406590291026899487431109110746657023874064284362499621762851387854720746040865741433394111425240861542892218169985953747711593827913014379823797703717216676877313898809377467394109623799717556800777662963842899812297087284510893865429864819927951428138755600792987191034272014681606301885821862650098620488569288170357746018556395309910262410994899971436293672676949544989196526035130226777567220128838888396668158456237490064462262193759918857287915854681904206680/4808076329737968688023887165061921594706561818755147855784713748545995818001333418509444774306288638038607173052166709335820929501845348060033808100812677)+      (num-test (/ -27971792815424016824370019866875377333122266892537700816201893161065327053508379094007350664178576160161460501442627646041422270472469587140689725524176629653056006769618104516779694726446739085332330345789012312708713495757968594985567285237456431009983022526625885024663335598317191838389804118084831445251467492693688286258834282078888862754754572546522075833632779922232880101875914894393005204887265821991459415144492487189071888581048779385051174007698853920104709378859053075296413813207007405843448595681090932498329066591349910723578718333092115184652723310842559914379989208301125396793101430807658654849482 3169580893680227534064172567436590084742349042688765883461923377455374714865282199177755353861979892274552092801376364846717140845237173266602633583445110) -4661965469237336137395003311145896222187044482089616802700315526844221175584729849001225110696429360026910083573771274340237045078744931190114954254029438275509334461603017419463282454407789847555388390964835385451452249292994765830927880872909405168330503754437647504110555933052865306398300686347471907541911248782281381043139047013148143792459095424420345972272129987038813350312652482398834200814544303665243235857415414531511981430174796564175195667949808986684118229809842179216068968867834567640574765946848488749721511098558318453929786388848685864108787218473759985729998201383520899465516905134609775808247/528263482280037922344028761239431680790391507114794313910320562909229119144213699862959225643663315379092015466896060807786190140872862211100438930574185)+      (num-test (/ -138888658164471549506154385143989713534453638138516110941977029 48484067562152384719540184707188444570280914254129306788137384972303743285284814 56428088099244342456240635263153370817851703737803685168591843059886944388583310 6984617762898435035101945891920384937438416626357047934508608980105797822504000 90193136183227859939744547239819443586783276313678017953708293432043879247302040 70539472782976230144489157899475475029273447055080677052149474853222128626227832 2525164589393997980217929709704832829968554364529060039097810436136432713906553063644429644328565051224269893261942396763235990073001625976866246420775436 15614337547041181126817477188043219628044963126229393225781917631975649438502836750353253851523795212263078850399716875892512719059737913422781999218667136371648316387382440793865460028660248325297931269646982047533754121791358966254514009830876592200454797694143082163294323565673200905929297174223061890100210054105027025488322289599106119653451218493916291922340123640475500240519924011764050880374885136181582395113140580448936759383024305870622004464940344826337458060607492042593813585998516868215921180540240201095202617277388950504036371411600204964284568597705251929695275183521036281637399204541958859605054) -138888658164471549506154385143989713534453638138516110941977029/4793535847709521198063287553243915170068914691727215964454867625024011698922303669226389748584276840530192157568469968220857898703102351955898913589325705637953049380748829567692600765708909637920797057370082064005557328769108356548100875674196976079597658854339583183901899349355521527519781721778545444496852540362424465770767219571362842157786846795990148969989617793004579188905882473140017509154008696803103206996067638134383708975696867028865870695941933200225325283190379262695816923376790224594063264297952504481719779782130509306530621779762254864669078635401870023086312919956154224782043667754741333688780367667466505233610011253346902821033707597517691608103391952937194719540981992469020284583499872663129517095879706480339710037976698298522952071766717472040399518290905103777436461474880898550115925718887748413534479076504168236430697214654069473800915087572730747027455509241250627470590715812698745630545585772046458363388764449879417348554556621640336029897762172500880501074103433267444717053504878282494505367980026597725927414511391047010801407870379019921551218005714825277162504166028680939100225793768617321830389705750902850499916610355200000)+      (num-test (/ 2902267908619179684129536324641634394442732593027015198805855082 4748067699021154152763168285921806700655154833226062437593302484475663167752990 92172802787151156076284963978247829387076983213530315481815585776147505007251090 15808981285029107672090190966349736198141855760941720122983980047623201110025085 60559202289239963744584432021634662330089323842876293477363484160210450706125345 20641717016962556495214267565148984505293698026059157698737040675346468206231142 142380249473014630955299439077662853963947100833592874440361316474000948841420058017600161066408668117933232436922811486348705081331372574460204309908598 22418721268614574393232189860262616514600143215945007038687873335656746730488694050883006164427390756358558140145027011322151188565843290717535647848841274550496431839061217253488169143292339455650565906288959125935798633464526818546688779845699340483771625364583343140648892889571715648295855169294054985996834093294240640072029711789359793649773566295329912082241637482772608479106201840565936084243727069954911883243252762742415647868355726139789907900798435783365130277592703989608678774745914668128791639635886550753850811717805962562157686110637810320436812644047534536168343578232389700410352900247092236175044) 1451133954309589842064768162320817197221366296513507599402927541/13803211377640454778526029288269623376813125655593684775595099045285713415153039020789267800416616529908688645478733023490751981264976732618374046330204398361829051480928696426688037404239513603403603849882719851670264413777889524531938606364925013854252374108222701436535488401321603495905123597139234414735397259257280679663147039651553472142280954446675036289021783142392760217244908768132158498744301278889276778209560846418263599491357632762902447742083022806085077053406738681250354036208472026046315736408632370478801849290705001622808552373129971427533249307210975612625050706661691322027927380443494854794852235813844542319971019369687589916047377092369702778251658652143114091304960406840026816351348391618676357634544120732441610431417230403811846208113160343697557236265319994702483700922393762500190362776377442551539417224595247790865885105594005740401824824367904020732469833438717527758468635665777261969819260766044978137909489986407113029460354144391595512642835261443393260585888868936164331461486646676578398836326366036777321522851855085808626766493197635871100152761464712744017549919220291986785134521319127277292845352756807452050073157340000)+      (num-test (/ 7798204144688205291220879078360728451593323170355809361079096742 35808393784851478122520372074317359817820799318259895240196875729073154197251420 58532175726063855694248618287185551673975962776708803423334853085996022345828434 97834368697888769536063057370864051207348099191057106781292664602519775900739777 92489021460656714290092899983209031746574776013841975324837145038810562509209529 71083733375588666647468985607775761710974844539643116636307037921671845148256816 6123989271760127932230015643359630675168106436173654465119508990415235040641894537960236511442249258231302028977221206744158863083898145166446430168108 -27418900206398855942064397259705713102524342707255992250395147550519659429645343464288092288218160406382406024735131578979728501208163782063519839258876833755387025755815673514708453862847139552613587001235204464673999898312854941659541050445981594990466469147364579547089805525464252876345032296745312923488525701877655352034887018931755379078328147999631937419977103372927428613463482328465834563846802083044643719319690088670748858904291298575733560600669924511028715689681303059001186388754140003746463568171428267337107394361025465082282061651196456268663181772211292647101192148287507051053367729008997838464209) -3899102072344102645610439539180364225796661585177904680539548371/113184205287561573324139833190653102440730360395399197973956984769580868365256138025034414373155098575475566747215877030265786675432252675717351889433714136838615056208470421665419618669892136317438270826178251174708190860235979949204785938786562420189510825909814566675745650194525647207897976611434325225523578368855952217879373499055292850828774005130267218801086474623429504045290678320168493275019256514768273116059350700654655821674309331585233552793659038912697151359657915391954687630783641745610431060563252789714638916120291482852533638921356624929690158752601417722733222880768367060672103351737811624242610815140332559619520810810999145535251960674284283045907801934328911198563750515779896457101601178888594882087326241517566336011980952110586199881600553269825310575512911473547251704677890770772166895623118832621335417348044312911888377718725944255218219811801447500167145561774582342171995333086224230231746597452848775656030037837271428187450747141983599129861631612369300880722326218963779650411119279310045263996988089484063433088077868691314162108392639864773907107325220582413508233901954483499166402135445110435112499264825479433389003494762240)+      (num-test (/ 6291885367078853457481986049409245691302078375827782321496819120 20959289231548357352292073342856567687394126070322865796282035211176720583560298 24366038587110130209541647226271577368736240640393242419005751016119649778306566 40118119174220166901790237425673316895032570534639145502274313654443256239236466 73598137358602854818844747625643480865061277528564461120022408463105339470504117 36695182446520138181079917512512743290981469731336486456411609014364293489978544 8671667981598505073194269824535189054936442262459158402875147736469644925300845122881093216273840895555488593258562684601176239455526568314028830532770 15920064019095473156324398162334173238735268739049399738654357508344572552411935473846021991360836375685872129737682603096450566258725052013769725919038955505690389573813769125933987978360857342250911865713011888064725725934341157729878064563080803955584985269499994186472079783942404183377695242296289152788154908185130552013951432753148997632323578507137074131845177376689609114975253308906745794984371839952312988353950198030866538756253618535421214253194954603293145507537939731320546686208032528588232652963255550963088571344119439249328480867640436815434047309164687808223851012490130534705427647158409623238123) 1439421788255379275215959765325419043929720157723371200401/1747562187028503746686299553853635643553063923188506902759251937250022196751705340155682655202720363192751787186892107863159676381018035068965958466119538181810433273947829904580526582292369320932134048728374142501965682147541817431447933591106030690334465450755701191781243754499216697336293783127396687916725975251100500896467549458036395977769801208905203001097425041200299917628353220804629035768571072498715030261324138691471497255335498185741379289492513543474304524261634247519034231348033379344777678679950561777846684978640375273167561174451700942154388980887510088060818147834369595669846115248027925007288445161871535514130090907585140894883683709507099726386549038354860875469377442908932714711235823032704493155679240378374325069782368108779247450762222838197717507164088182062062215767468125843278459189085290703729281279344184417197883359351058003644499215541300350121854220342250451978930421772367851329849662028719768708399155817754711362398236471946313773603716759409265530444582884661320404389499624411965234669344882203618613097197387901166904575791500958722726774956950592290330175936039556139052663816485140080963740296685158607671768592)+      (num-test (/ 7377598052472799909620353419322603137723415431070641423056433630 50990728761110292768803869421408199244526424730838143228662194914314857136430737 89434155113971221138805303763480423496687322824531744020762041598590716339098287 91343386111124700155689622654961840380754244946720984970313893805578518003516073 5641075230099727784981579696383316732450130418277879081291954534985607255267932 91040802121912074401640073226003257602385910518707524375098380810792151468159323 59272268188012925764499414539835790113036863511169317924034366016920114706179376837448098952655862721652129333873020625135398431500899131874782270590048 26690053756452308398721390096804652429111408747235998849320348549870126230712525274708597346508961935323823048352116439255386668122483555236157562141222434006899926132549352821247340442387991613448730451171206857242290791156220288682675982609964518905569737166444127835826079348146626921864776959482079234994631361894786436656768739968380067890165160954836874044821979903056957225885565092422439358816023307475581832942250031121721325840673134241504501661692722633100336840768527354183989544434614842654682324213774503456414914613412547380720171088896588158750436205804689590730033393056191028424154915201435563063992) 3688799026236399954810176709661301568861707715535320711528216815/169215718032454146095901737002485678790901914179482864125777331106759302744215797822810809511498045518338288799757661725047129775976254373463314416017128993811694804386237923340900604770406784566473173755998386770282409830097844352035251738093305402541509197084964701114515390028814839744480965823142680384744649624767291550851759670297818996073873968006960956353033659153219390871979066743795530136868490210455800714335529013059123604101460242870160400211866883478263106349349114199154533363251799944090298252763172390952446660627602934622584400932001701907172000401485323481964448487312714644861543740014645407417493588261100128985848137181719614326345024112347151970444057551896842474702539258687521054961314443551837168457190568932765925484427579811571491887599619302241390226818415165012748654917331557679228501007751078584244340346651276906088856205294333241792044902850102153793417101337667969641035858108457362954650972654353600494166650067557014544136240962457086782865870886529792004619668808741311540795514394731398977642092124679638585188974746423756335151669217754388004341907440529525288302872368689364872785975840444000802518095138062596107983803117056)+      (num-test (/ -239344771695510351349291992975349015183687755312261264640655565 59880027487583466136533364102518649070390160795136023810470091681171428955831193 48344457085007359228086666145324485903333773379391455489556219681156342646858065 96824393663737121700189215323825147927318524415097221824671795011444303522438090 73240728471954064253765051525185557601431281145369716902120469411886093226662465 53476482728312567840603110355495270554470432250981685279567813448298175801364992 2468459436652089730331798017030410049989399340882712030505584719342958436741536069714790640546086933185494149096286590992747248311590137695839482679011866 -20583944357058654336975302336113341974001469085102805363209530168831840401111182124827636905521584509677325966689931599005216123375088335255672290604710305325984961984791919524676460851699284525672773368217606895110240237523696098521003978238685169880199868729577660354717875890521074505342309726366304528678619465048659607726264456481345739318939431629704180230985397408136331466856633265343276511285483458860216756106887559724757372775728879136089013590836231272961497930729470443491032308329051560641396901204040829291495325588896591482909336032903587307512310970849256645908744180630660878534263566681640143534823) 15956318113034023423286132865023267678912517020817417642710371/3718709813392127924163278362562751486187605430152002432053108623099406465632705761508167478249438322470295467114170871555665890539409511492475240415534629792791729596612426725326976353265532166735941330128195885206087665506220364347120981130748862937276841801804372097254983242962029582754709606117339082763083905960784323141929645331591164015455383939302728076410053178677168172481507115685831178503426055335630689722163467637005123748113214310366231893390818795405612007113310547901224920768646006621130651182788173442625298859454337696280614462941186626306295514630883052819172301830539345633711941340491653447613466053205836875456839023743314390098829184111583809697328393569588632000669468187410368485286035179259523632217543401146996259011916302393091677624838641658623073752023082344005134299104409908004250830639232078441523519412192782367689826532215394196055149255026188549091956300108740792221660678858924234682223183500313556198187095251404633698868186071148295957994257417049500872570631774233307260384902571112475241073598945295745287525486108978093728296107260155093397986671349139935376427469718767763295900745932105722655724205000829205748307261900800)+      (num-test (+ -6069217517368004039/4076344942716985944 -399587800008780737/578697755310708616) -321318766345655960630110128852941297/147435729263904928853096856396980844)+      (num-test (+ -41285036778370718/305793940074617155 -1396094619926552183/15846027887642356854) -1081121118676718273499338028514700537/4845619302294419132297197085940230370)+      (num-test (+ 15975644088444536091/18063939613598316583 17501188199168431305/2979264551795273683) 363736076920798535449296038324193823968/53817254956563877935003279344562385189)+      (num-test (+ 10197734562406803221/17452826108659293487 14639450560606090654/236781760961536951) 257914422508077920978698094723491089669/4132510899763835955061848877304138137)+      (num-test (+ -16810360766832230069/13652857552883800956 5011749175730438558/4169057419710079215) -184295743992738197672588473692806043/6324394120121667288243293659228081060)+      (num-test (+ 2234573531734039025/1128831476977636536 5842177084459535064/10255356071975483971) 29511180623959738330730559435115466579/11576568741659658592450950022331964456)+      (num-test (+ 2268894928233321367/45672733521488298991909987382109984899 -10510750087507287356/187832098427494353069556175466145198255) -53883392376116199828369509984040539934420061636271022459/8578805378260910951788610598591490227836321974082207035230408675959411151245)+      (num-test (+ 14273433611429514043/7774518083776389556784045601066955324 17247074371340283485/225579726714102822702316919752160926694) 1676942472465190408518249346164012571239098147062478293991/876886832336064155131767120243155911448808491410701588797601053820468509428)+      (num-test (+ -384768590020206817/26284423885474502132625533495652664626 -913687410374243983/254477371735734658619949996700223764026) -10160887225658731404416073535892287983824191154410167550/557399258996959835387173465565070652935481894323496556880024318994528462023)+      (num-test (+ -4465222504572200650/89674568206322981678158378582739708537 4148550863841320780/74302497820894496090312266744880513261) 2118016946376507498169590394563632549990739165791772590/350686547828419379316750498534703170285368675911953477374458878558215968903)+      (num-test (+ -4466938407638238142/281859125741189685767904931589784285893 7302241525893379697/204618108204962312932373858463395271264) 1144186926000295881841982161759159994442430111060328362933/57673481089466829503954266461746705742702466399988738560842837126631263478752)+      (num-test (+ 6692616266348342275/280491911593106290120490189988812804382 5414100524539959087/183579771905991028181574615911067652873) 2747240373316006570071525025488180559154305534334705425309/51492641151737853299832848099101317109893853469394209716061486746077629289486)+      (num-test (+ -2794289802081124319/15768464977850217600859580216291365931410230647587457388598921425875331529149 10869776169503285673/33805119742344157512165738805682358903614971418053290198565741206390317449856) 76938383491719886409504555688515759257937029058461512747558964579607347503639994773101488934213/533054846729186819415263583890627325668798847177803707144003483502948153457972377767011992167761176556555806720273883868208938866192358148729990609852544)+      (num-test (+ -253222140119290489/2123024034843473393742534167007121513293496410591072104903085284304117612082 17957334013642389787/32058972871090153103034645121513493401113378486125580864856088310966601405847) 30005809992231287609744177955201962181880644831204431411802631067134766877061419104162728517351/68061969937719269465960475690278941280799593161143759512261685488134507341176789799765185182008442410081522124548392827986923668912612728349293792643454)+      (num-test (+ -13318881947309618/3105936147298438543619802738126617974207009907186580731552500517452462642139 1850968757748704519/36469179946212878965111748233319050931475015876401494718861814560453153824935) 5263262069792987469108717688485565287648879759118200779949761992573778798556738644541735401311/113270944257273905484832818286307416845956086746130199501242465128236430928807948126409718436237517505516279133169796919230385184900609912160483959935965)+      (num-test (+ -9937822914683494298/36414156259035675966580098631253549474580108307284844243190992829476777586283 -13712605099585970325/17758145954890657915358548152198427387923366136638180213650029984340849686198) -675810254607579372158951115566887998278519717754376916387787672973408477396668549189167387350979/646647901672150721610792561233068038707362067627156669418022102308446036384411330678972562863413004325878365438890328206637571985169324874284800419222034)+      (num-test (+ 2479135971595944301/28169711053558469409458629766960029324030958129245230797895768033968717159836 3427244662960653095/28446538857424788738244844756675951434179713170118835630969510829753715142438) 83533664807147783700314944003289704497366290621039272787320536148072960487262393639109696219129/400665390043739792096386856839000624247597803909916773326187593475005945995926511155915226239317839405221783416485999405286913042389632370302962776360084)+      (num-test (+ 14865500635281371370/56222262470894935247131881777606182311286871927285650835673424014252462156319 6436092572090050725/19282524131572095520593158313261757267758159099923763177708581262473988426947) 648496060602737474174747620183913927791943082591316359990137585798909535115053578637078811588665/1084107132826611778585714784136700465449309125114745313342842325649687943726086785657821763235618936882528385000712567133180567926723616940173290425928093)+      (num-test (+ 340196811925805824067049620503247332111/14422464039094716975 51285507111580975533385007190438537498/3230944134273302873) 1838820276033673324738967436225477772648372110186756083453/46598175588880723338390245118389369175)+      (num-test (+ -210449319160504160992731982827917332322/5436857856220342451 251628249079137248539965770847855056283/4323109210037952829) 458271632943884346915405609513071881239303671882386130695/23504130271893362375786510953364243879)+      (num-test (+ -40984360445255688839942109197081457275/6593417935076565019 -138094174027187773198981391229349265879/7135512300754720691) -1202957011856131413678873259651070808566709454882536663726/47047414779755620074837011989046108129)+      (num-test (+ -289704472880230079383856507128133962457/10452740760651010288 -55251460678415911958671096669490155237/10333740726609314202) -1785630052601050832889834016432677758176770083879794496285/54007956451514283340719766211063255088)+      (num-test (+ 276702099951674677215621541062877777467/3899918017008359516 42623843937285717338660228144403811741/1973785812353331893) 712380176058162142132059442064597996057720566915757732387/7697602851312240113570356856612843788)+      (num-test (+ -323480614013303716597188084301661616596/12957985934572321773 -72966206939397711493108854138997499334/4539020357040680881) -2413780175334213399707013296172687953960842714316410700258/58816561943270580900205343368941122013)+      (num-test (+ 65443777543319569578713907336699651721/218804857459609839540825438673960136766 -61986861924091374470669233802827103921/65997977315012279293170493460332070399) -9243869541956614722377007489838492339200370508580665293676272508698701352807/14440678019033825487758061900150103876633207457375858942267120523885980189634)+      (num-test (+ 75417845823236070411341994633288547531/70553457686181702397810927701121800017 -7132208259849175775323757110664708879/24379326462014713478002790304943339422) 1335434330716260509518880689691257567128541829706203586134358870209350816139/1720045777955364955754847231620711706115121721983605654691934662747636370174)+      (num-test (+ -144692585186931942602350348772472248638/135233395864627580439431775527364081053 282512666765911374279543408363363928190/317835040256607665191397469890906044457) -7783226336195038987381961251409043080655184208289882004756343793157154115496/42981911818671667582796085276418080952868666330715445603855323471628969373221)+      (num-test (+ 44888992584766727877549626240272070725/30583318432547259097085073976959329092 8004917623696885952432014881247978821/22005016116109025986417835664774768346) 616299974987760892931461886440810919939264155149950328291076750435394215691/336493207496148335911511951044490614757807556827643881435283379298939260916)+      (num-test (+ 78378756441281199312006031491361997668/175125578595003447448566412156266355477 41128705932035853424044828385766740319/216359823601433445464965619660717081261) 24160702340946845080381231961736762955784254747832931999121777482667650876511/37890139292913914697800186893609983979783140570423836226844401085057321416497)+      (num-test (+ -36669293296367265584135816683983780855/7341750629088488427994322429098120058 -110335983484012479290765295565662258281/5944410911181873015545360879141666465) -1028036623331099574157832708037007047972965676333418398303213384036005227873/43642382546729990922161061763293407461832155878510163500678954788762454970)+      (num-test (+ 228535455883892721240720366651075744967/13353170075841095813026701300679754576855418298534901819672803635370738730013 50622643250826426975012800479360461693/18462345430382979738234695697296360785230118465695284267226773073149552698303) 4895273294635392498665165879164922265508724130843670837390305811645771221742112327485665544066552056189958877583010/246530838530831602270074647792752210668736478466245992891169449973883874207653264921203783108295835419855394180777469634862446033810927048792871560267939)+      (num-test (+ 11355068601761731966774720678777239425/4604724775053993730579400400679579947095967462408565975449642189823843820753 140083339434585694465706029861026468774/44667214322013486680993684507177513903616004462434123967566781106229226297333) 1152244506542792151980649054527153167035843960949499862764543674633978109831264344257976000890169981044543787620347/205680228421222079539939271800361418862113882206694593495620042859527547538342323521609420336002641308832164587573546802806916292021672743366881933951749)+      (num-test (+ -1347509007210283053816302848714698886/1127513773036247565111791991337919355855664936242166138889250311777351432819 -29464928273311615445392112247506626497/61933028109313748081628643142485450090725737246358993405254280723087421657760) -116677425670791909053501267317366054796703074907755330120413752187834449333299886015456661052906469074533366060403/69830342199092322009251417145364324484174202256910311362396720371574344280505889954115533896831727771442604285956749924105078563356474162416148250025440)+      (num-test (+ -324250487660721070279458563122233299722/81069650926979269606211148691445887485067008319429991878657612702576019034861 221744296343315457943731256980089803078/69422237643162665956763790134527973903052044485041686255401689654420090859107) -1511153903564243978242173323335554031611949546418082039382510246845821774680210236992700372319944685567533765722032/1876012190766999122356500320654631447623282613780323887424324139799202291067983209550065997185860196433399782230215269625922714982832188312141580824109709)+      (num-test (+ -5518324152042099343909980322067306333/114786626838714403445081775763480415805466836213320421844559660900880511042496 -34415425451618992284220085078832944671/96012285963709194218263616278916829663708037691620330613749177799086889040577) -121088040955051148243092870850103339772063863319219725752028251933576579890093496821887384992074112246777968211161/297862876779681729593084954525306275464788137269287692384941959703420459939692410434239827100068259769782676124741025632728203586961467995819025176090816)+      (num-test (+ -14763921690861243371082340598041267817/5580497386043551028888310256097864185640794395615400088682607872958152738111 -37917865546640067592937379176813765341/6460563866107795917092814416816176677900242086501650458839130903088333290440) -306983808565398982164654624310995401934900925070311336095043743767915008644459192438083753301097540174379867380331/36053159767181973313125557585868206969047484351694148822117591172786449966899079869470557965303954072842600790897257698854023751399649072014440219958840)+      (num-test (+ -50167218239107621378232529938205077788547946059832391744348095230748591585676/15685777859540025727 2959973815535345735348053015389999235839609978295604181643547897863515739931/7556072538495923601) -332637648328710384664787658442281566361265475773778265650094684540358159241317316408573560734439/118522875329417757148187346888166482927)+      (num-test (+ 36275100136090483878026478935942224245036692059657264537598788566553406654319/7192442039871568876 31833552596558882106090352174644817045294359487590746360517241517440556146007/5115621724114081523) 6795584791386081942310910570767193224876510928834120433155946649367201608618436115134135392229/603177258173744207443043238127434068)+      (num-test (+ 1518304705177739493483387141342904186483658277690975456045607777812450680478/1837349761252804045 -98159070764971437450169149833809835519268242923913777966502463698396945141091/17238232824535200528) -154179655228376218743158291724235398278770272999447263973992852061897564252670941977524115620711/31672662964580000612902147746364535760)+      (num-test (+ -16820231344048323866426670709751443650129113909724546927974450301780935205864/4879137683452153951 41987219452495799378686134495924115238909423831017150785452046648616005475639/10470103987572807938) 28751853386830083847297108941057082854166610198448421498169760256533906032780671559334244751257/51085078915429149801779227663330863038)+      (num-test (+ 106981694162678522688926793970551228214793665448093395251834862896418045995969/12359470989873920972 57736849967187961211538031441400807467468650239660040144967046985609433512403/9148121311784151716) 211534804819567028232303054650327703050869189253958355919997046592895748577556985792570078031065/14133242495605447754080611005730273494)+      (num-test (+ 32477400086615533920132766925666506741908300936974348739732763951610256880146/9045135183308696243 -27444990730472195954051975667481893116650518055101159075033425831129583042846/14815776448343565085) 232934248044934592851252865496377968609159820017147884670610366058217203617961573611006127074832/134010700820948737148715427669965475655)+      (num-test (+ -110053921687226074580746319073262192216481755737797790655164396095655530752161/255625377233605953547425802301922658850 104095037267817888539158192425982072195078148060302393917025130946535913363779/52156238014583575190277280296975732513) 20869334635774913818120011435677143948904421430726712952150525645851498022294865158343391008006649321440592131083557/13332458017563665620865770931104425383051282278510599570476131200251352190050)+      (num-test (+ -29732769078100192507326444863945498799317005912797369958801703828462203585495/153426302667449722633466432797809987061 36094569840376017510791155197897623093337784636438580042046806320700826250193/73286165979315961333009750429763545174) 3358855747298609357265422062476767573626163217619249414656940907348235709105513077913806378841119674678021275101643/11244025482879487592663298816607141776071841230792806495601092332558428993614)+      (num-test (+ -5942892427460131788264792587455286675871284855854073854440582948253436001319/42136930106315714728428443448730580823 4013357443728612356640061171485791666303136232331145404661874650095235381569/4039594279673425548586623641599574814) 48367895947790658831309709091377784501687363167039737892874371817395083020674648576881857510385191335175551957207/56738700606823969419119152217721454504573192499839513549171731025354063974)+      (num-test (+ 83833896550100013648317056712064289497247852876055488793078639582729685477353/188580876675619574786621140720273228537 -94310653397371924313725082402708514144086936359594289802762093989853507835016/223423274286761439988276492107364036191) 945257965914081840217765265999453398105151083284254483307155736205796420255026737575918161700355729594975143830831/42133356934734885127066999419230498520039134905254787577957770920054881982567)+      (num-test (+ -14753992026457621496269953958381833108089826525439816493815533773338622353285/187171041855711408638339193132645929319 41340837577662628944845446369855468662228665858415210386857356535970453143469/322471558852595372991189266479896691326) 993354944176102401496932276511264091214577507066786487301109889019709943488537161608732610457423116833164991120567/20119112546425211128699888199278894685207186285215928241217590790016852128998)+      (num-test (+ 1370528773439579327226257222995383030603284075640526658282329726447335048230/305600505683287165495713194488435114383 65450762047588146235054351616480175308174618406941901794570541085963681607527/78934496562987400429145916504112602768) 2234440886428442112499564751364146150136438855986167755259621093816030535881959724370423862435538502079424185584609/2680269118389404699570998335430047660909241475691839354273569734988880268016)+      (num-test (+ -76890617375308981455205142622328108690129081798840077873315966300000409208129/15716637731576156581128288257209679492686622162926707938907282962815471734862 38716252217351070567267262306332875768795464072349655597599997486613800623507/8966639693620677733207403249675415446338239705879120765911896990394928596139) -80961151400006413290662155450270992168701818633203071886556882897757813544592915596861717853520674107309124394292702460320442121704840951425284048212897/140925427734207212133604717335369986754855062343668899363006574618520848268718851310007161609443093589067206438198588881828988648068282656538084484897818)+      (num-test (+ -43290760758277846058307167265569849910514905939554272559141355223092464986939/39390771697068809730875092892395235497943839933482798653607450783947201796777 -34021960935937170163894986285771504067448629886312440795733904794894095253649/106500928228745564800818258673435811176493306775154643113582742982704678574998) -5950657500399238361998292872481533631424138885403498309639150240712482075115081624153513501886127772738596607451116548616099047843190357858736503567640395/4195153749384427435979718872073512266029328962522899010907363614544821318917440413166534226890289043064894115954085809567292470182917919104836361549181446)+      (num-test (+ 17906146982204022925114071077515882010955693727109005464426577098738402001871/11978213712662686419384559301746021856683603106261241838035626618416021524231 37108371752538653389309509075248119316034595087990649061240232817571629131708/23044877611981158676785639370406786635050056158699399001947422631523989139615) 857136973087880657664203854652754375000000796400911171478039451763440064550649429609696307332611304395324153178602635490321877797571177424460384122636213/276036469018466057777760709173569478463866562650149880633721199971933767458324034017734890892482223472007882939609440193626728031771767304374122564511065)+      (num-test (+ -77062185592993847534024832256462395143306675613123510837298699277378172890089/108133793614758275822883834459865239455798743725021300772336023406871185253111 11169356025540464491224577661206910726665825152149521753528516637690366838655/6369000033300801574913390611244042297918207179453133439308688067382050608197) 716975776667538986425481530620118513423964367153518065425241139444161780269039780459555836804116752462325735011822817367819625929553250251515977390346172/688704135133337463423649074673019029541747166391680122270752018123634233590688096940261480888455237095078029621363428114402137147558304641222314936350867)+      (num-test (+ 13583698920327742567560325715281067532806062839142769830536738488850089822247/37364394142255392010559408553278838878570049727027927213977555360874308098434 89809462356450792524214360688853318641058652796345720882094866396911421360072/67457610947238032712889230619376608100793287037427539672885124981055281513463) 4272000026182362299819817378001862956001381379478285995446709640464951377212652125169846305230835604666564953883168949950485767679005929254184987140738609/2520512763327523955464432226120154092742373168521113224665257966793820057379494860454732800329019773731110452438496395974166220481124541266348389100216942)+      (num-test (+ -56124163112538495128545947597589743957824668875494126834084658670528264380488/4752969512023182700122983723156599300062332404522277372984645779569746369511 -24794747728228571193100294011820993825205231022194400752319729320185378063197/98168688073468429337427023004226732413974455700654808087001957859427678524065) -5627484141989830997868845457242226973925524393512774885292323552602180052845805156311097870316601631410500655735815037997645271136502511615781690896430387/466592781448509275992390948177487068548424631274164031114910250651063315574511979617153568070687706304645818907382693929886654490427484894987856595782215)+      (num-test (- 8229768172162771789/4094631553683915058 14916542302144281688/9648520391570031013) 18327341244785642013243791303754634353/39507136041685332578233153660317693754)+      (num-test (- 13554976081719376860/5850035209629724601 -6813034992928443315/16012083383654426278) 256899901877002811987490932642058619395/93671251573905451634945335611797465078)+      (num-test (- -221798849980968127/896588178875000428 -10118632981534633697/16809799818197706916) 333990778095757160537366868413422249/941966737890699707694484674257410003)+      (num-test (- -10398409463665680242/10672871071680021919 908300169382593227/1663860017749090135) -2076589873614048366639515256135965791/1366012573135328609279238070700513005)+      (num-test (- -2198518713248421187/494031967775171833 162489257999262168/3608560229859558061) -8013762081101965644053022173225152351/1782744111192743850497670941715295813)+      (num-test (- 4025149216228566945/640594137312937394 5467380276809034025/15813352732084653151) 60148732603712157399679443099667862845/10129941051434949990590527231467828494)+      (num-test (- 45649282670476595/278386580761220266717341154184065537 -8637266763647548631/320617180101036447149595031898805939080) 17040443444897688379155017841073877168061229451634462447/89255520501631886327999278515127058459530587144975987720686743155549485960)+      (num-test (- 5648415331928005377/86815630814151297970860026950116430492 -3858618729527320883/27855468652821710859204555976171379400) 123081918822962876101148539477322308270739795776139149559/604572520679633516300271119677141637780408278090307422820905500994965166200)+      (num-test (- 9781572955588417059/112881800445343004034168709823458687843 -5059688483724168531/4577416283528891230944530353546966748) 615921077060787960354561606126348783111829996215681822765/516706991472571912574910836774186280180852506048696459094758451180832844564)+      (num-test (- -4967914039344839478/238170260180199675500515253723794945205 1851848905279976507/5731170327270969184071911155742503278) -469527297115675955424190428047537920421409443442551107819/1364994327983166854234805393053180119374354994464588574791772715189542881990)+      (num-test (- -16853061581795824324/96404437352723357070647888504166371117 2887610208906060444/32980643277330946266739822018299212963) -834203249643667606680245846951263316484378801689149307960/3179480358681967952651970543397987660141008737601948320258541111852875189671)+      (num-test (- -10766003534404571638/1736320411127247334175538439020437437 -220564366893542891/24024005562370344889629855466198025799) -11228676451427374102904112111967705085778332338188090365/1813624835433832784217556253227924899981441517333394378436857197512671181)+      (num-test (- -4039872531792560303/2717817538621352660433068255065439787147153801016478776178010367557953211548 -17969900169229544519/10371230759745501411127733226376204123221866394120596070959771442399588297129) 6940459580028931824293913174633904994365279610168782399332846513086074139209123514834476635325/28187112855925579976299840753672542065528422968220885043792832460046226866036339425358907691441054924266606457279617295071355282523744922239122018045692)+      (num-test (- 11905720953886477738/26349991043344773150817457299711471013733618033386232710348739943906972457535 -1868508269239354100/7915113871665192715310471309271830385175189228544536787145345883401181858893) 15941145914794937177093386304443205602552827651536706608400845076162777444155363739893353329726/23173686625047977587990304423741788120258508897732978034793987736019678129860415537604628640859289817332994555163435451240013483415438259775849311623195)+      (num-test (- -2449440712560236858/3924161613720467738425590715321110829708355586356453490516463081317902575263 3313932993860824279/18392642760231276916239249302906853654153090246504347205856270072174622214792) -19352032211145724571420568734409847660231095572377236173431089875006133635431666731719362137971/24058567564857748536604240288023690440577404826273237225585673569644473540232022448230431237781096357243673961302816983638647478040822458289501843963432)+      (num-test (- 2375854596996813469/17171542567603713573317138241061150416263899780234956304631913156611236192733 -1690236091628058998/115698505401619203741389026136939663329574241316722960060260525901879106902321) 303906786920788985464713527121698374469813384178920405503303785899916213843318155692692663023083/1986721810512032345893371071989737461519340072368099757524397292434629497187713075053126253107235936414498803590298681018206068059043963268488989361033293)+      (num-test (- -9066703779833220052/53996509329904595759286231403247566365148374715934463324003880626270687736687 10104829441267883881/34350188217372122913844475743718288066233853695548819225257606841719829170673) -857068498550946301314281599902676812596945461499639532351672507051201056365247232693696093577243/1854790258563312749374056592838765632813507083399863975139987272744324437901043103651094837595789610803765303659351781344942305171362498886075754606580351)+      (num-test (- -712905705954993103/38361275706852471555340413672243335795384295466685977818182375699688812583403 -3487523845474404757/24004509207225606167828624323100421869226668573968691661898194620137716910067) 116672912187985693533424614379662678476187446315443107971581372764612623068602629062267386180170/920843595906060126846114857872490000269306626188013726759480780006531676144330596572087176480154495471428384288229491172449159350622326294294528887818001)+      (num-test (- -104068455909264700529593875361271227125/3443783531459345396 94266182755532992545775726171008609186/10986871169556601787) -1468019045636814162670978305715811638938423723806410280031/37836405995984502494576730289263822652)+      (num-test (- 6250188382163250356218308848100308290/74975517450841979 10057222263694104272437942231238950849/1377150882331486572) 7853407001895533030925726629648778749078643531548391709/103252600010686800286181264132405988)+      (num-test (- -325869560300902552275820653500571757882/6390430580148850471 94468553562411191993094256419298214695/11908765973274803007) -4484399064985071999330976874105690617426359030318059422519/76102142247451389303559481900024166297)+      (num-test (- -93570528036598407567281714804477572547/1681213810574384291 -244906502561054838674546679498356325029/6878656438675875801) -231899320744132980638168050942881155823492361410591515708/11564492202898292712047439710761442091)+      (num-test (- -81411835730261219386583131450337332863/716127167248934 305772198898084305417824619321954306670/5852119619187572757) -476650772889757879179369019399921041943854248979406203071/4190861845290706865359628655691038)+      (num-test (- 8378821874364768218652992773582270365/264620166167099506 -235085292482743132422942426826553295351/5218853722286899445) 105936154887632142427944491040385766054707164161382644031/1381013939193345109641609957531174170)+      (num-test (- -46932041053326337601984043288899377207/83004348019257810472659105973646518650 -172752976692389001100875729845538600392/64697064048458368935602368307247306331) 11302882932785858045495103305619355060523322049764297548269071809310077113283/5370137620102451116225827082734739449691101289924623877117727128768254573150)+      (num-test (- -5215113722152182902641295804790889582/37267147737183802417372262122851319461 -174324915479281952095382231256728338942/198797486533978895289571841018885549001) 1819946959828587625889363843813156766676787993042778284071188313098762447560/2469538433480866339929667414220581052912334718874062150193407525506073469487)+      (num-test (- -308468863588547635528373349890793262605/277175417813474671446046438490775760091 -88071245580784145343997181342216325733/109042592277517238289414020635536175644) -9225060231388102579469362745283215538990500777711808852192407359260779270917/30223926073985207174135233898799350451872811382182855106546181559011381423604)+      (num-test (- -139281160373255540085888405052544101003/21590054032847718908692432707921390245 -175128181843395150044469443628898278945/101874815793501611839718166887463701141) -10408215647857282226079103083273257459322595128147732742048301223816698452898/2199482777568107961766315941206227462112836158088743951492692685709912769545)+      (num-test (- -13653637423911886957204229566898836211/6724361745919744069899921221745423919 60537422461958273742622747790343370991/323722395245687564470126807800714703749) -4827063738484690108652046326448960810791170812913084889649499536314520788768/2176826490887613088066161490358401961235974091796973399049221882998503572331)+      (num-test (- 207284509647982883454717074874778610186/315575836476247924963087075944676754095 59454580888278446469281150437143941047/3799382139920332759258392540934029749) -17974876032324524053425850245755672169670471578477359535347261991433397414151/1198993196898275844180025803639723883733761367273976879884312817813487572155)+      (num-test (- -149255714031984711085009662216310611563/61209488724728410476016289765233999883959861482512968048939594260689484910535 -206353007879160639705730135450663155/12341134377195982958424940281067948493740598784362073339140017508008773524522) -1829354061323966095884091779117676852909282652562065419187935424186237303685407507859167669375269438805585201409961/755394525511335693198081866608161950899365908489933659716533239785460293292606918153507868614180865950008697266433342863460741791684603303270127798639270)+      (num-test (- 286228990947356503137685907205210886138/64525193112922470913382853022276019736227442678252533126077234112153953877503 -93778927468512815169462456699065596479/70019706577332037325570327903202382111804035215024271930215402736305222068556) 26092773364888269343302672267572690894453186378630697330693315371426642609003667116358459590920104883240139740188665/4518035088612517412858008269349176355736855744033363257986123715832709510554983209440815107866748014413528943649032845277041680450752670951433682692095668)+      (num-test (- 128067958966292694713545212085241612749/50804897676960765097908813878456128842417954009101908722816951877006748778869 -331437715897535092432788513322484606485/102911257177761006574263802557003927106564530572416215828322919550454967864323) 30018293903870953799879886574342637699455128356488843398998059810000258259055116602688738404467489640369684487419392/5228395890723542025866546462435908982096651119675992137235094920338650164475761939608730060759309002063498665792819192135030537577109853650729817121390687)+      (num-test (- 27065789167947870065829490227927612633/10795458608984562931374526676297845621730864739104955678079256994070639461197 53314096352440087811254806167289750292/44807028208492548064750449353871285104149154384082409595945081934090139448067) 637187458285170434834128234123875152637450428605039275620795715002449318075555518355578432548587274399560043210887/483712418416385035748598509413117409273155809870339120248356475239836262578288026980177669113025449532258001487616187498682131415946755647640047843156199)+      (num-test (- 275528434092876314751862670579225752027/23290954563951481764306221308726902093226107549717031306984541394996363441752 118398743375843543978994815511147957868/26050691402435592629863948804505350954161759382372519491414484055670238339031) 4420086456754111377514058698455330162869575963826459083894390154200727636413353382047981846196341965799691593361101/606745469813648893293125236863835131523556569847025597910312571817347251611730291043895952533706547565767925058454286630395458711598751591845070996622312)+      (num-test (- -263828172858355421790882308711676546531/27836884730007976814146538035133148053942251062564400015534567388490010158584 31580638196736633522674344981675107601/26210154715367115936541726366619494863883445533448748701891278370021519416412) -1948520953518189888695889830515156795224640917019574042614412953331052369986548949517168001067643449389746489215939/182402263891837359872743630675214135004512597266032306942151126033873543370078488920825920736994254287019873146147276876145783659805845233146169813070152)+      (num-test (- 43029409555492054023102681165249027816896930295612442385573977041111849786681/17478431621804970398 -63831159286570708329826084149841946467426290005331979697932225104261019322894/15909114936773208135) 1800228375210677909820927489860838061135888931548234366640994061734196466170531105718785437541747/278066377585826623354880511023167787730)+      (num-test (- -34677827126365037739221949705076349308552841821108642369491195428278121711851/12321935233094032355 2466652720703038662112375481129216761044838204088317060529010755963314905661/458077759838279587) -46279076433142446690218423399092373290016631287423134630356063713373023144989129659854095947192/5644404488448083755690706619714037385)+      (num-test (- 75657421640076548917316021979547903196453821552146142751737530624725671569062/5416811919979369403 -51031635143911513328361770575139950616395278082588474953679149885798666896870/16274277637120569843) 1507698654622877634185545368063085304919907004898369478770589865697455127479301592176158803465876/88154701093808389139357381843158713729)+      (num-test (- -86696779369804422745383183615836359604633179506005810847902134850836986706763/15354752711854066426 83875579121692496325618937810567731584819474189441279434601944065565889174333/1890321146489013312) -725886765676185953186290796464189476910148783977596698524963064505627422317719186476684911836457/14512706875163632554860591439823131456)+      (num-test (- -2824584270835350806110810310308644313069326027498380007733023821989145840779/3128200028313826545 -16485532380752962986834975164722153533427821569516340079793116204530103476885/4044901389917631001) 40144878017198534388242075435853869853984060096218401720566307902396394251666454424383286522546/12653260642466969643085415999628721545)+      (num-test (- -71140717297594692514165816539390347954764512441693085945645019026357644035048/15130773661553937219 106518314860779634188990156539381479314908411240039365434170935270962911954978/11202282371121185733) -267626990691150539404999353980899804835901788880218020004516046839225745741587662342920970677374/18833244338916713919008552672213388503)+      (num-test (- -31372444086039981530710911528326367048894875160807395940269724829549418985367/149682691887362386596593782520991059630 13980025800771566396092717430902170466939197897483207383178768135899198010674/143215924045734814208985239450703841431) -6585601463869631351127457963734548845246885851328680299125624347680443020577881573937479731612385878788264587830797/21436945032301618223045694723696447349670080755369221855700055538448185530530)+      (num-test (- 60002561005149795132492915799111287923312170708430066011808292212167201814322/16346766380600148228286881361520329811 104734497917913613491539581495799848702023341599268915776996571583385896191203/61937476024742321910315674059586179787) 19844918952732846654680216616282727016967753441473733514766184661191061075852141231786969917096326062063227788681/10024529215648371311559365663430434349900555024451481776473735938354274557)+      (num-test (- 78980655687309201443760271907411093305339297143458162112992101000746746121121/24094471248783344167514231679460830840 10562090177736342378322146805187203837437609238688017154037816697523731420573/74961473522415640988394298626742882726) 2833009175986364875175323375606672657538996734036576482627590142336455915129629838687125527863027857335645122892263/903078534276138789186206765245648729133926893901427360507431923032322034920)+      (num-test (- 96507496069338193466683209170737942070468924698476218759487496209308948365/19252547784216386872197161331387216893 12563973560096321588715986952435909079270363887929001032891628645353358046011/79879611474172059435223762585596250921) -234179520035021783886726161079163865833895106001667476480293126893061678147610754451356994012799045797572757769658/1537886036891137155393554113191390737924110193971845147480358562685078008453)+      (num-test (- -95307376781556674397571761484869767912211504027346871580288574968524683908606/128329921725822403056205582017133271311 36170894925879686192917617159219095595164782822289198001474013555499918728596/240886887357120796976726436320063138705) -27600105449672599524131749634403660999916186956076872373762346977331203119722064380924286397976905109959929163304586/30912995399316310109755266138690547023211992922143297688759057498082990192255)+      (num-test (- -22104893896795356297688360407985617971036912713007110938688208155601366216839/5790727918973991999188987227357894380 -2339372311396919406471876113751500811577555408710269902369834593304924842262/12937689744925498650506694361349920911) -90813196841584888136609582546105640167792279132393576014002859436259486025871518847027719826829986116492656710923/24972880404321196721702428178050372850585634300866259560981343234830460060)+      (num-test (- -3426218098660813853559652497557253942819662042768623922183022792185928242671/2077407536662385613357832628600529321326686191757127715026249042748302985178 102639297566540827510784861997871251414598617775200449087621943894148321803293/83089038429507982364103335021257902316010144851865721965726693103637274338545) -497904817589969304680335736144278473886197067420059149312627956679073246109792679236301202959163792633927112737045328517845259242265445360227131779644849/172609794647490471018785535271654901168315737813115654161745630290269473799997219289162551586864155467201760250711449118429648095083028041134558889086010)+      (num-test (- 1543899448831604569141696144740105016328586790221799945430718394112623114412/1094690716976737526626281319975432667416762320123576900412499904933271786567 -101835025746074730017715423582062511397387458863000475669454309217160145993/55116548932808468782187525862059393507883043749327746382569396580129398962) 196572266866178229534134252625134989714563665559807019513454337864363053729628560611312158082929567528955985669620113192156991984486011150099776316375/60335574468539540262844259780498204139853746803235564167348945699931512713417761400790104247218084745081610815218855896912895393599203789305655343454)+      (num-test (- -37581128364300495505521143552535972339959603365602244668159915869829949338997/42947503543372015019662104425995959382231280059683481488692141811517675950053 -64888994735350842409379226446854438865448614840503930577860382883594178287934/83188698741706753136718468601650233481619465918167616089202536622553688681087) -339504834548876267781536981106771553482515399809961247195394672491113984585270709765073243997043174508213253440272888923497173265137136111635177948889237/3572746933977957867604303713153220827104741303667912510494658617478381525690274918494624922428110123336345510454960178899375325287131764283538305257747611)+      (num-test (- -16230533405187239318665866908175768720879595131719076634847964191318368133798/22572606803697929681675696479626869642065470042484269772607381297011844085929 -3238806615045730440879378702226410558103197865253164974472379309242480970831/7167633180423354812410246140643720752789573307606828791458541239290047771821) -43226201536346598702395278529841763047400215735214225929426206339139243925579733185594282160061132691154727543083543034702325848468839969037250195569159/161792165494835249202675342837643048016103040739685489755239980324180308179745586573032524649518850731442178659412287492012066453331740508600962908806709)+      (num-test (- -58154703770626762920775801228739843350302933064569814497417973139312614069763/25655935043535628671780902110427599603857741303802203417196105196580175051005 2291927744682353823611191393035210406213286149316388597509251757479544491322/2075117977066796442381930295725401140983312287419314083032058820231519915051) -2848879691864593463404526996418656511058536739346277043463623510210968076493148319480555434626780964688210750895957968447300033820091387019574369485421/845064952814266442598400897276554701819815257830830535600041451476645443978805142044657833921127247033533628716506571358424324423237490438402971304385)+      (num-test (- 16233726784138742204308718138203086218138595789383817317246449554340898453104/16370584482945481446847872945862788646563748664837147378940234530469832625057 14431071141710676049963542765626402177344958369162454874051268130438178883381/21166786163219212747261378458659387864767326410261049063051557406799162784072) 107370754167217929909136144689909613387440429633745577224054233373886366171618903318258855919060113440621302505589923655976636732694637334616990468681771/346512661117421566971293748815177161526095870176610277140325665174756629068111228154091043637596506814557119477231243643171068111260010676990408227692104)+      (num-test (* -6520062188352981842/3213004995534018829 -3812444292971845716/15284944374811818089) 24857373879807849010516976362973488872/49110602632729971801355498746248797781)+      (num-test (* -844583948128454879/4750740551331102615 -1309778567130405125/4885884698278749707) 221243590680205607733892613510570975/4642314113048197066962569716783636761)+      (num-test (* -4579815856418431271/16947444571374397297 7990245706938186906/12540719430158043191) -36593853985314806270746820601513137526/212533147427761354206383017714519654727)+      (num-test (* -3587966953201943536/3194797554208122281 975954052071387816/2707062718507963111) -3501690886675668292903668827990357376/8648517352177231144330968693325176191)+      (num-test (* 710265334225408429/567023629756400552 -5578988760400430103/4131535930210536898) -3962562316545608552741467762441538187/2342678499616965424161446427863567696)+      (num-test (* 18305319006789031727/4480148641441744463 -1641093267260986094/16028097657311023719) -30040735777106040963634910981471804338/71808259944297590021537032075729917897)+      (num-test (* 522499067029593907/142530390958606446621834761330018829110 1567459634764499377/31663510497342378306792964160850079086) 818996196770998943862055820464495939/4513012530308148429025282037949729145117603192483641232823845248212618993460)+      (num-test (* 6214041481074460220/139497414619784295310756757536261769729 12187470171919324678/129216394212432939561557938117593031955) 15146689039532873328968703771155061832/3605070583825050709361064709099418651298807367637359842488375232197429738039)+      (num-test (* 10022419596195177499/91129297586760817507648681092594591108 239769653037576215/24086455608554015268646156321002022494) 104481394312031409685890479072416795/95433990476618390508514520731482064738017476445225501421324446942302103624)+      (num-test (* 127731839927226607/59760640855511386051149338950192132591 3679984267166095161/269870724770589242613062477043917992045) 470051161348371979221331000573148727/16127647460431744118786930146746069875784110572380855085272434637353123238595)+      (num-test (* 4919926511230586366/29288587285987487013553554568227355149 -2914615432991234299/34407808954885309804037535414452526052) -7169846869407694119621783007930483717/503878057947370143933800273784055481319429768630967123178484618174989420874)+      (num-test (* -4322680734125283661/246950524730861178141734701180345535020 11581515233057355754/82204027418720951285150957025638971309) -3575942340708251875937466941988609671/1450023407574517046920597087724458064116343346221474061477327267648859624370)+      (num-test (* -5552456004563371781/36434418778024040927761226774271610950778609263056622471030041615086459120568 233319937833204741/228703279535756717601739981368829304509550463672786894384479957768850829340) -1295498689806330283646616799874813721/8332671062513255913250553083541810221054209355142441164334390514659539371361850837178162594438925276666798780352514152276296209564179606228713851865120)+      (num-test (* 7279569964232187047/36316165899095632459738478614507512808578186173163489609755035948221062420580 4568992288187244990/18279847281938710983382796940666233712517527808023718591530848159479207220137) 1108676634263212048809114991909788151/22128465550033953372731954247755694375180631486898426116907313824243654714198100644737500721615620412852035450119116976232805701601749863504629937973982)+      (num-test (* -8689289043809733973/34365105035540924847908154205433563929060132734873649554594240958996510665976 281724695877043289/3383396067954681850718083474385093262190311835985400909911383280975222535225) -2447987313255021583629117408894957197/116270761252098802423406562021935246701911690887646043563899994409915142686943691634418411056232663942535537938126289647041118885713303684881867869004600)+      (num-test (* -4176416206981759902/47077361360975682486641492558477246171356187409295624938308162261216397376441 -10870319933050648575/51626085927005484523186190379579228801774286705829757742503501130303410401261) 2670528255498212232918897515060496450/142965876637554026205455979922464979254073063785755559223760631646970673683621524411341782655829702451013418009338618833412062193643308417898164204593653)+      (num-test (* 4496049401725150702/8024116634872885909638996643719901973664008349644172107626390134736213108465 -5231341280619167012/99267989241776204190444307671763754306088564051099822830201760217121508089279) -23520368834947889555464127765407042424/796537923785319116837266627763277272873506235001122453584405648384893204423914484193595265931840447141766909166026026228531619859740155558402735330646735)+      (num-test (* -2488955833769033882/80573015130339486598712021266263458487997757617589137912729682647628329090307 17723590657579960683/79078600039601362101827108583564759878924923849842119643649415446502020994810) -22056617181258995266120581914227430703/3185800618738432636378738398589185111057563002909241393794402306079667392482341108052833514927720630087013771419748846412352850012097731569487991234153335)+      (num-test (* 24410613567363183821142175154197794689/2233491913446620869 -289777146895293391500645889398422195537/12394177861163531771) -7073637953514043162500219088395995153310329907185649946877180402954938102993/27682296026727883467940485833673128999)+      (num-test (* 15029397898618080393623393093137341347/9939158597399833599 268484092305118852707129202725716126526/9752180454987984749) 1345051417567645337656755504737828287428006597367109244226136136424901090174/32309489404196149853047846865649927217)+      (num-test (* 175291724581304230067306380062677652261/4791591464449055089 -207911166974886786162808240992513636954/957635297799905137) -36445107018739410292029741836217649994267718828374576884161821761303211252994/4588597118993154438342028473487092193)+      (num-test (* 208446980882041538439350888438428103817/11756453246592156788 -99855903858077543170703702663212319708/7775813092266901197) -1734555140205305628415286772698507060801514301420325900368570916304368260453/7617998589456250715053087609460739603)+      (num-test (* -49595797981179247160347259926801311825/16426101929443877636 104499598328969971414586784725010079457/3085074725343747115) -1036548193567594227670217621556353400490405002875929378150074378019016735805/10135150379689493069951723318357604028)+      (num-test (* -288919818051255959565698296502103975540/9373352185361138021 77343596824463059344208562767410464067/8355013728778983070) -319229970313622361785032672064391711775428287673147624981393545586243098874/1118778374191039878067165437747032921)+      (num-test (* 301194765217764762175383920433701358543/150076401641721289621709469985978858175 -109319143590504335906407585568245068241/158084148208214805386290412276525928977) -32926353787549066990014316879429253235742017240010356390402491456481443332863/23724700119685440084214937112355810539035473428177368317381421021523605836975)+      (num-test (* 14575317438235510996984657523859363247/6747043355688580686998987940004831062 -98472042392613093668204392119412188287/152397803267436514292317070561082866275) -1435261276663720115408306632770383012566806521695455296458086302958691687889/1028234585957093005711368462502470683211464374115746651290896689614112234050)+      (num-test (* 7543367187310376010646193530301789591/61115754966424662873097894247178344192 309940239796651595482411737112678240799/200261667764086238794802895148430893795) 2337993034909171213000031444662193658341848356694420878002930517675329723209/12239143016237439360279809707749702660797878084581096344749106125186707088640)+      (num-test (* 306232835922656327867425959604977465100/55646521674811091128956181530575055283 45245255551837746690160535427248646677/3669533234425940180962041078287629087) 13855582919684583969821610044729507626133731299765443289084519977056998472700/204196760665922729081584465192637337445710456706084552841012480810023816621)+      (num-test (* -280037880297253633994139513185953058494/23798550327416056573646642830182072429 13967268482262630670960486883264178489/7947215947745048068401387767511847243) -434596028812829556627014314125713048434599389957141408329542154357763726174/21014690966139335562014814134594464675233042588696546668504776333756662583)+      (num-test (* 87160410649223805266866345018804635271/204719779683096591635231158476535039583 91197762560765392928084914476898132964/277206223024759381433146631560580134513) 7948834435086720002947247338196997812861466884983039250681993725808882173244/56749596904412078223459353928850191672356004665473536520452927516595919428079)+      (num-test (* 272801380449749740391855824723351316848/2170368723435176720708253536680067463416474841046765138040214254204061862261 14545537787709209389572055399030228996/8381323291479119825335849511027103148981778425333781230074116361235206363821) 3968042787871071204066360146704950989545352280096012736206796950415592924608/18190561932825050861659739926693806725838682397154479213760300500132465705680046683155463862909993066621811136554677896021527098482779305371951555659281)+      (num-test (* 58980225701104541897366713189611773567/10973700523953435846969235385386214078292603476932194022615006557054104506344 21633357583056027790037764923811848217/41236459355840549300942497778444413350482341379076368704834339005347182486274) 1275940312921345964633100864283753667394719832288287163056787891633576680039/452516555639171997520308257003811683819837367444947027711901120987864272999978391252372420644671039873982401560595091423172287702745925783369137325922256)+      (num-test (* -39569537110370574225194522625562874655/36290593978404925051095380486087641410218299612051669925683823165483928853304 39273660356839128453616088747231247259/28875229647500294680887983884278577441525691250738380954940513956990510132534) -1554040560950035541902707236381071410695075315482961522429891905381129320645/1047899235170633560739863801929205639611958070150694189488499584527041043137082563721218908614201921449076002548982308540689571766482794493357171683792336)+      (num-test (* 8957762734053174688386697837976422606/712105675122280831038408324375785815130945929819518342973925027507219300067 118977607972668646264715307919875588738/36563306353035936296510796886853084280648109576589600551753305930842020963283) 355257727628119695756412145322380851760544279491883270008434507085780737076/8678979318410478400681656718586483785992423192579006235728835173903750764880944673586689792087386144715446501744012435157310426693657188196381455479987)+      (num-test (* 114386050140129336980347743358441052599/11994188887964574384037137314302737861703229337059619512751326848591488081229 -50822174853799566513638003084407139228/97406657802317796912648600328217961853548397771614449630742570869667560514587) -5813347841057137571369557065847591420664634372223088557679866032754664253572/1168313852626327929522799656188055465298138284154709873285311568978496136227795809646907486798429717114923178357702460243511883684964123937654308495387423)+      (num-test (* -22147677230189664783449572410799931501/75580058176304394102183955194485040346816524663599269056794063928343401057143 -127672554664595215026114551202414743739/35777311684781371234035985601066874920871049301826919955489852676067316906014) 2827650531865200718433745248471704607394596478050653604940563621773668622239/2704051298527551014378337257898371613519363350219566689647796093438747503077807722203668806231503452508016974614236112792032033672965127824348803574358002)+      (num-test (* 3468729773587632113679855593063165286551216344725198121609354788619580819847/7106612002452012151 20863200733446307102600190583661606839853255577505815215312643683864543217073/5700246487811068117) 72368805556440529088812813715602124890901251289457147618293618526488567540302416253970205832659523238561757581481150988870947074663135867252252227647831/40509440107213064064897416415172689667)+      (num-test (* 43306673717838918980731699770600730039727453611468399058203483818093233880231/6173575908538565981 106634227988568775671050783423559067905086861634892257032833451008548321218936/17988169594879808463) 1539324572884864883885215269788177741067901747630436643318399808029602335378536990210735234944615096105103848497832537965483619535769637171783464984418072/37017110149885307295697375341989232401)+      (num-test (* 61636028396239445662576777415312348317278054920190931147781159688109244233565/149659999183936017 50280832809996410949441105432174396823883728565382915986396125237655209339731/3406752842984125790) 206607389257567119017662603624829733217835095238758046754428174885007999774491792658838812826043033826701244157167565054600950156595290052398436186551401/33990308513391731439280046802638562)+      (num-test (* -100579490802304807750359433955474958462342659278486016345156932756807754105945/15683759624513404963 7314396152134987983181095955389244247502417255088677055075146925285457081540/950287995699608967) -735678240508074701153113537069655056596152436111651040530896921701439724727486696483134676487497031899584038731663111390949471467249259023050011663755300/14904088498613295322494450308817103221)+      (num-test (* 25984831699359211750216710442693374608159925357093100400945034699383345074385/10463598404993207796 -2395913226491242076662067669730978955981403048697660449593722338244504668974/7015215522730452775) -6225740195664363384298636893730784883811595661227613249243163802476751022407971476247993440178871949687923603921101094083879668063131450147131783163099/7340439795432595812648347200273983390)+      (num-test (* 5173661857391320950903772549611256023540539838210520778403003347430938670915/2590493168574884173 100300641976357496491877756123729102910724064566692821682523911939220592349990/15304416107565779147) 518921605664943617990486317157527087053001312760892500249127957517476408720600460633868004681188890038115877413554399588737851074382787744833707113540850/39645985375676570588146199684023740431)+      (num-test (* 30299639015164203561126609159677900559022306879488518544803392527841364186955/97638167801975054493877206805944332747 -50150465496280036231382225902610460555496341860773955714344071185921583266663/170117675960786609061777750278261277482) -1519541000979732808188648781832621044050652591754537200855596768903085847105531546641139177813880505696192826380113425984545675787584857974943247950981165/16609978191541300835961154615181304582159561006676548938424954151558306303054)+      (num-test (* -34494394944257769716276791009665812125094062960425641316440943461722789694119/69239821080832171466311153221314488591 -68027404272124217088707268142523090163964888591405843143848585935878552833247/257149529774225346004390673137885895872) 2346564149995340998782934409780604815295734898030424565252099571337345550054284934036215402972664245125313098735082896555892607540059632597741979943574393/17804987432587488254198543762235568841018786223139145264591718687823557996352)+      (num-test (* 22330754509472350470460807673039908304726422770752644988051418230315708975569/141163736844241522445115344332946835969 -3776092949566234532895208849184634613770861313997034923686862122594334787771/22367110097535579962848998753563258272) -9369222740190326741203615957382420344247102784278353165345406236082475331042528539717966581690645628370939381978953360215380653092335198860022382107411/350824982641632215769272917522017419782283768012468846380070797128085153952)+      (num-test (* 1376215273451682681102140384578115142238259557166158859699272578561460124263/3593386179017642636485249017714833669104405991325015697577507088650274886871 37146275008876311604039415809582675415172661567487888072055609579242279390723/55424998453085285819414374477780690192979527887019008768378662580126754826472) 51121271019052119686352858568900325361226598163234091421115939503875711782442415328681175322030659510284806538410228985354770913411724825992699509412149/199163423413390889071651575953261174839972499014963134990506980080139461063269751906284862132821075544766093817070661266293471833091996501160433036049112)+      (num-test (* -88175289711320073148300791156190227927348022787624424521937188958291199926437/38194742314758366741668899229532351990874883495690656157862650973602784662629 93421911195279228911508870033119580111709458306921869937709821511660370035352/66371395138592894543765954603571534463846496049156722497129962530412046587003) -8237504085028962150049531747535213236460729066521397582683209771842938254589363802757604921456170821878391951762499073662677974506165863935238701489400824/2535038334389561782321790943041741331416028402594806464107449488311138037598457377927652600804722340759363172755193254192462811091332303758223034251210887)+      (num-test (* -88364214910455569163017945328431687038422451206033411348821431934742389780753/43010507830592044720656702803904712217809857004582018186125828892174875808576 10405170283887792832024806983921158923908589830001636723872220129826733402834/4055629711949631304631599195955105801456753694558712994574702123032807265321) -459722351572673455425943766571506569631562018487574498847133029199411842205331593858852090421782204158679934054007027833206633183796877753882057444427001/87217346741895687976684378003169607737518608233754137677854312677618987931466495788077930577814677920791330694741284253568592140275298729115088619596448)+      (num-test (/ 7013212896988366906/12397903473277899947 818833870013215068/2125577647443895255) 7453564285301859120853045020886215515/5075911640537211768265804260348400698)+      (num-test (/ -15781329068048599432/14942574238341613337 4388772934226358350/2640112802717985697) -20832244458230302534551181278529162052/32789782692450857054331267544650656975)+      (num-test (/ -9015230453321124271/17425619133302730035 -10422000746814766599/14972344381173680534) 134979135022768387806775446187867640714/181609815620990738305316999098032100965)+      (num-test (/ -14741075237791868512/12448692140900938227 -1090381863721238817/1060836378253796023) 15637868866825840780217685066084527776/13573828137487503515304766902031557459)+      (num-test (/ -7371815071140740177/4722722556038701367 3872455829192658988/994203944294825175) -7329087620340161131469364260313555975/18288534491791723206480607737200436596)+      (num-test (/ -9856364379969390509/7988230468709836259 -7208901117187058135/7430860779232874136) 1093153305924514768551484985555671272/859497963436269188803272225817371895)+      (num-test (/ -16740689272507881147/56924866550406451570641164619431212169 -14712532880452686095/143481612520580129383584255576273223983) 2401981091525408257128502717450566513166280001357873948501/837508970838236191644285394369194561392491093277901090055)+      (num-test (/ 1874027699956565000/65960003455647360668413772300355814843 -172394881832672950/2006879686300828197846469567507151887) -75218962452157875130617756878839223573611935155763100/227423340028380523596387094039260091189651621559491937)+      (num-test (/ 851521912886492079/58839621451933520132430725102159653727 -5525838657334730480/268863138354222710211869290179088409033) -228942853876053297959532391872114722003932597144466549607/325138254802036127673497464266072288930584674567672498960)+      (num-test (/ 2130823024472312937/30463932363736038600114358208342163020 413938864244113775/131673792970459944919771618253738144891) 280573549781056638388629087822719475587456644826399754867/12610205563054396144647765193069861697742251186477600500)+      (num-test (/ 17234694073181371137/253506951459931119968572673772742357160 8407879684613951161/42697666588937447817581914537644794355) 147176244259806896721181660841298454615950364713859506327/426291189417673978158704851675227114861497071554451732552)+      (num-test (/ 14739301038477826821/4801125431810347467140397350459581435 -1752125940488995048/127905197451270157484305628763539243969) -1885233209620217720514367144506571751170505057476450692549/8412176412616337518572109406238500578932979745867733880)+      (num-test (/ 9194848570227974720/45448499872046683203864930109076126035374684748838016011669264943000310475483 -4572473918523931944/28941042619577200519536336906341131911598596429670188136734086846500956354149) -33263563043940787786171015409141766453199063320923723716765930467953050399983260590187417389160/25976510037621464639740779963549572814837984766154635046133743883024710122710674726552171566119)+      (num-test (/ -2662376868940711929/2674240208804755702377222409224408783678596883960539287029565653749020338064 -5046618244273151929/26826013625152995057141957222948811537350409769204161465077735924332004069058) 35710479080747854012875521001477955195584454274704368888444222736697434540936425667291700196441/6747934713661461716612153292457811722283965560031580498434684530869001786777260513409206862728)+      (num-test (/ 646980248518054663/28444849537262537816809349756569888989442483441699293309597267649158853799707 -10174938507557455325/16470612178414296088079890015341965945714023680627341561729034923083435428747) -10656160760434978971303471120231114671340660575734505071429575384684610862775940451177787597261/289424594898370460244167952344748286246980979584479610186308309369583658143095854438992150589775)+      (num-test (/ 1268676597518744714/6024937921458004492480888468749320142603908196076058575752452561172018490893 17823595902143962912/85935047374548136904062562443188289405155329832270007415035044821925251080203) 18170630585125644385503771892175817370913744757273904248648000044618805359154885235028182716157/17897676474595109057512045856227678061218241143085827332930191066967148125532813505892133626736)+      (num-test (/ -3035741006152688190/58890268425224581569217175195410848521985674465189565646495474378301884202047 -4870935665435665519/47998868922405332801456101880162843269583282603435159879276723163289928325531) 145712134636693761356266465698326002831562744975420904782663360472436650653549187025441059178890/286850708819506259357726384810790881448875152111132928069815447961129371272624891025817707117393)+      (num-test (/ -4420263280205408439/38682162086456801604593696710774835436326970692840048042132553053971380151628 -758651402628235427/1755534012040040367913026343944696058732638465867705260088080517539506722166) 3879961265286134914514096239640695384126081133972137242327715997675029567458817030555062379437/14673138261791601182714628661554161812345431143865809776872034934342213839184709418896670662578)+      (num-test (/ -312487180249669742743295380499853180353/9828632991038934281 -86131955660561774942466932680637336739/10268762916730341592) 3208856768501438660232746468300370677374054716853273141976/846559380988100144557815474234956961169507773676687849659)+      (num-test (/ 105376075880566042097567073713047434893/11411565636673693365 -220737802783327232867818580441304577024/5817406274606660773) -613015445021032499619145665530563205764250055719854552289/2518963924957071797477174332253152325843619212749200245760)+      (num-test (/ -311533429150518992652072799089375050497/4403073054828470603 -320230219907951760832723580313293021909/1370493254961533625) 426954463345823097468320537904981772054351338526938461625/1409997052618498081840381197699863669488222338862641441127)+      (num-test (/ 305676222727436457375950609916137360009/2001517485431820526 324338803123828318219640932070020543912/11123178903397935211) 3400091311912189654145957985944153094384781502787164376899/649169785656371151621897383467144093766684841422885937712)+      (num-test (/ 8845112929712368402815105446090151026/8124751572615311799 -107609110538267962880281203537194473336/8714443449141779053) -38540118213625599008519681983731393728094066419546629189/437148645036763776481446937412401903340367189496615845732)+      (num-test (/ 152921217721894690043853278309581658066/11705615305395353865 184187448038871874764725486848823516773/4171619104693691390) 127585814672335876029018138907883882524550368713261650348/431205482165106014329333719781838993214328411764819575529)+      (num-test (/ 16414254293541341780725162107696242521/155838132618727968561620486302365154071 323320173010032367023620851618405869489/49801924105617352177018959505967933104) 817461446577249670665800625691379410535771218196808189195363718417488315184/50385611999847495177988476252475899813264458225659097815552272081452203039719)+      (num-test (/ -188149667625860588508273820953820709614/21438745582767797684161462130971215025 128458309657689922121539794960212789849/134174286369366827879740776978166655691) -25244847384333405496229128525982900130397411994350175944375943735942831513274/2753985018743617742875555653653797261370358442640799457019039857068516281225)+      (num-test (/ 1218460641064115152742257147372113443/1773382194117714970762642066492794929 -105212349758139121832338365854603836112/35045896682356785176328011712384921341) -42702045738251194875426595475683618047253961691478453648029952948483687063/186581707662369193907913729212042024270164277319717456729276609131940676048)+      (num-test (/ 1467722271775252460214852151179762687/1747611358981474614363356529179985509 25495740211005247928144692929451604259/29615224810946461612486375021101910565) 14488975012885720730598332784736375353299643425098519766594278819666029385/14852215066131169889445443721709162270198753408805825268529301698140894277)+      (num-test (/ 6278399735526726207674375684072448068/13890681759576280617381650633747782321 -112063146811220963294237186476216238443/46495820670393894026441353693945662660) -291919348200099113895651901892723884699250237261456280525601785996696740880/1556633509331345870779770006255469001211806559199158615405344674499795966203)+      (num-test (/ 248406099260780863433196593538936526373/315762135750029127758352280023694126018 -24578051912523675039725210046249323571/3033769619337997374435389027823294736) -376803438597807975522050212312559316811899647514236724224019181136008036264/3880409082236781853269738100403484871805889674074731389226471480469265885139)+      (num-test (/ -305871752543087256004326578375555909668/80170799467978436032303243749692785696371676780847080230403479135749775915991 -208573266832391890136462745593008906685/96016271562601269514856687672805175650907293023094157826925793080307407361434) 29368665255505841438632782694581946057561031972462112644657516768267440383833513431444679871238206541553985530943912/16721485549600848123731461311227384049611071114404954309505697259277905994635125654414916826332204568970567318299835)+      (num-test (/ -171651126582338417143004525987733942986/48126955023093310081685702171788275811688444573315712039582092051531229683107 32570134112026732491936310765048378699/18584159151613423191553551933672204731023422884196280183931777685641069715348) -3189991854959918631828923606391779823799241149346421336570141741355492000935500642040047513113849334779592681149128/1567501379505627719887579027549074087653888429037997616626567546431482074522690424133509833932668944596793898937793)+      (num-test (/ -31304786393644787215292629624842492472/10539846271603297974613179098685212701091372728582260780054561526149580513583 43496364289252206338797704034889660065/966865502932307025364733802774045297740949567802356684866342045679773834966) -30267518040679809082934454680954168768135550720881039440573156734314284479043791824457029301083428211405425375952/458444992982373700837242411005687390212275114474481688646320865335043970683786989531994936463047685893258985162895)+      (num-test (/ 124366625369659591476708994326732418029/107684759001536292829359995221778346870065030877016948429894748600664800488759 -90949754058598173499067700725927605729/79727020098830307921496202496061295138733611655702270828135321391380898414003) -9915380440470549523296226431396644117384598256053664887332801972488440466568616812942647849957495261151611303260087/9793902347049141646079571573977765974008832433473016883117384010293158932212528563016145547341801740792289848500311)+      (num-test (/ 26792084925762094333829722201654015569/6815899891200140342329613369008754659665480100088941978786466272502677117648 179968988142253715757129058636648023126/97033837835570527321466682927970125702018459951415339098532052222053589117353) 866579607987744230609336186273867662887766686833260209925103055244528379635362816895584608387230956963010276689619/408883535566062149539621907018509777969515872715944952500700527207173412646715462423653890585029605025758308909216)+      (num-test (/ 320794852821756057819990044473359503428/42380074203350930293358543616207018031675687905746455222111844144668904183229 -11813439835454851567822019323728871339/51852159737956631156972450987013128151750117741949546305537111598356497409240) -5544635317209327550045071802859986261979158492907374734760649234578367469399038563605323839330681533705071632958240/166884818941132804535892580774781586387104334774784737031184369589400544303785250219152004898392301479219940857877)+      (num-test (/ 63160395612932962868082774785156358041658469338654564454114468396132462549944/5671929772244157797 19541045450680948617094710246839287171374470593288265457341382295544977156173/10827756125123268218) 227961786821047895774887365257727015864174017882302289602409601101722343657899277052494444293264/36945145824164509580938949252327087600266044162541122809277442696583642758457532273140841543627)+      (num-test (/ 31389399613343712511677734270541516183531975055644318154870016415582858008412/11320913214023484367 -95931706646769408081251897664360951854776052790951374912970042200868629796051/14301831604104230477) -149641969141325406602881756591195860220337618158488775091717625369334526143115090325362684257508/362011508473745439254610688691597507367516106821889963803421575701854031622412859179610532278239)+      (num-test (/ -50845041077039215658764589763556935122444212169574762080162289087527164772395/482986173890811026 -51342299909113507561385579724776151277474630060658338514843664853027455595538/3864573616937705869) 196494404298439669659681446421686066898686292162412914850963937042669022612531239234324840686255/24797620991857267698917294149872672843409173617406514673128342148521539559341861421304646801988)+      (num-test (/ 76283614020376921713154299810619585257752996149145061806263596894412414185408/337890011287912517039286436540240936661 70530558237421368381589233382700323659036925075366138096846582768833233488577/12121510300837787759729092713205686989) 924672613133132744522463879340347327755455994321131972145048214329608890428265966744607561005512244129921459256512/23831571118985077324412202325831974453532679575894228007993082738742295289254461850021038245882565939546151124021397)+      (num-test (/ 13518475961402756750057330871273933874583566313800024119371308450919239424622/71146816100737230880567880716110051085 -11914742388051168959634071864657967837347162591767656949770878950409478930980/166466796775669753065110807850377519909) -1125188695291804746273664719520877594103080002716204716437885631737502681157239448228517736957154781558316254899699/423847992785167635691798025732868758201476408654527740579259436528169254792708107390082891890404030666159494556650)+      (num-test (/ -53624051286117226406327700847140806598091981633622544805551583455315188018537/149060170957501829683988930330276188371 -49540630291338976658332195799658601133012561780540500265134312414843218811481/313014990314092319823049811442768272842) 16785131893926373429171158665038393627227592608630727377590747943991201054188961463248027101037470630205119769672154/7384534820569381535972144752572408048556227885764547207137140227958732266609348654686668662110083737942669493487451)+      (num-test (/ 2634758410586745842739353561704344884865889793873131750193619887157306355755/83106075320614705363810122092414199463231740446254118542567688658288107572919 10787649314660479714744029413883607304719873485501736976813666398631455642569/2439964488756696481271244145022481444549967702052558191280867337292105066432) 2142905652761565172685487282499186838096673751132490328620490049367034561455889328384026705096013173825469773464105722689198047146574263705663366838720/298839732158850477765824602476778580028064205733214070073086531571837859351705342746223206218407306637658483098569582239416197836311325170250187389329637)+      (num-test (/ -1907320079310938642409293211056905401889419041722087613680756850005726714712/10387378553621846874105702088597026076825105075730032753153301604042569998683 113647247724474559442709588703965365251731833799417671287796250968092484717057/58756890421232187224353930678527831208703723187770044891160428018937233424397) -37356065632762902117955690133395145368676268194116097031480521390942668514422835237280325034441435052929702455487858500299401976652159912902024146542888/393498994563785425899168694480259206994308562177080555315323154941891277193612821825931878224565302417504072329241812530787363937691786269618438039211977)+      (num-test (/ -54987418627898620923060954379316763081930842855917193391807940070173620336071/17370345837184638879794373707261631548922174314274224219546763452439685451597 107349939397731511365417710412808670916754334908520065561311453951414109180973/7800708635318451621630266369706695626474649690647985662113853436261704078874) -428940831324519456770429889832838610542119304716244392653623661175655561457214418178921042544524225772650432309479656622489393939407340321261255371264054/1864705572939408818246392762570376592749103793151936455808919833872532407312841098160841844995663367019074328670998871082130543124576872890789577304863881)+      (num-test (= -98781233389595723930250385525631360344437602649022271391716773162526352115087074898920261954897888235939429993829738630297052776667061779065100945771127020439712527398509771853491319737304616607041615012797134365574007368603232768089410097730646360760856052946465578073788924743642391638455649511108051053789425902013657106523269224045822294981391380222050223141347787674321888089837786284947870569165079491411110074602544203383038299901291952931113248943344436935596614205784436844912243069019367149526328612664067719765890897558075277707055756274228634652905751880612235340874976952880431555921814590049070979276358637989837532124647692152520447680373275200239544449293834424643702763974403094033892112967196087310232853165951285609426599617479356206218697586025251765476179158153123631158173662488102357611674821528467825910806391548770908013608889792001203039243914696463472490444573930050190716726220002151679336252008777326482398042427845860796285369622627679324605214987983884122808994422164327311297556122943400093231935477754959547620500784989043704825777186301417894825200797719289692636286337716705491307686644214213732116277102140558505945554566856673724837541141206267647285222293953181717113434757149921850120377706206012113994795124049471433490016083401216757825264766474891405185591236321448744678896448941259668731597494947127423662646933419809756274038044752395708014998820826196523041220918922611359697502638594907608648168849193813197790291360087857093790119162389573209640804111261616771827989939551840471235079945175327536638365874717775169210186608268924244639016270610098894971732892267642318266405837012482726627199088381027028630711279130575230815976484191675172279903609489448225149181063260231957171204855841611039996959582465138269247794842445177715476581512709861409446684911276158067098438009067149531119008707418601627426255891/2063950098473886055933596136103014753954685977787179797499441692283103642150668140884348149132839387663291870239435604463778573480782766958396423322880804442523056530013282118705429274303746421980903580754656364533869319744640130831962767797772323836293079599182477171562218297208495122660799328579852852969560730744211066545295945803939271680397511478811389399527913043145952054883289558914237172406636283114284363301999238526952309439259354223729114988806937903509692118585280437646676248013406270664905997291670857985754768850507766359973207600149782819306010561088246502918148146264806947375101624011387317921439210509902170092173796154464078297852707797984007992277904626058467143192149921546030028316990855470478894515952884526783686210401408859364838148201339959570732480920969000913791571631154267939054105878236201498477027265774680071188764947522112650857013491135901945605796776829525789886482760578142306057177990048751864852763036720112071475134369179525117161001517868525821398753039187062869247457336940152614866298628205010037695017885878296140891234142925514925051385440766473260338168038302226808098439763889250948602137806546736025439919604390464712793474019469457135856879584745805794574609707742445431851999335443724488636749987837445626810087003490329257105472274738811579817454656532496370562155449815456374456838912258383282154811001588175608617475540639254689723629881619252699580383612847920348111900440075645703960104081690968807839189109040568288972353424306876947127635585164905071821419089229871978994388197349499565628906992171901547121903117815637249359328193980583892566359962066242217169190169986105579733710057404319381685578470983838597020624234209884597110721892707818651210378187525863009879314177842634871978427592746452643603586344401223449546482306838947819060455178762434166799996220143825677025686435609179225302671777326568324855229172912876656233006785717920665743720753617646617017219230313226844735567400507490772935145894670445831971526014183234960075574401616682479457962912905141754252265169682318523572680657053374002911007741991220001444440319448034755483178790032581428679303588017268970 0) #f)++      ;; these come from Brad Lucier:++      (num-test (quotient 295147905149568077200 34359738366) 8589934591)+      (num-test (remainder 295147905149568077200 34359738366) 21754858894)+      (num-test (quotient 696898287454081973170944403677937368733396 1180591620717411303422) 590295810358705651711)+      (num-test (remainder 696898287454081973170944403677937368733396 1180591620717411303422) 314390899110894278354)++      ;; (map (lambda (x) (number->string x 2)) '(696898287454081973170944403677937368733396 1180591620717411303422 295147905149568077200 34359738366))+      ;; ("1111111111111111111111111111111111111111111111111111111111111111111100100 010000101100001100110110010000011011101000100001101001011011010100"+      ;; "1111111111111111111111111111111111111111111111111111111111111111111110"+      ;; "11111111111111111111111111111111100100010000101100001100110110010000"+      ;;  "11111111111111111111111111111111110")++      (letrec ((factorial (lambda (n i) (if (positive? n) (factorial (- n 1) (* i n)) i))))+	(num-test (/ (factorial 100 1) (factorial 99 1)) 100)+	(num-test (/ (factorial 1000 1) (factorial 999 1)) 1000)+	(num-test (factorial 100 1) 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000)+	(num-test (factorial 200 1) 788657867364790503552363213932185062295135977687173263294742533244359449963403342920304284011984623904177212138919638830257642790242637105061926624952829931113462857270763317237396988943922445621451664240254033291864131227428294853277524242407573903240321257405579568660226031904170324062351700858796178922222789623703897374720000000000000000000000000000000000000000000000000)++	(num-test (* (factorial 3 1) (factorial 5 1) (factorial 7 1)) (factorial 10 1)))++      (num-test (modulo (+ 2 (* 3 499127 495037 490459 468803)) (* 499127 495037 490459 468803)) 2)+      (num-test (let ((n 1)) (do ((i 2 (+ i 1))) ((= i 100)) (set! n (lcm n i))) n) 69720375229712477164533808935312303556800)+      (num-test (log 69720375229712477164533808935312303556800) 9.40453112293573922460049312446069272415E1)++      ))+++(let ((f= (lambda (a b) (< (magnitude (- a b)) 1.0e-15))))+  (let ((log2 0.69314718055994530941723212145817656807550013436025525412068000949339362196969471560586332699641868754200148102057068573368552023575813055703267075163507596193072757082837143519030703862389167347112335011536449795523912047517268157493206515552473413952588295045300709532636664265410423915781495204374043038550080194417064167151864471283996817178454695702627163106454615025720740248163777338963855069526066834113727387372292895649354702576265209885969320196505855476470330679365443254763274495125040606943814710468994650622016772042452452961268794654619316517468139267250410380254625965686914419287160829380317271436778265487756648508567407764845146443994046142260319309673540257444607030809608504748663852313818167675143866747664789088143714198549423151997354880375165861275352916610007105355824987941472950929311389715599820565439287170007218085761025236889213244971389320378439353088774825970171559107088236836275898425891853530243634214367061189236789192372314672321720534016492568727477823445353476481149418642386776774406069562657379600867076257199184734022651462837904883062033061144630073719489002743643965002580936519443041191150608094879306786515887090060520346842973619384128965255653968602219412292420757432175748909770675268711581705113700915894266547859596489065305846025866838294002283300538207400567705304678700184162404418833232798386349001563121889560650553151272199398332030751408426091479001265168243443893572472788205486271552741877243002489794540196187233980860831664811490930667519339312890431641370681397776498176974868903887789991296503619270710889264105230924783917373501229842420499568935992206602204654941510613918788574424557751020683703086661948089641218680779020818158858000168811597305618667619918739520076671921459223672060253959543654165531129517598994005600036651356756905124592682574394648316833262490180382424082423145230614096380570070255138770268178516306902551370323405380214501901537402950994226299577964742713815736380172987394070424217997226696297993931270694)++	(log3 1.09861228866810969139524523692252570464749055782274945173469433363749429321860896687361575481373208878797002906595786574236800422593051982105280187076727741060316276918338136717937369884436095990374257031679591152114559191775067134705494016677558022220317025294689756069010652150564286813803631737329857778236699165479213181814902003010382363012224865274819822599109745249089645805346700884596508574844411901885708764749486707961308582941160216612118400140982551439194876889367984943022557315353296853452952514592138764946859325627944165569415782723103551688661021184698904399430631382552857364668828249881368228006341439107868932514564375102044516275619349739821169415857405353617589009751222337977369696877543547951357129821770175812421223514058101632724655889372495649191852429607966842346470693772372526550820320783339280558928531468730951326064583091843974968222303257654675333118230196492752575991322178513533902374829643395025460742458249346668661218814365265654295427676105054777954229339733234011737431939745798470185595484940594783539438410106029307622922281312074893063445340252777326856271480016818715472439782071878034446780216178158419042820076721243255738014364178876826161041016818724240687908909929874208152183237528942752732534071002835750695062403965462752244308462588450859786253083224774538885068003488324340490083990058080943565282122370388702036804548600776214244088697259413584365999226211739670804950952792714363154640444623089158185367119608370304853520909672629582415040355995121355450332241748474100331981487832452569334704949937301656336660991903957122822844881674312150628569993874038819012744839564791034772885972119850649422796985791669956418551265041502191554719665856929726606523573293736830027830921776605387030462007661584946700226011756797518003934791763277844935142634968360037557857160700498181519184373438290934746660457750659273670121115370582496479847930404205823964753857850960626093389914706120130243108260518262958640076003059494321166880446106134684533980))++    (if (not (f= log3 (log 3.0)))+	(begin (display "(- (log 3.0) true-log-3) = ") (display (- log3 (log 3.0))) (newline)))+    (if (not (f= log2 (log 2.0)))+	(begin (display "(- (log 2.0) true-log-2) = ") (display (- log2 (log 2.0))) (newline)))+    (if (not (f= 3.0 (exp log3)))+	(begin (display "(- 3.0 (exp log3)) = ") (display (- 3.0 (exp log3))) (newline)))+    (if (not (f= 2.0 (exp log2)))+	(begin (display "(- 2.0 (exp log2)) = ") (display (- 2.0 (exp log2))) (newline))))++  (let ((sin1 8.414709848078965066525023216302989996225630607983710656727517099919104043912396689486397435430526959e-1)+	(cos1 5.403023058681397174009366074429766037323104206179222276700972553811003947744717645179518560871830894e-1)+	(tan1 1.557407724654902230506974807458360173087250772381520038383946605698861397151727289555099965202242984e0))++    (if (not (f= sin1 (sin 1)))+	(begin (display "(- (sin 1) true-sin-1) = ") (display (- sin1 (sin 1))) (newline)))+    (if (not (f= (asin sin1) 1.0))+	(begin (display "(- (asin (sin 1)) 1) = ") (display (- (asin sin1) 1)) (newline)))++    (if (not (f= cos1 (cos 1)))+	(begin (display "(- (cos 1) true-cos-1) = ") (display (- cos1 (cos 1))) (newline)))+    (if (not (f= (acos cos1) 1.0))+	(begin (display "(- (acos (cos 1)) 1) = ") (display (- (acos cos1) 1)) (newline)))++    (if (not (f= tan1 (tan 1)))+	(begin (display "(- (tan 1) true-tan-1) = ") (display (- tan1 (tan 1))) (newline)))+    (if (not (f= (atan tan1) 1.0))+	(begin (display "(- (atan (tan 1)) 1) = ") (display (- (atan tan1) 1)) (newline)))++    (set! sin1 -.3056143888882523)+    (set! cos1 -.9521553682590148)+    (set! tan1 .3209711346238149)++    (if (not (f= sin1 (sin 10000)))+	(begin (display "(- (sin 10000) true-sin-10000) = ") (display (- sin1 (sin 10000))) (newline)))++    (if (not (f= cos1 (cos 10000)))+	(begin (display "(- (cos 10000) true-cos-10000) = ") (display (- cos1 (cos 10000))) (newline)))++    (if (not (f= tan1 (tan 10000)))+	(begin (display "(- (tan 10000) true-tan-10000) = ") (display (- tan1 (tan 10000))) (newline)))+    )++  )++(let ((bes-i0 (lambda (x)			;I0(x)+		(if (< (abs x) 3.75)+		    (let* ((y (expt (/ x 3.75) 2)))+		      (+ 1.0+			 (* y (+ 3.5156229+				 (* y (+ 3.0899424+					 (* y (+ 1.2067492+						 (* y (+ 0.2659732+							 (* y (+ 0.360768e-1+								 (* y 0.45813e-2)))))))))))))+		    (let* ((ax (abs x))+			   (y (/ 3.75 ax)))+		      (* (/ (exp ax) (sqrt ax))+			 (+ 0.39894228+			    (* y (+ 0.1328592e-1+				    (* y (+ 0.225319e-2+					    (* y (+ -0.157565e-2+						    (* y (+ 0.916281e-2+							    (* y (+ -0.2057706e-1+								    (* y (+ 0.2635537e-1+									    (* y (+ -0.1647633e-1+										    (* y 0.392377e-2))))))))))))))))))))))+  (num-test (bes-i0 1.0) 1.266065877752009)+  (num-test (bes-i0 2.0) 2.279585302336067)+  (num-test (bes-i0 5.0) 27.23987182360445)+  (num-test (bes-i0 10.0) 2815.716628466254)+  (num-test (bes-i0 50.0) 2.932553783849336E+20) ;arprec+  (num-test (bes-i0 100.0) 1.073751707131074E+42))++(if (positive? 2147483648) ; check for int=32 bits+    (begin+      (num-test (< 1/123400000000 .000000000001) #f)+      (num-test (> 1/123400000000 .000000000001) #t)))++(num-test (exp (* our-pi (sqrt 163))) 262537412640768743.999999999999)+(if with-bigfloats+    (begin+      (num-test (exp (* our-pi (sqrt (bignum "163")))) 2.625374126407687439999999999992500725895E17)+      ;; H Cohen p 383+      (test (< (abs (- (expt (- (exp (* our-pi (sqrt (bignum "163")))) 744) 1/3) 6.4031999999999999999999999999939031735E5)) 1e-32) #t)+      ))++(num-test (+ 1/2 0.5) 1.0)+(num-test (- 1/2 0.5d0) 0.0d0)+(num-test (+ 0.5 -0.5 1/2) 0.5)+(test (= 1.0+1.0i 1.0+1.0i) #t)+(test (= 0.0+0.0i 0.0+0.0i) #t)+(test (= 1.0+1i 1.0+1.0i) #t)+(test (= 0.0 0.0+0.0i) #t)+(test (= 1+1i 1+1i) #t)+(test (= 0 0) #t)+(num-test (= 3 3) #t)+(num-test (= 3 5) #f)+(num-test (= 3 3 3 3) #t)+(num-test (= 3 3 5 3) #f)+(num-test (= 3 6 5 2) #f)+(num-test (= 3 2 3) #f)+(num-test (< 3 5) #t)+(num-test (<= 3 5) #t)+(num-test (< 3 -5) #f)+(num-test (<= 3 -5) #f)+(num-test (< 3 3) #f)+(num-test (<= 3 3) #t)+(num-test (< 0 3 4 6 7) #t)+(num-test (<= 0 3 4 6 7) #t)+(num-test (< 0 3 4 4 6) #f)+(num-test (<= 0 3 4 4 6) #t)+(num-test (> 4 3) #t)+(num-test (>= 4 3) #t)+(num-test (> 4 3 2 1 0) #t)+(num-test (>= 4 3 2 1 0) #t)+(num-test (> 4 3 3 2 0) #f)+(num-test (>= 4 3 3 2 0) #t)+(num-test (> 4 3 1 2 0) #f)+(num-test (>= 4 3 1 2 0) #f)+(num-test (= 3.0 3.0+0.0i) #t)+(num-test (= 3 3.0) #t)+(num-test (= 0.0 0.0) #t)+(num-test (= 5/2 2.5) #t)+(num-test (= 2.5 5/2) #t)+(num-test (= 5/2 2.5+0.0i) #t)+(num-test (= 2.5+0.0i 5/2) #t)+(num-test (= 5/2 2.5+1.0i) #f)+(num-test (= 2.5+1.0i 5/2) #f)+(num-test (> 0.0 0.0) #f)+(num-test (= 0 0.0) #t)+(num-test (= 5/2 2.5) #t)+(num-test (< 3.0 3) #f)+(num-test (< -5 -4 -2 0 4 5) #t)+(num-test (> 8 7 6 5 4) #t)+(num-test (<= 3.0 3) #t)+(num-test (<= 3 3) #t)+(num-test (<= 1 3 3 2 5) #f)+(num-test (<= 5/2 2.5) #t)+(num-test (>= -5 -4 -2 0 4 5) #f)+(num-test (+ 1 1/2 0.5 3.0+5.5i) 5.0+5.5i)+(num-test (- 3 0 3 5 -6) 1)+(num-test (- 0+6i 1/4 0.5 7) -7.75+6.0i)+(num-test (* 7 6 5 4 3 2 1) 5040)+(num-test (* 2 2 2.0 2) 16.0)+(num-test (/ -8) -1/8)+(num-test (/ 4 2) 2)++;; --------------------------------------------------------------------------------+;; miscellaneous numeric tests++(num-test (expt 0+1i 2) -1)+(num-test (acos 1.00001) 0.0+0.004472132228240686i)++(num-test (sin (/ our-pi 12)) (* (/ (sqrt 2) 4) (- (sqrt 3) 1)))+(num-test (cos (/ our-pi 12)) (* (/ (sqrt 2) 4) (+ (sqrt 3) 1)))+(num-test (tan (/ our-pi 12)) (- 2 (sqrt 3)))+(num-test (tan (* 1/4 (atan 4))) (* 2 (+ (cos (/ (* 6 our-pi) 17)) (cos (/ (* 10 our-pi) 17)))))++(num-test (sin (/ our-pi 6)) 1/2)+(num-test (cos (/ our-pi 6)) (/ (sqrt 3) 2))+(num-test (tan (/ our-pi 6)) (/ (sqrt 3) 3))++(num-test (sin (/ our-pi 5)) (/ (sqrt (- 10 (* 2 (sqrt 5)))) 4))+(num-test (cos (/ our-pi 5)) (/ (+ 1 (sqrt 5)) 4))+(num-test (tan (/ our-pi 5)) (sqrt (- 5 (* 2 (sqrt 5)))))++(num-test (* (sin (/ our-pi 7)) (sin (/ (* 2 our-pi) 7)) (sin (/ (* 3 our-pi) 7))) (/ (sqrt 7) 8))+(num-test (* (cos (/ our-pi 7)) (cos (/ (* 2 our-pi) 7)) (cos (/ (* 3 our-pi) 7))) 1/8)++(num-test (sin (/ our-pi 4)) (/ (sqrt 2) 2))+(num-test (cos (/ our-pi 4)) (/ (sqrt 2) 2))+(num-test (tan (/ our-pi 4)) 1)++(num-test (sin (/ our-pi 3)) (/ (sqrt 3) 2))+(num-test (cos (/ our-pi 3)) 1/2)+(num-test (tan (/ our-pi 3)) (sqrt 3))++(num-test (sin (/ our-pi 8)) (/ (sqrt (- 2 (sqrt 2))) 2))+(num-test (cos (/ our-pi 8)) (/ (sqrt (+ 2 (sqrt 2))) 2))+(num-test (tan (/ our-pi 8)) (- (sqrt 2) 1))++(num-test (* (sin (/ our-pi 9)) (sin (/ (* 2 our-pi) 9)) (sin (/ (* 4 our-pi) 9))) (/ (sqrt 3) 8))+(num-test (* (cos (/ our-pi 9)) (cos (/ (* 2 our-pi) 9)) (cos (/ (* 4 our-pi) 9))) 1/8)+(num-test (* (tan (/ our-pi 9)) (tan (/ (* 2 our-pi) 9)) (tan (/ (* 4 our-pi) 9))) (sqrt 3))++(num-test (sin (/ our-pi 10)) (/ (- (sqrt 5) 1) 4))+(num-test (cos (/ our-pi 10)) (/ (sqrt (+ 10 (* 2 (sqrt 5)))) 4))+(num-test (tan (/ our-pi 10)) (/ (sqrt (- 25 (* 10 (sqrt 5)))) 5))++(num-test (* (sin (/ our-pi 11)) (sin (/ (* 2 our-pi) 11)) (sin (/ (* 3 our-pi) 11)) (sin (/ (* 4 our-pi) 11)) (sin (/ (* 5 our-pi) 11))) (sqrt (/ 11 1024)))+(num-test (* (cos (/ our-pi 11)) (cos (/ (* 2 our-pi) 11)) (cos (/ (* 3 our-pi) 11)) (cos (/ (* 4 our-pi) 11)) (cos (/ (* 5 our-pi) 11))) 1/32)+(num-test (* (tan (/ our-pi 11)) (tan (/ (* 2 our-pi) 11)) (tan (/ (* 3 our-pi) 11)) (tan (/ (* 4 our-pi) 11)) (tan (/ (* 5 our-pi) 11))) (sqrt 11))++(num-test (sin (/ our-pi 12)) (/ (- (sqrt 6) (sqrt 2)) 4))+(num-test (cos (/ our-pi 12)) (/ (+ (sqrt 6) (sqrt 2)) 4))+(num-test (tan (/ our-pi 12)) (- 2 (sqrt 3)))++(num-test (sin (/ our-pi 15)) (/ (sqrt (- 7 (sqrt 5) (sqrt (- 30 (* 6 (sqrt 5)))))) 4))+(num-test (cos (/ our-pi 15)) (/ (+ (sqrt (+ 30 (* 6 (sqrt 5)))) (sqrt 5) -1) 8))+;(num-test (tan (/ our-pi 15)) (sqrt (- 23 (* 10 (sqrt 5)) (* 2 (sqrt (+ 255 (* 114 (sqrt 5))))))))++(num-test (sin (/ our-pi 16)) (/ (sqrt (- 2 (sqrt (+ 2 (sqrt 2))))) 2))+(num-test (cos (/ our-pi 16)) (/ (sqrt (+ 2 (sqrt (+ 2 (sqrt 2))))) 2))+(num-test (tan (/ our-pi 16)) (- (sqrt (+ 4 (* 2 (sqrt 2)))) (sqrt 2) 1))++(num-test (sin (/ our-pi 20)) (/ (sqrt (- 8 (* 2 (sqrt (+ 10 (* 2 (sqrt 5))))))) 4))+(num-test (cos (/ our-pi 20)) (/ (sqrt (+ 8 (* 2 (sqrt (+ 10 (* 2 (sqrt 5))))))) 4))+(num-test (tan (/ our-pi 20)) (+ 1 (sqrt 5) (- (sqrt (+ 5 (* 2 (sqrt 5)))))))++(num-test (sin (/ our-pi 24)) (/ (sqrt (- 2 (sqrt (+ 2 (sqrt 3))))) 2))+(num-test (cos (/ our-pi 24)) (/ (sqrt (+ 2 (sqrt (+ 2 (sqrt 3))))) 2))+(num-test (tan (/ our-pi 24)) (+ -2 (sqrt 2) (- (sqrt 3)) (sqrt 6)))++(num-test (sin (/ our-pi 30)) (/ (+ -1 (- (sqrt 5)) (sqrt (- 30 (* 6 (sqrt 5))))) 8))+(num-test (cos (/ our-pi 30)) (/ (sqrt (+ 7 (sqrt 5) (sqrt (* 6 (+ 5 (sqrt 5)))))) 4))+(num-test (tan (/ our-pi 30)) (sqrt (- 7 (* 2 (sqrt 5)) (* 2 (sqrt (- 15 (* 6 (sqrt 5))))))))++(num-test (sin (/ our-pi 32)) (/ (sqrt (- 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt 2))))))) 2))+(num-test (cos (/ our-pi 32))      (/ (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt 2))))))) 2))+(num-test (cos (/ our-pi 64))  (* 1/2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt 2)))))))))))+(num-test (cos (/ our-pi 128)) (* 1/2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt 2)))))))))))))++(num-test (/ our-pi 4) (+ (* 12 (atan (/ 18))) (* 8 (atan (/ 57))) (* -5 (atan (/ 239)))))+(num-test (sin (- (/ our-pi 2) (* 0+i (log (/ (+ 1 (sqrt 5)) 2))))) (/ (sqrt 5) 2))+(num-test (sqrt 0+i) (/ 1+i (sqrt 2)))+(num-test (expt 0+i 0+i) (exp (/ our-pi -2)))+(num-test (* (cos (/ our-pi 9)) (cos (/ (* 2 our-pi) 9)) (cos (/ (* 4 our-pi) 9))) 1/8)+(num-test (* (/ 4 (sqrt 522))+	     (log (* (expt (/ (+ 5 (sqrt 29)) (sqrt 2)) 3)+		     (+ (* 5 (sqrt 29)) (* 11 (sqrt 6)))+		     (expt (+ (sqrt (/ (+ 9 (* 3 (sqrt 6))) 4))+			      (sqrt (/ (+ 5 (* 3 (sqrt 6))) 4))) 6)))) ;31 digits+	  our-pi)+(if (or with-bignums with-64-bit-ints) (num-test (+ 2 (expt 276694819753963/226588 1/158)) our-pi)) ; 23 digits+;(num-test (expt 4297607660/144171 1/9) our-pi) ; 15 digits++(do ((k 1 (+ k 1)))+    ((= k 12))+  (num-test (+ (expt 11 k) (expt 24 k) (expt 65 k) (expt 90 k) (expt 129 k)+	       (expt 173 k) (expt 212 k) (expt 237 k) (expt 278 k) (expt 291 k) (expt 302 k))+	    (+ (expt 3 k) (expt 5 k) (expt 30 k) (expt 57 k) (expt 104 k) (expt 116 k)+	       (expt 186 k) (expt 198 k) (expt 245 k) (expt 272 k) (expt 297 k) (expt 299 k))))++(num-test (expt (- (expt 2 1/3) 1) 1/3) (+ (expt 1/9 1/3) (- (expt 2/9 1/3)) (expt 4/9 1/3)))+(num-test (sqrt (- (expt 5 1/3) (expt 4 1/3))) (/ (+ (expt 2 1/3) (expt 20 1/3) (- (expt 25 1/3))) 3))+(num-test (* (+ 1 3 5) (* 1 3 5)) 135)+(num-test (expt (+ (cos (/ (* 2 our-pi) 20)) (* 0+i (sin (/ (* 2 our-pi) 20)))) 20) 1.0)+(test (= (+ (expt 2421 3) (expt 19083 3))+	 (+ (expt 5436 3) (expt 18948 3))+	 (+ (expt 10200 3) (expt 18072 3))+	 (+ (expt 13322 3) (expt 16630 3)))+      #t)++(num-test (/ our-pi 4) (- (* 4 (atan (/ 1 5))) (atan (/ 1 239))))+(num-test (/ our-pi 4) (+ (atan 1/2) (atan 1/3)))+(num-test (/ our-pi 4) (- (* 2 (atan 1/2)) (atan 1/7)))+(num-test (/ our-pi 4) (+ (* 2 (atan 1/3)) (atan 1/7)))+(num-test (/ our-pi 4) (+ (* 5 (atan 1/7)) (* 2 (atan 3/79))))+(num-test (/ our-pi 2) (+ (* 2 (atan (/ (sqrt 2)))) (atan (/ (sqrt 8)))))+(num-test (* 768 (sqrt (- 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 1))))))))))))))))))) 3.1415904632368)++(num-test (expt (- (expt 2 1/3) 1) 1/3) (+ (expt 1/9 1/3) (- (expt 2/9 1/3)) (expt 4/9 1/3)))+(num-test (sqrt (- (expt 5 1/3) (expt 4 1/3))) (/ (+ (expt 2 1/3) (expt 20 1/3) (- (expt 25 1/3))) 3))+(num-test (+ (expt (+ 1/2 (/ (sqrt 69) 18)) 1/3) (/ (expt (+ 1/2 (/ (sqrt 69) 18)) -1/3) 3)) (* (/ (* 2 (sqrt 3)) 3) (cos (/ (acos (/ (* 3 (sqrt 3)) 2)) 3))))++(num-test (expt (/ (+ 1 (sqrt 5)) 2) 5) (/ (+ 11 (* 5 (sqrt 5))) 2))+(num-test (/ (+ (atan (/ 239)) (atan (/ 70)) (- (atan (/ 99)))) 2) (+ (atan (/ 408)) (atan (/ 577))))+(num-test (cos (log (+ our-pi 20))) -0.99999999924368)+(num-test (expt (+ our-pi 20) 0+i) -0.99999999924368-3.8892669402222e-05i)+(num-test (cos (* our-pi (cos (* our-pi (cos (log (+ our-pi 20))))))) -1.0) ; actually there's a 3.93216e-35 imag part+;(num-test (/ (+ (cos (/ 10)) (cosh (/ 10)) (* 2 (cos (/ (sqrt 2) 20)) (cosh (/ (sqrt 2) 20)))) 4) 1.0000000000002480)+(num-test (/ 53453 (log 53453)) 4910.0000012208)+(num-test (/ (* 2 3 4 5 6 7 8 9 10) (* 2 (expt (log 2) 11))) 102247563.00527)+(num-test (exp (* our-pi (sqrt 6))) 2197.9908695437)+(num-test (exp (* our-pi (sqrt 17))) 422150.99767568)+(num-test (exp (* our-pi (sqrt 18))) 614551.992885619)+(num-test (exp (* our-pi (sqrt 22))) 2508951.998257424)+(num-test (expt (/ (log (+ (expt 640320 3) 744)) our-pi) 2) 163.0) ; rest is 2.32167e-29+(num-test (exp (* our-pi (sqrt 719))) 3.8426143735395488914902942778058291929999e+36)+(if (or with-bignums with-64-bit-ints) (num-test (+ (expt 415280564497/348671682660 3) (expt 676702467503/348671682660 3)) 9))+(num-test (expt 25 6) (+ (expt 1 6) (expt 2 6) (expt 3 6) (expt 5 6) (expt 6 6) (expt 7 6) (expt 8 6) (expt 9 6)+			 (expt 10 6) (expt 12 6) (expt 13 6) (expt 15 6) (expt 16 6) (expt 17 6) (expt 18 6) (expt 23 6)))+(num-test (/ (- (sqrt 5) 1) 2) (/ (sin (* our-pi 1/5)) (sin (* our-pi 2/5))))+(num-test (let* ((N 3502)+		 (D (* 1/2 (+ 1071 (* 184 (sqrt 34)))))+		 (E (* 1/2 (+ 1553 (* 266 (sqrt 34)))))+		 (F (+ 429 (* 304 (sqrt 2))))+		 (G (* 1/2 (+ 627 (* 442 (sqrt 2)))))+		 (d1 (+ D (sqrt (- (* D D) 1))))+		 (e1 (+ E (sqrt (- (* E E) 1))))+		 (f1 (+ F (sqrt (- (* F F) 1))))+		 (g1 (+ G (sqrt (- (* G G) 1))))+		 (defg (* 2 d1 e1 f1 g1)))+	    (* (/ (sqrt N)) (- (log (expt defg -6)))))+	  our-pi)+(num-test (let* ((N 2737)+		 (D (* 1/2 (+ 621 (* 49 (sqrt 161)))))+		 (E (* 1/4 (+ 321 (* 25 (sqrt 161)))))+		 (F (* 1/4 (+ 393 (* 31 (sqrt 161)))))+		 (G (* 1/4 (+ 2529 (* 199 (sqrt 161)))))+		 (d (+ D (sqrt (- (* D D) 1))))+		 (e (+ E (sqrt (- (* E E) 1))))+		 (f (+ F (sqrt (- (* F F) 1))))+		 (g (+ G (sqrt (- (* G G) 1))))+		 (defg (* 2 d e f g)))+	    (* (/ (sqrt N)) (- (log (magnitude (* -1 (expt defg -6)))))))+	  our-pi) ; Newman and Shanks "On a Sequence Arising in Series for pi"++(num-test (let* ((an (sqrt 2)) ; Borwein and Borwein "AGM Mean and Fast Computation"+		 (bn 0)+		 (pn (+ 2 (sqrt 2))))+	    (do ((i 0 (+ i 1)))+		((= i 4) pn)+	      (let* ((sqa (sqrt an))+		     (an1 (* 1/2 (+ sqa (/ 1.0 sqa))))+		     (bn1 (* sqa (/ (+ bn 1) (+ bn an))))+		     (pn1 (* pn bn1 (/ (+ an1 1) (+ bn1 1)))))+		(set! pn pn1)+		(set! bn bn1)+		(set! an an1))))+	  our-pi)++(num-test (let ((pi2 0.0)+		(ais (vector 1 -3 -2 -3 1 0)))+	    (do ((i 1 (+ i 1))+		 (two 2 (* two 2)))+		((= i 30) (* 36 pi2))+	      (set! pi2 (+ pi2 (/ (vector-ref ais (modulo (- i 1) 6))+				  (* two i i))))))+	  (* our-pi our-pi))++(num-test (let ((log2 0.0)+		(ais (vector 2 -10 -7 -10 2 -1)))+	    (do ((i 1 (+ i 1))+		 (two 2 (* two 2)))+		((= i 30) (* 2 log2))+	      (set! log2 (+ log2 (/ (vector-ref ais (modulo (- i 1) 6))+				    (* two i i))))))+	  (* (log 2) (log 2)))++(num-test (+ (* 2 (atan (/ (sqrt 2)))) (atan (/ (sqrt 8)))) (/ our-pi 2))+(num-test (* 12 (/ 13591409 (expt 640320 3/2))) (/ our-pi))+(num-test (+ (* 48 (atan (/ 49))) (* 128 (atan (/ 57))) (* -20 (atan (/ 239))) (* 48 (atan (/ 110443)))) our-pi)+(num-test (+ (* 176 (atan (/ 57))) (* 28 (atan (/ 239))) (* -48 (atan (/ 682))) (* 96 (atan (/ 12943)))) our-pi)++(num-test (sqrt 13) (do ((i 1 (+ i 1)) (prod 1.0 (* prod (tan (/ (* i our-pi) 13))))) ((= i 7) prod)))+(num-test (let ((a (/ (* 2 our-pi) 13))) (* 8 (+ (cos a) (cos (* 5 a))) (+ (cos (* 2 a)) (cos (* 3 a))) (+ (cos (* 4 a)) (cos (* 6 a))))) -1.0)+(num-test (do ((i 1 (+ i 1)) (sum 0.0 (+ sum (cos (/ (* 2 our-pi i) 11))))) ((= i 6) sum)) -0.5)+(num-test (do ((i 1 (+ i 1)) (sum 0.0 (+ sum (expt (sin (/ (* our-pi i) (* 2 10))) 4)))) ((= i 11) sum)) 4.25)+(num-test (* 4 (+ (* 3 (atan 1/4)) (atan 1/20) (atan 1/1985))) our-pi)+(num-test (* 10 (asin (/ (- (sqrt 5) 1) 4))) our-pi)+(num-test (asin (/ (sqrt 2) 2)) (/ our-pi 4))+(num-test (asin (/ (sqrt 3) -2)) (/ our-pi -3))+(num-test (acos (/ (sqrt 2) 2)) (/ our-pi 4))+(num-test (acos (/ (sqrt 3) -2)) (- our-pi (/ our-pi 6)))+(num-test (atan (sqrt 3)) (/ our-pi 3))+(num-test (atan (/ -1 (sqrt 3))) (/ our-pi -6))+(num-test (+ (* (sin 0.1) (sin 0.1)) (* (cos 0.1) (cos 0.1))) 1.0)+(num-test (tan (/ our-pi 3)) (sqrt 3))+(num-test (tan (/ our-pi 4)) 1.0)+(num-test (tan (/ our-pi 6)) (/ (sqrt 3)))+(num-test (sin (/ our-pi 3)) (/ (sqrt 3) 2))+(num-test (cos (/ our-pi 3)) 1/2)++(let ((top 0))+  (let ((x-10 (lambda (n) (- (expt n 10) (* n n n n n n n n n n)))))+    (let ((happy #t)+	(lim (if with-bignums 100+		 (if with-64-bit-ints 74+		     8))))+      (do ((i 1 (+ i 1)))+	  ((or (not happy) (= i lim))) ; stop around 63 bits+	(let ((val (x-10 i)))+	  (if (not (= val 0))+	      (begin+		(set! top (- i 1))+		(set! happy #f)+		(display "(expt ") (display i) (display " 10) = ") (display (expt i 10))+		(display " but (* ") (display i) (display "... 10x) = ")+		(display (* i i i i i i i i i i)) (newline)))))))+  (if (> top 63)+      (num-test (+ (expt 1 10) (expt 2 10) (expt 4 10) (expt 5 10) (expt 6 10) (expt 8 10) (expt 12 10)+		   (expt 15 10) (expt 16 10) (expt 17 10) (expt 20 10) (expt 21 10) (expt 25 10) (expt 26 10)+		   (expt 27 10) (expt 28 10) (expt 30 10) (expt 36 10) (expt 37 10) (expt 38 10) (expt 40 10)+		   (expt 51 10) (expt 62 10))+		(expt 63 10))))++(num-test (expt 3 9) (* 3 3 3 3 3 3 3 3 3))++(num-test (+ (expt 510 3) (expt 580 3)) (+ (expt 300 3) (expt 670 3)))+(num-test (+ (expt 2230 4) (expt 3196 4) (expt 5620 4) (expt 6995 4)) (expt 7703 4))+(num-test (+ (expt 2 5) (expt 298 5) (expt 351 5) (expt 474 5) (expt 500 5)) (expt 575 5))++;;; some of the tests in this section are thanks to Bill Gosper+(num-test (expt (- (expt 3 3/5) (expt 2 1/5)) 1/3)+	  (/ (+ (- (* (expt 2 1/5) (expt 3 3/5))) (* (expt 2 3/5) (expt 3 2/5)) (expt 3 1/5) (expt 2 2/5)) (expt 5 2/3)))++(num-test (sqrt (- 2 (expt 2 1/7)))+	  (/ (* (expt 2 1/14) (+ (- (expt 2 6/7)) (expt 2 5/7) (expt 2 3/7) (* 2 (expt 2 1/7)) -1)) (sqrt 7)))++(num-test (sqrt (- 127 (* 4 (sqrt 6) (expt 7 1/4))))+	  (+ (/ (* (sqrt 3) (expt 7 3/4)) (sqrt 2)) (* 2 (sqrt 7)) (/ (* 3 (sqrt 3) (expt 7 1/4)) (sqrt 2)) -6))++(num-test (sqrt (- (expt 4 1/5) (expt 3 1/5)))+	  (/ (+ (* (- (expt 2 3/5)) (expt 3 4/5)) (expt 3 3/5) (* 2 (expt 2 2/5) (expt 3 2/5)) (* (- (expt 2 4/5)) (expt 3 1/5)) (expt 2 1/5)) 5))++(num-test (sqrt (- 161 (* 12 (expt 5 1/4)))) (+ (* 2 (expt 5 3/4)) (- (* 3 (sqrt 5))) (* 4 (sqrt (sqrt 5))) 6))++(num-test (* (sqrt 2) (sqrt (- 31 (* 4 (sqrt (sqrt 3)) (sqrt (sqrt 5))))))+	  (+ (* (expt 3 1/4) (expt 5 3/4)) (- (* 2 (sqrt 5))) (* (expt 3 3/4) (expt 5 1/4)) (* 2 (sqrt 3))))++(num-test (/ (sqrt (* 7 (- 2 (expt 2 1/7)))) (expt 2 1/14))+	  (+ -1 (* 2 (expt 2 1/7)) (expt 2 3/7) (expt 2 5/7) (- (expt 2 6/7))))++(num-test (sqrt (- (expt 4 2/3) (* (sqrt 3) (expt 5 1/6))))+	  (+ (/ (expt 5 1/3) (sqrt 6)) (- (/ (expt 5 5/6) (* 3 (sqrt 2)))) (/ (* (expt 2 1/6) (sqrt 5)) 3)+	     (- (/ (* (expt 2 5/6) (expt 5 1/6)) 3)) (/ (expt 2 1/6) (sqrt 3))))++(num-test (* 2  0+i (log (/ 1-i 1+i))) our-pi)+++;;; --------------------------------------------------------------------------------+;;; a selection from Eric Weisstein MathWorld MachinFormulas+(let ((formulas '(+		  (1/4  (1 1))++		  (1/4  (1 2) (1 3))+		  (1/4  (2 2) (-1 7))+		  (1/4  (2 3) (1 7))+		  (1/4  (4 5) (-1 239))++		  (1/4  (1 2) (1 4) (1 13))+		  (1/4  (1 2) (1 5) (1 8))+		  (1/4  (1 2) (2 6) (-1 117))+		  (1/4  (1 3) (2 4) (-1 38))+		  (1/4  (2 2) (-2 12) (1 41))+		  (1/4  (2 2) (-2 14) (1 1393))+		  (1/4  (2 2) (-2 17) (-1 41))+		  (1/4  (2 2) (-1 5) (1 18))+		  (1/4  (2 2) (-1 6) (1 43))+		  (1/4  (2 2) (-1 8) (-1 57))+		  (1/4  (2 2) (-1 9) (-1 32))+		  (1/4  (2 2) (-1 12) (-1 17))+		  (1/4  (2 3) (1 5) (-1 18))+		  (1/4  (2 3) (1 6) (-1 43))+		  (1/4  (2 3) (1 8) (1 57))+		  (1/4  (2 3) (1 9) (1 32))+		  (1/4  (2 3) (1 12) (1 17))+		  (1/4  (2 3) (2 12) (-1 41))+		  (1/4  (2 3) (2 14) (-1 1393))+		  (1/4  (2 3) (2 17) (1 41))+		  (1/4  (2 4) (1 7) (2 13))+		  (1/4  (2 5) (1 7) (2 8))+		  (1/4  (2 5) (3 7) (-2 57))+		  (1/4  (2 5) (3 8) (1 57))+		  (1/4  (2 6) (3 7) (2 68))+		  (1/4  (2 7) (4 8) (1 239))+		  (1/4  (3 3) (-2 11) (1 682))+		  (1/4  (3 3) (-2 13) (-1 38))+		  (1/4  (3 3) (-1 5) (1 57))+		  (1/4  (3 3) (-1 6) (-1 68))+		  (1/4  (3 3) (-1 8) (-1 18))+		  (1/4  (3 4) (1 13) (-1 38))+		  (1/4  (3 4) (1 20) (1 1985))+		  (1/4  (3 5) (2 8) (-1 18))+		  (1/4  (3 7) (2 8) (2 18))+		  (1/4  (3 7) (4 11) (-2 682))+		  (1/4  (3 7) (4 13) (2 38))+		  (1/4  (4 3) (-4 8) (-1 239))+		  (1/4  (4 4) (-1 7) (-2 38))+		  (1/4  (4 4) (-4 21) (-1 239))+		  (1/4  (4 5) (-2 408) (1 1393))+		  (1/4  (4 5) (-2 478) (1 54608393))+		  (1/4  (4 5) (-2 577) (-1 1393))+		  (1/4  (4 5) (-1 41) (2 99))+		  (1/4  (4 5) (-1 70) (1 99))+		  (1/4  (4 5) (-1 213) (1 1958))+		  (1/4  (4 5) (-1 226) (1 4155))+		  (1/4  (4 5) (-1 237) (1 28322))+		  (1/4  (4 5) (-1 238) (1 56883))+		  (1/4  (4 5) (-1 240) (-1 57361))+		  (1/4  (4 5) (-1 241) (-1 28800))+		  (1/4  (4 5) (-1 252) (-1 4633))+		  (1/4  (4 5) (-1 265) (-1 2436))+		  (1/4  (4 5) (-1 408) (-1 577))+		  (1/4  (4 5) (1 41) (-2 70))+		  (1/4  (4 6) (1 7) (-2 117))+		  (1/4  (4 6) (4 31) (-1 239))+		  (1/4  (4 7) (4 18) (-1 239))+		  (1/4  (5 5) (-3 18) (-2 57))+		  (1/4  (5 6) (-1 43) (-2 117))+		  (1/4  (5 6) (-1 68) (-3 117))++		  (1/4  (-29 239) (256 378) (200 829) (244 882) (-388 993) (324 2943) (-144 18543))+		  (1/4  (-4 307) (394 577) (163 1393) (-12 12238) (-24 58911) (-68 1999509) (-68 11653127))+		  (1/4  (7 10) (2 50) (4 100) (1 682) (4 1000) (3 1303) (-4 90109))+		  (1/4  (7 10) (8 100) (1 682) (4 1000) (3 1303) (-4 90109) (-2 500150))+		  (1/4  (12 18) (8 307) (46 577) (19 1393) (-8 2827807) (-16 11653127) (-8 16480443))+		  (1/4  (17 23) (11 882) (24 931) (10 1143) (-2 34208) (-8 44179) (-13 485298))+		  (1/4  (29 268) (198 378) (142 829) (186 882) (-301 993) (237 2943) (-115 18543))+		  (1/4  (43 57) (22 746) (-2 1568) (1 4662) (28 12943) (14 32807) (11 157318))+		  (1/4  (44 515) (95 538) (127 682) (176 782) (95 1068) (88 4030) (17 12943))+		  (1/4  (76 682) (190 746) (271 882) (315 2917) (-132 9466) (295 12943) (-95 19703))+		  (1/4  (83 107) (17 4443) (68 11343) (-5 113568) (-34 595667) (-5 23481902) (5 168925949733307))+		  (1/4  (83 107) (17 4443) (68 11343) (-5 111693) (-34 595667) (5 9503057) (5 232633636378307))+		  (1/4  (95 418) (171 682) (176 882) (315 2917) (-132 9466) (105 12943) (95 16693))+		  (1/4  (100 437) (254 577) (127 1393) (44 2072) (24 2943) (-12 16432) (-100 28800))+		  (1/4  (122 162) (22 568) (-29 1432) (83 5087) (-7 6107) (-10 27493) (-29 30027))+		  (1/4  (122 183) (108 1177) (29 1393) (22 4443) (54 5087) (-64 7078) (-10 27493))+		  (1/4  (122 418) (237 557) (29 1068) (144 3458) (-61 5087) (122 16452) (105 27493))+		  (1/4  (127 239) (100 343) (-56 2072) (-76 2943) (100 7983) (-12 16432) (100 28322))+		  (1/4  (127 239) (212 1068) (-144 2072) (188 2309) (-200 6105) (376 6807) (288 13637))+		  (1/4  (127 239) (400 1068) (44 2072) (-376 2943) (-200 6105) (100 13637) (188 16432))+		  (1/4  (127 682) (227 788) (227 843) (44 2072) (51 2943) (-27 12943) (88 16432))+		  (1/4  (127 682) (454 818) (271 1303) (-403 2943) (-44 6118) (-254 12943) (-183 3014557))+		  (1/4  (171 239) (68 788) (-56 1744) (36 2943) (44 6613) (-112 13603) (144 28322))+		  (1/4  (171 239) (68 993) (-20 2943) (56 4443) (-44 13252) (-112 17088) (156 28322))+		  (1/4  (171 239) (124 993) (-56 1252) (56 2855) (-76 2943) (-100 13252) (100 28322))+		  (1/4  (171 682) (183 788) (227 843) (95 2943) (44 6613) (-115 12943) (88 28322))+		  (1/4  (171 682) (271 882) (95 993) (315 2917) (95 2943) (-227 9466) (200 12943))+		  (1/4  (171 682) (366 1068) (139 2436) (271 5357) (315 5507) (227 6962) (-71 12943))+		  (1/4  (176 463) (32 682) (241 798) (241 3141) (-58 5357) (-122 12943) (-51 390112))+		  (1/4  (176 557) (244 757) (90 1068) (61 1393) (22 3458) (122 11018) (44 27493))+		  (1/4  (179 239) (44 5357) (80 5507) (156 12943) (8 17923) (48 32807) (-40 157318))+		  (1/4  (179 239) (120 4662) (4 5357) (116 12943) (-32 17923) (88 32807) (40 390112))+		  (1/4  (179 233) (120 4662) (4 5357) (-63 12943) (-32 17923) (-91 32807) (40 390112))+		  (1/4  (183 239) (32 682) (-88 1143) (132 2673) (68 12943) (-132 34208) (-44 44179))+		  (1/4  (183 239) (32 1023) (-68 5832) (12 111693) (-100 6826318) (-12 9503057) (-12 232633636378307))+		  (1/4  (183 239) (32 1023) (-68 5832) (12 112068) (-100 6826318) (-12 13288972) (-12 49541920807))+		  (1/4  (183 239) (32 1023) (-68 5832) (12 113568) (-100 6826318) (12 23476958) (-12 111432033307))+		  (1/4  (183 239) (32 1023) (-68 5832) (12 113568) (-100 6826318) (12 23481005) (-12 612463280182))+		  (1/4  (183 239) (32 1023) (-68 5832) (12 113568) (-100 6826318) (12 23463218) (-12 29483238307))+		  (1/4  (183 239) (32 1023) (-68 5832) (12 113568) (-100 6826318) (12 23481902) (-12 168925949733307))+		  (1/4  (183 294) (44 905) (115 1292) (88 3957) (-32 12238) (68 12943) (51 114483))+		  (1/4  (183 307) (32 682) (95 1143) (132 2673) (68 12943) (51 34208) (139 44179))+		  (1/4  (183 378) (115 557) (29 1068) (122 2943) (144 3458) (-244 14318) (44 27493))+		  (1/4  (183 378) (144 606) (86 1772) (122 2943) (-115 6118) (-71 14318) (-71 27493))+		  (1/4  (183 378) (144 905) (115 1057) (151 2943) (-29 3957) (-100 14318) (-100 27493))+		  (1/4  (183 378) (215 682) (44 1432) (51 2943) (-315 5257) (-71 12943) (44 13043))+		  (1/4  (183 538) (215 682) (51 1068) (44 2309) (88 2673) (88 3039) (17 12943))+		  (1/4  (183 568) (215 682) (278 1636) (-139 6107) (112 12943) (-234 19703) (132 32807))+		  (1/4  (186 307) (41 378) (27 829) (-13 1713) (122 2943) (42 12238) (71 58911))+		  (1/4  (190 577) (76 682) (176 882) (95 1393) (220 2917) (-132 9466) (200 12943))+		  (1/4  (198 577) (200 606) (127 1393) (-20 2943) (112 3740) (-44 6118) (56 11018))+		  (1/4  (199 233) (-60 1393) (-76 5357) (-43 12943) (-152 17923) (9 32807) (120 1049433))+		  (1/4  (215 233) (-216 1568) (12 4662) (-64 6898) (113 12943) (-51 32807) (-32 534568))+		  (1/4  (215 239) (-248 1568) (76 4662) (296 12943) (132 32807) (64 83270) (32 1493208))++		  (1/4  (160 200) (-1 239) (-4 515) (-8 4030) (-16 50105) (-16 62575) (-32 500150) (-80 4000300))+		  (1/4  (215 682) (644 1568) (227 5767) (366 6898) (-532 12943)  (227 24331) (-51 32807) (183 534568))+		  (1/4  (295 4193) (3767 5507) (593 18543) (-1228 39307) (2068 55603) (-962 211050) (-708 390112) (-1587 2867938))+		  (1/4  (537 1393) (1118 5357) (952 12943) (3032 17923) (-1384 32807) (-1194 157318) (-1870 1049433) (796 21638297))+		  (1/4  (581 1023) (183 4443) (664 5832) (732 11343) (-171 110443) (-366 595667) (171 4841182) (83 6826318))+		  (1/4  (581 1252) (764 4853) (1030 5832) (-398 58898) (-764 97232) (195 110443) (537 4841182) (266 6826318))+		  (1/4  (581 1252) (764 5593) (1030 5827) (366 58898) (195 110443) (537 4841182) (-764 6826318) (-1030 1561886607))+		  (1/4  (581 1252) (764 5618) (1030 5832) (366 58898) (195 110443) (764 1256859) (537 4841182) (266 6826318))+		  (1/4  (581 1252) (764 5593) (1030 5832) (366 69051) (195 110443) (366 369957) (171 4841182) (266 6826318))+		  (1/4  (581 1252) (764 5593) (1030 11557) (1030 11773) (366 58898) (195 110443) (537 4841182) (266 6826318))+		  (1/4  (581 1252) (1030 5507) (764 5593) (366 58898) (-1030 98821) (195 110443) (537 4841182) (266 6826318))+		  (1/4  (764 1068) (298 5832) (581 26307) (-183 78813) (-171 110443) (215 314982) (171 4841182) (83 6826318))+		  (1/4  (808 1477) (1308 2436) (-1635 5283) (-417 5507) (593 6962) (632 390112) (-561 2733307) (266 23747457))+		  (1/4  (1074 1568) (840 5357) (-779 12943) (625 17923) (-1106 32807) (657 198505) (-259 390112) (657 24185182))+		  (1/4  (1074 4246) (1257 5357) (1731 6107) (295 12943) (625 19703) (-481 32807) (-1042 39307) (398 390112))+		  (1/4  (1484 4693) (2097 4831) (366 18543) (1189 49457) (-227 123093) (-879 128643) (481 27872057) (-266 31895807))+		  (1/4  (1738 4193) (1699 4246) (144 6687) (-1443 32318) (-266 39307) (337 235318) (-227 390112) (-481 2282363))+		  (1/4  (2363 4557) (1218 5507) (1850 18543) (-266 39307) (-2658 49457) (1257 123093) (-1484 390112) (481 27872057))++		  (1/4  (-31739656 201229582) (38819595 231373438) (110380200 284862638) (122355452 312322593) (-134055653 496651953) (5301720 509435077) (63861353 543644509) (68679613 934981432) (130575087 1845907403) (-32548340 2189376182) (-71616726 2539791558) (98822066 4732978887) (119051879 7804016832) (48482068 9233371207) (-99832073 41734246913) (-99143267 66492889557) (-25601898 73276714818) (-79323772 579766497643))+		  (1/4  (16106659 103224943) (48702787 196047454) (18674705 199762118) (8786524 201229582) (-16824928 244653118) (-9582339 261221282) (33092716 266981905) (50379909 270684757) (24748365 909140573) (31675677 1770638022) (1576733 2189376182) (-4742586 2701984943) (-34586991 5475957057) (10864048 14033378718) (-13079131 18986886768) (22266057 25220059245) (17791526 34840696582) (-12650410 193100304493))+		  (1/4  (154370374 124845505) (-90941691 193788912) (64454803 196047454) (-82996236 201229582) (109691394 244653118) (-15562779 462333568) (6518215 553806443) (-169821027 1134156517) (-244516782 1222853176) (100563577 2154947322) (-47118309 2189376182) (-35713908 4006581229) (60656646 5475957057) (-4001125 18986886768) (-68810571 37093513413) (-20888958 100083704193) (16990004 250645741818) (-62587614 5142102426318))+		  (1/4  (-119375678 193788912) (61799442 201229582) (-19991865 272525023) (20438744 321390012) (88331413 331905423) (103467976 343841922) (88464202 378026293) (138122046 600536193) (44232101 653023206) (115219328 846974497) (-81969855 1033937133) (-63521464 1454097393) (-118694678 2189376182) (117332455 2322170807) (-26482877 6884660047) (-18702052 29546599818) (7415308 250645741818) (166718050 512223806648))+		  (1/4  (-85386445 101859193) (4420755 112519818) (43555859 193788912) (15003774 194195097) (108912996 201229582) (61225652 231373438) (16824928 262992072) (73421340 284862638) (123118321 1057929843) (-10593254 2189376182) (40618746 2539791558) (73863237 2616939213) (-30947737 14811180432) (58354910 41734246913) (19908612 66492889557) (5345839 73276714818) (-90280386 120563046313) (61328880 579766497643))+		  (1/4  (-75143577 193788912) (17567341 201229582) (64670845 321390012) (88331413 331905423) (103467976 343841922) (68472337 372954564) (49657844 600536193) (115219328 846974497) (24240236 1012047353) (-81969855 1033937133) (24942738 1454097393) (-118694678 2189376182) (73100354 2322170807) (-88464202 4549886677) (-26482877 6884660047) (-18702052 29546599818) (7415308 250645741818) (34021747 512223806648))+		  (1/4  (-9761163 108220762) (13910116 144252856) (12032992 157157432) (55358773 167207057) (6697039 168623905) (-28651627 193788912) (1825738 201229582) (67020547 215266693) (-1575761 216260702) (45238607 284862638) (10024910 934981432) (20338355 2189376182) (-450675 4832545807) (-27703534 4935283579) (-25688998 7804016832) (-58020549 18986886768) (-28330426 120563046313) (-20446387 69971515635443))+		  (1/4  (-9719634 193788912) (17567341 201229582) (70452403 204415882) (12270610 244653118) (18184957 313467682) (44573394 426775692) (3945487 600536193) (33076315 892642643) (62731148 919331002) (18631836 1012047353) (58964485 1454097393) (32836016 2032914193) (-3430506 2189376182) (-19017973 5475957057) (60427493 6884660047) (-9222216 16406542707) (25467476 22827763470) (-8020348 29546599818))+		  (1/4  (-7707046 100457781) (102467557 168623905) (-37989469 201229582) (-19264491 216904033) (74130709 231373438) (9117882 262992072) (61898132 284862638) (-26046661 314198789) (20721724 327012132) (-6893934 1111885489) (-40541219 1183092682) (-40255386 2189376182) (82347539 2296713307) (31354293 12988236682) (27538131 18221678207) (-68243977 41734246913) (12646329 73276714818) (-45544955 193100304493))+		  (1/4  (-6829481 193788912) (49141523 227661182) (80561462 231373438) (12671730 244653118) (29897458 284862638) (-73630486 355671793) (58626712 398795108) (62468573 509435077) (24454447 543644509) (-19908612 657922943) (28905471 1057929843) (35237534 1845907403) (26678061 2189376182) (-117350972 4866438247) (-61240161 5475957057) (23212961 9075730623) (-20886351 9233371207) (-65421299 60402345333))+		  (1/4  (-6249813 193788912) (56771042 201229582) (28076746 231373438) (-19468648 262992072) (30639871 266981905) (19911270 284862638) (130457979 532399876) (96830507 672554667) (-25661007 1057929843) (13459441 1111885489) (-45480502 1183092682) (5693286 1770638022) (-21577251 2170952313) (-67486342 2189376182) (2925523 2701984943) (27538131 18221678207) (-7198038 193100304493) (36293576 307026452057))+		  (1/4  (-60656646 143846482) (38271221 144309885) (138138220 157565949) (35739707 193788912) (-42115413 201229582) (-49270023 231373438) (94471578 278263393) (-68287996 398795108) (87062724 462333568) (-21411533 593897943) (-13257608 1057929843) (-106971336 1206519637) (34427295 2189376182) (166256019 4006581229) (111296506 4832545807) (58999250 18986886768) (100563577 373139596292) (100694535 5142102426318))+		  (1/4  (-5621437 103224943) (81294931 115811807) (23943179 193788912) (33709426 199762118) (-2077524 201229582) (-31310435 261221282) (4978864 266981905) (-15147806 282218776) (-1688365 909140573) (20050974 1047764193) (-18279356 1770638022) (-1777511 2189376182) (19200593 2701984943) (-21507860 5475957057) (30332696 34840696582) (26011854 48312162432) (7938525 193100304493) (9186926 250645741818))+		  (1/4  (-5497394 101057042) (65180148 144309885) (53832596 193788912) (48554212 201229582) (52075350 447821668) (-105963621 539290393) (-8554603 2060228568) (7313117 2112819717) (-57858314 2189376182) (-3891660 2572149874) (7518287 3261365450) (-19908612 4044044333) (12568802 4866438247) (-83992146 5494891577) (-68408704 9233371207) (6071631 20336334426) (26993421 45384196187) (-20080982 71617196968))+		  (1/4  (-52897653 193788912) (17567341 201229582) (88637360 214539684) (16824928 329492391) (87365276 426775692) (89084239 434859193) (64670845 478798161) (-60879340 600536193) (51820567 706366957) (25661007 1033937133) (-7721255 1119211358) (-11874055 1454097393) (-46608525 2189376182) (-7415308 2674664693) (38361126 6884660047) (-54246761 29546599818) (29095538 42354792693) (55834766 512223806648))+		  (1/4  (-51730315 193788912) (50509639 201229582) (-2925523 224497457) (34338149 231373438) (56651725 266981905) (88974774 284862638) (6009207 367829623) (44851350 532399876) (77361859 672554667) (-36293576 1047764193) (19819495 1057929843) (-26011854 1695830317) (-10691678 1770638022) (-51609424 2170952313) (-31380534 2189376182) (21276728 18221678207) (9186926 250645741818) (-16384964 4125516427007))+		  (1/4  (-50738726 193788912) (95363435 196047454) (69453144 225823278) (69510447 227661182) (22432893 244653118) (-32772323 266981905) (-17689880 284862638) (-25151223 657922943) (45597610 672554667) (-15126313 934981432) (76492809 1770638022) (84039104 2189376182) (-104948381 4832545807) (-85627080 5475957057) (-40656362 5684017953) (-5242611 7804016832) (-197723175 18986886768) (42533486 25220059245))+		  (1/4  (-28765620 120868561) (44046442 160007778) (67427201 167207057) (37325093 191800592) (70499068 270090468) (-57543499 289008998) (17519675 361632045) (-4374603 747769833) (-52576452 2674664693) (-7666625 2971354082) (83775059 3069221943) (44136928 4549886677) (-7704241 4832545807) (109211041 4935283579) (43406332 5271470807) (-4967047 8815417307) (24253605 14033378718) (72936300 69392205693))+		  (1/4  (-19504206 100457781) (24986381 107793452) (26438497 121042733) (40255386 160007778) (28377269 168623905) (23815821 314198789) (-2374068 361632045) (25057307 672554667) (-9351768 773302059) (11008080 1479406293) (574237 2296713307) (-3020779 2701984943) (17648998 4038832337) (-9422284 12139595709) (27538131 12957904393) (20007517 12988236682) (23727647 18710140581) (-4711783 120563046313))+		  (1/4  (-42543389 193788912) (74917830 201229582) (28076746 231373438) (16824928 262992072) (30639871 266981905) (74351634 284862638) (21577251 640348873) (78683719 672554667) (-25661007 1057929843) (-4687347 1111885489) (-27333714 1183092682) (5693286 1770638022) (8531273 2189376182) (-76017615 2674664693) (2925523 2701984943) (-39724039 4309606382) (27538131 18221678207) (68819577 193100304493))+		  (1/4  (-41665661 138884933) (61863206 168623905) (-24923249 201229582) (1860735 231373438) (152322833 244685917) (16824928 262992072) (45004160 284862638) (6816407 306903943) (-25731933 2189376182) (-2937113 2539791558) (-80514719 4100676432) (-30142453 5157407572) (88702086 17249711432) (10077565 18986886768) (-34456033 41734246913) (19908612 66492889557) (66436029 73276714818) (-10644159 579766497643))+		  (1/4  (-39775463 119742462) (20197545 168623905) (93476735 201229582) (1860735 231373438) (58490589 262992072) (86669821 284862638) (-4706801 437768635) (41665661 1258140850) (-35068662 1396533757) (-56669435 1624720807) (61079955 2189376182) (69090409 2539791558) (-73253757 3712239557) (42278290 41734246913) (-46591870 52254287493) (59684075 66492889557) (-12188492 73276714818) (-15350960 579766497643))+		  (1/4  (-3944315 103224943) (48706548 136899993) (18362609 186695067) (14767496 193788912) (-25501467 201229582) (-15136563 244653118) (29933522 261221282) (30079929 266981905) (117267526 480808760) (-30911261 1012047353) (40320881 1770638022) (53656250 2189376182) (20888958 2701984943) (-63283169 5475957057) (-32599626 37093513413) (-43463674 43917943025) (-64759288 193100304493) (21735578 5142102426318))+		  (1/4  (-3908713 100351813) (64565359 115453918) (26685223 201229582) (-8153925 214539684) (96935488 385231007) (15853328 459637173) (-19281720 539290393) (-48760063 883337939) (62688235 909140573) (-67639108 1282794079) (-5891323 1304967682) (-10583319 2189376182) (34749426 2572149874) (-55437542 3508373380) (-90085473 4427365493) (-35842901 5494891577) (-35317011 18986886768) (-22926686 45119420807))+		  (1/4  (-36515828 110175338) (5722932 193788912) (17567341 201229582) (83804410 203283777) (85603231 244653118) (79850836 273202197) (68353757 345311195) (-87424385 549758463) (-63893191 1454097393) (-111387800 1459933093) (69893108 1725455932) (-61767440 2189376182) (-19017973 5475957057) (102875038 6930719818) (47464799 16406542707) (21866697 29546599818) (-15003774 37093513413) (-46223313 5142102426318))+		  (1/4  (-36293576 132095062) (57870827 168623905) (-42543389 193788912) (35193791 201229582) (-8216830 231373438) (53118504 262992072) (30639871 266981905) (128791998 284862638) (60536931 672554667) (-25661007 1057929843) (49753017 1111885489) (-45480502 1183092682) (-30600290 1770638022) (-9615515 2189376182) (-69661629 2701984943) (63831707 18221678207) (29095538 193100304493) (-36293576 5142102426318))+		  (1/4  (-35775309 107793452) (-7119735 111530944) (127376638 115811807) (66649464 193788912) (-21949674 201229582) (-43413311 244653118) (-45561148 261221282) (49941099 266981905) (-9186926 396134107) (-886843 1770638022) (73138594 2189376182) (-39140796 2296713307) (61906878 2701984943) (-3565489 5458840213) (-21696619 5475957057) (-7498561 55237647473) (75356069 193100304493) (-1877124 579766497643))+		  (1/4  (-35368492 144309885) (-13432309 201229582) (124560353 231373438) (-8671679 284862638) (3303573 398795108) (141414744 509435077) (203277950 543644509) (-124589816 1845907403) (-32548340 2189376182) (-53309379 2539791558) (115883211 4732978887) (68679613 9075730623) (-1890198 9233371207) (19219806 41734246913) (19908612 66492889557) (60138860 73276714818) (-53675839 102428655030) (-10644159 579766497643))+		  (1/4  (-35368492 110911039) (50372266 113561432) (3303573 168623905) (-16735882 201229582) (74188087 231373438) (30000386 284862638) (106046252 509435077) (99229845 543644509) (-89221324 1845907403) (-67916832 2189376182) (-53309379 2539791558) (-15003774 3658567505) (65510945 4732978887) (-16893972 9233371207) (-19452259 41734246913) (-30463654 66492889557) (75142634 73276714818) (-10644159 579766497643))+		  (1/4  (-34897469 115453918) (87164915 118708522) (27407173 168623905) (87908983 193788912) (-27111639 201229582) (25214128 284862638) (-104763374 426775692) (55687060 600536193) (-49901243 909140573) (3434531 975229968) (-44950370 1454097393) (75180138 2189376182) (27482161 3508373380) (-68146942 4866438247) (-85620582 6884660047) (15583442 9233371207) (30725109 29546599818) (2193045 1442060060693))+		  (1/4  (-32461025 169937257) (42456472 193788912) (60136529 201229582) (45652872 230845763) (-11582317 231373438) (-12390325 448235443) (44415233 539290393) (59855124 595484173) (64938439 1057929843) (30600290 1500534537) (71357041 2189376182) (45920466 2616939213) (48826263 2701984943) (27854052 5494891577) (22522061 7193374037) (-21720539 11115923863) (1241486 14811180432) (-44678980 58240834569))+		  (1/4  (-30911476 193788912) (17567341 201229582) (68472337 272525023) (64670845 321390012) (88331413 331905423) (15003774 343841922) (5425743 600536193) (70987227 846974497) (-37737754 1033937133) (69174839 1454097393) (-30230476 2189376182) (28868253 2322170807) (-26482877 6884660047) (-44232101 24139206772) (-18702052 29546599818) (-44232101 50443911578) (7415308 250645741818) (-10210354 512223806648))+		  (1/4  (-30692741 227661182) (12504894 231373438) (-39446702 244653118) (114600079 262992072) (92590873 284862638) (113856011 314198789) (86140179 346369967) (-22467890 355671793) (-141382552 398795108) (59415160 657922943) (-7326899 1620933557) (-1037771 2189376182) (-79323772 8895085098) (-27205340 17997844652) (-10574983 41734246913) (-27904591 60402345333) (-79821190 73276714818) (16893972 102428655030))+		  (1/4  (-30361861 113561432) (85628068 168623905) (20493345 231373438) (53783788 262992072) (46894358 284862638) (65430523 1172624874) (36958860 1258140850) (-16893972 1624720807) (21304492 2189376182) (-1046915 2539791558) (-16436052 3658567505) (20222978 3712239557) (18632610 9549201618) (-27859034 41734246913) (-6816407 52254287493) (50270473 66492889557) (22880170 73276714818) (-10644159 579766497643))+		  (1/4  (-29735286 115453918) (-1890198 149299093) (12010178 168623905) (30661691 195053432) (7109402 201229582) (55743030 213255960) (32522426 231373438) (65751551 262992072) (35890388 284862638) (40220018 687606629) (-29216048 909140573) (-63654586 2189376182) (44099312 2539791558) (-33529628 41734246913) (-20830644 66492889557) (26660566 73276714818) (28204899 579766497643) (-48926623 1197009532318))++		  (1/2  (94283734 231373438) (147962666 262992072) (211308992 284862638) (-26800082 318942476) (-69173113 610076381) (-137945216 1111885489) (126007473 1183092682) (333203505 2189376182) (-250903561 2296713307) (248078871 2539791558) (-379960570 5458840213) (-73879914 18221678207) (132652425 30446482737) (68447160 41734246913) (-28954879 66492889557) (35907922 73276714818) (124495078 193100304493) (118351969 579766497643) (18339615 69971515635443))++		  (1/4  (-177112869 1047764193) (690072825 1057929843) (94777525 1082548618) (102841728 1770638022) (254740469 1845907403) (-7897447 2189376182) (-276135745 4866438247) (382919489 8634733487) (364832031 9233371207) (-255036003 18221678207) (-47281269 30446482737) (-14754756 31147706551) (145805470 35587716432) (-60553945 41734246913) (275062833 73276714818) (130937707 73745675437) (225667081 91140429801) (-58222931 120563046313) (217205407 250645741818) (-335335373 69971515635443))+		  (1/4  (48554212 1047764193) (-8064203 1695830317) (273129107 1845907403) (256152120 2060228568) (387484239 2170952313) (522262813 2189376182) (139928940 2426435870) (35269543 6249781117) (-116987170 9233371207) (-153310392 14885462059) (243523167 16346803247) (-191276069 18221678207) (-114320902 30446482737) (430509851 31147706551) (-62448154 35587716432) (118676670 41734246913) (-206756368 73276714818) (103732367 73745675437) (887580 250645741818) (-42628659 69971515635443))+		  (1/4  (59529729 1111885489) (411801489 1183092682) (-11697838 1770638022) (-10217933 2189376182) (178183864 2420845318) (481604223 2674664693) (200815307 2701984943) (18311409 4309606382) (-54066665 5684017953) (391091355 9566096322) (433050011 14033378718) (155959834 14474950443) (123563452 18221678207) (-322558047 18986886768) (-187246484 41734246913) (182267620 73276714818) (70949047 120563046313) (85657566 134237866432) (150508360 193100304493) (16824928 804006285737))+		  (1/4  (79674619 1057929843) (430112898 1183092682) (103029535 1770638022) (419995354 1845907403) (161719567 2189376182) (25897285 2701984943) (-165526275 3651666474) (-450635225 4866438247) (418811986 5684017953) (520079918 9233371207) (-370946465 11079391432) (11498734 14033378718) (1575319 15548138481) (-17734177 18221678207) (310673925 18986886768) (179773324 91140429801) (10643092 193100304493) (158038974 250645741818) (-165442692 804006285737) (119720378 11484937157318))+		  (1/4  (210413195 1047764193) (49034748 1057929843) (129893399 1111885489) (920835218 1222853176) (-367170458 1770638022) (-460082449 2154947322) (471386290 2189376182) (-4742586 2701984943) (-385386694 3651666474) (239038662 5684017953) (399473027 12988236682) (-298167989 14033378718) (111903950 15548138481) (-327400900 18221678207) (-789934617 18986886768) (-490722320 34352737807) (-639330225 193100304493) (-182267620 250645741818) (264670206 804006285737) (460026972 11484937157318))+		  (1/4  (245117311 1057929843) (-441536832 1111885489) (694624721 1183092682) (357582197 1845907403) (993878808 2189376182) (-264511823 2296713307) (279266579 2701984943) (-1351244216 4866438247) (255211890 9233371207) (142361641 10855443178) (-647040605 11079391432) (-55648319 15548138481) (-29232911 18221678207) (533067633 35587716432) (34223580 41734246913) (165442692 73276714818) (-215957611 91140429801) (786436927 120563046313) (939525243 193100304493) (311982932 250645741818))+		  (1/4  (290087814 1057929843) (129893399 1111885489) (189059832 1183092682) (312611694 1770638022) (-177755991 2189376182) (30639871 2539791558) (236310480 2701984943) (285108950 3651666474) (-530648699 5458840213) (208398791 5684017953) (381614163 14033378718) (81264079 15548138481) (-679782152 17249711432) (321741381 18221678207) (130900601 18986886768) (210413195 66492889557) (250865122 193100304493) (28145575 250645741818) (44970503 804006285737) (-460808246 11484937157318))+		  (1/4  (719865552 1057929843) (-120111015 1111885489) (-210078035 1183092682) (62607280 1770638022) (322252837 2189376182) (486314894 2701984943) (254469079 3651666474) (149133453 4832545807) (-401152271 5684017953) (491057480 7804016832) (-30639871 8995467682) (-328807860 14033378718) (392548235 15548138481) (-311284156 17058320068) (-669324927 18221678207) (-180383555 18986886768) (-60419034 193100304493) (278149989 250645741818) (325614788 804006285737) (-180163961 11484937157318))+		  (1/4  (764256596 1183092682) (340757269 1770638022) (82030807 2189376182) (-651971659 2296713307) (188678845 2539791558) (371182743 2701984943) (-541133952 5458840213) (282350263 5684017953) (261942239 9566096322) (414738602 14033378718) (-578034328 17249711432) (219993557 18221678207) (-126062774 18986886768) (-58097368 41734246913) (129149116 66492889557) (53118504 73276714818) (-68972608 120563046313) (210038089 193100304493) (285108950 579766497643) (16824928 804006285737))+		  (1/2  (-389355483 1111885489) (-85198635 1770638022) (942772580 2189376182) (860225796 2296713307) (958295292 2439473093) (1701938869 2701984943) (570217900 3651666474) (-653171089 5684017953) (1290597651 9566096322) (632981931 14033378718) (-258298232 15548138481) (-716081542 18221678207) (-448620821 18986886768) (-1711424041 41734246913) (1131248413 73276714818) (1650144299 120563046313) (1441452520 193100304493) (766713173 250645741818) (800363029 804006285737) (-1590316151 11484937157318))+		  (1/2  (-383575951 1082548618) (367447545 1695830317) (470326860 1845907403) (302791880 2060228568) (1332608020 2170952313) (1886585069 2189376182) (-562201563 2426435870) (610170129 2539791558) (-707278553 4732978887) (-215928441 6249781117) (-232950527 9233371207) (201602620 16346803247) (172870593 31147706551) (-125920121 35587716432) (696860645 41734246913) (207464734 66492889557) (-412488923 73276714818) (689924269 250645741818) (305596971 579766497643) (199162583 69971515635443))++		  (1/2  (468218462 2189376182) (1818521088 2439473093) (1312583386 2701984943) (121856072 5684017953) (-1109476277 6327662603) (570217900 8634733487) (1720710549 9566096322) (718180566 14033378718) (601927564 15548138481) (-1921221601 18221678207) (-59265338 18986886768) (1164382644 30446482737) (-936396880 41734246913) (701135515 73276714818) (1205140059 73745675437) (875117138 120563046313) (236312461 193100304493) (336600275 250645741818) (715164394 804006285737) (-815288990 11484937157318) (-860225796 69971515635443))+		  )))+  (for-each+   (lambda (formula)+     (let ((r (/ 1 (car formula)))+	   (sum 0.0))+       (for-each+	(lambda (arg)+	  (set! sum (+ sum (* (car arg) (atan (/ 1 (cadr arg)))))))+	(cdr formula))++       (if (> (magnitude (- (* r sum) our-pi)) 1e-12)+	   (begin (display formula) (display " = ") (display (* r sum)) (newline)))))+   formulas)++  (if with-bigfloats+      (let ((mxerr 0.0))+	(for-each+	 (lambda (formula)+	   (let ((r (/ (bignum "1") (car formula)))+		 (sum (bignum "0.0")))+	     (for-each+	      (lambda (arg)+		(set! sum (+ sum (* (car arg) (atan (/ (bignum "1") (cadr arg)))))))+	      (cdr formula))++	     (let ((err (magnitude (- (* r sum) (* 4 (atan (bignum "1.0") 1.0))))))+	       (if (> err mxerr)+		   (set! mxerr err)))))+	 formulas)+	(if (> mxerr 1e-30)+	    (format #t "big max error: ~A~%" mxerr)))))+++(if with-bigfloats+    (letrec ((sin-m*pi/n+	      (lambda (m1 n1)++		;; this returns an expression giving the exact value of sin(m*pi/n), m and n integer+		;;   if we can handle n -- currently it can be anything of the form 2^a 3^b 5^c 7^d 11^h 13^e 17^f 257^g+		;;   so (sin-m*pi/n 1 60) returns an exact expression for sin(pi/60).++		(let ((m (numerator (/ m1 n1)))+		      (n (denominator (/ m1 n1))))++		  (set! m (modulo m (* 2 n)))+		  ;; now it's in lowest terms without extra factors of 2*pi++		  (cond ((zero? m) 0)++			((zero? n) (error "divide by zero (sin-m*pi/n n = 0)"))++			((= n 1) 0)++			((negative? n)+			 (let ((val (sin-m*pi/n m (- n))))+			   (and val `(- ,val))))++			((> m n)+			 (let ((val (sin-m*pi/n (- m n) n)))+			   (and val `(- ,val))))++			((= n 2) (if (= m 0) 0 1))++			((= n 3) `(sqrt 3/4))++			((> m 1)+			 (let ((m1 (sin-m*pi/n (- m 1) n))+			       (n1 (sin-m*pi/n 1 n))+			       (m2 (sin-m*pi/n (- m 2) n)))+			   (and m1 m2 n1+				`(- (* 2 ,m1 (sqrt (- 1 (* ,n1 ,n1)))) ,m2))))++			((= n 5) `(/ (sqrt (- 10 (* 2 (sqrt 5)))) 4))++			((= n 7) `(let ((A1 (expt (+ -7/3456 (sqrt -49/442368)) 1/3))+					(A2 (expt (- -7/3456 (sqrt -49/442368)) 1/3)))+				    (sqrt (+ 7/12 (* -1/2 (+ A1 A2)) (* 1/2 0+i (sqrt 3) (- A1 A2))))))++			((= n 17) `(let* ((A1 (sqrt (- 17 (sqrt 17))))+					  (A2 (sqrt (+ 17 (sqrt 17))))+					  (A3 (sqrt (+ 34 (* 6 (sqrt 17)) (* (sqrt 2) (- (sqrt 17) 1) A1) (* -8 (sqrt 2) A2)))))+				     (* 1/8 (sqrt 2) (sqrt (- 17 (sqrt 17) (* (sqrt 2) (+ A1 A3)))))))+++			((= n 11) `(let* ((SQRT5 (* 1/2 (- (sqrt 5) 1)))+					  (B5 (sqrt (+ 2 (* 1/2 (+ (sqrt 5) 1)))))+					  (B6 (+ SQRT5 (* 0+i B5)))+					  (B6_2 (* B6 B6))+					  (B6_3 (* B6 B6 B6))+					  (B6_4 (* B6 B6 B6 B6))+					  (D1 (+ 6 (* 3/2 B6) (* 3/4 B6_2)))+					  (D2 (+ SQRT5 (* 0+i B5) (* 1/4 B6_2)))+					  (D3 (* 1/2 (- (+ 1 (* 0+i (sqrt 11))))))+					  (D4 (* 1/2 (- (* 0+i (sqrt 11)) 1)))+					  (D6 (+ 1 (* 1/4 B6_2) (* 1/8 B6_3)))+					  (D7 (+ (* 1/2 B6) (* 1/16 B6_4)))+					  (D8 (+ 2 (* 1/2 B6)))+					  (D9 (+ 13 (* 21 B6) (* 67/4 B6_2) (* 21/4 B6_3) (* 2 B6_4)))+					  (D11 (+ 129 (* 109/2 B6) (* 59/4 B6_2) (* 9/8 B6_3) (* 9/16 B6_4)))+					  (D13 (+ (* 3 B6) B6_2))+					  (D14 (+ (* 3 B6) (* 3/4 B6_2) (* 3/8 B6_3)))+					  (D15 (+ 79 (* 27 B6) (* 39/4 B6_2) (* 37/4 B6_3) (* 21/4 B6_4)))+					  (D16 (+ D11 (* D3 D9) (* D4 D15)))+					  (D17 (+ D11 (* D4 D9) (* D3 D15)))+					  (D30 (/ (* B6_2 (+ (* D3 D6) (* D4 D7))) (* 4 (expt D17 1/5))))+					  (D32 (* 1/2 (+ 1 (* 0+i (sqrt 11)))))+					  (D33 (/ (* B6_3 (+ (* D4 D6) (* D3 D7))) (* 8 (expt D16 1/5))))+					  (D34 (* 1/4 B6_2 (expt D16 1/5)))+					  (D35 (+ 2 (* 1/8 B6_4) (* 1/2 B6 D8) (* 1/8 B6_3 D2)))+					  (D36 (+ SQRT5 (* 0+i B5) (* 1/2 B6_2) (* 1/4 B6_3) (* 1/2 B6 D2) (* 1/4 B6_2 (+ (* 1/4 B6_3) (* 1/16 B6_4)))))+					  (D38 (* 1/2 (+ -1 (* 0+i (sqrt 11)))))+					  (D39 (* 1/8 B6_3 (expt D17 1/5)))+					  (D40 (+ 3 (* 3/2 B6) (* 9/4 B6_2) (* 7/8 B6_3) (* 3/16 B6_4) (* 1/2 B6 (+ 6 (* 2 B6)))+						  (* 1/16 B6_4 D1) (* 1/4 B6_2 D13) (* 1/8 B6_3 (+ 3 (* 3/4 B6_3) (* 3/16 B6_4)))))+					  (D41 (+ (* 1/4 B6_2 D1) (* 1/8 B6_3 D13) (* 1/16 B6_4 D14) (* 1/2 B6 (+ 4 (* 3/8 B6_4)))))+					  (D42 (+ 3 (* 3/4 B6_3) (* 3/16 B6_4) (* 1/8 B6_3 D1) (* 1/4 B6_2 D14)+						  (* 1/2 B6 (+ (* 3/2 B6_2) (* 3/8 B6_3) (* 3/16 B6_4))) (* 1/16 B6_4 (+ 3 (* 3/2 B6) (* 3/8 B6_4)))))+					  (D43 (+ (* 1/4 B6_3) (* 1/16 B6_4) (* 1/8 B6_3 D8) (* 1/4 B6_2 D2)+						  (* 1/2 B6 (+ (* 1/2 B6_2) (* 1/8 B6_3))) (* 1/16 B6_4 (+ 1 (* 1/8 B6_4)))))+					  (D44 (/ (* B6_4 (+ D42 (* D4 D40) (* D3 D41))) (* 16 (expt D16 3/5))))+					  (D45 (/ (* B6 (+ D42 (* D3 D40) (* D4 D41))) (* 2 (expt D17 3/5))))+					  (D48 (/ (* B6 (+ D43 (* D3 D35) (* D4 D36))) (* 2 (expt D16 2/5))))+					  (D49 (/ (* B6_4 (+ D43 (* D4 D35) (* D3 D36))) (* 16 (expt D17 2/5)))))+				     (* -1/2 0+i+					(+ (* 1/5 (- D32 D33 D34 D48 D44))+					   (* 1/5 (+ D38 D30 D39 D49 D45))))))++			((= n 13)+			 `(let* ((A1 (/ (- -1 (sqrt 13)) 2))+				 (A2 (/ (+ -1 (sqrt 13)) 2))+				 (A3 (/ (+ -1 (* 0+i (sqrt 3))) 2))+				 (A4 (+ -1 (* 0+i (sqrt 3))))+				 (A5 (* 0+i (sqrt (+ 7 (sqrt 13) A2))))+				 (A6 (* 0+i (sqrt (+ 7 (- (sqrt 13)) A1))))+				 (A8  (* 1/2 (- A2 A6)))+				 (A9  (* 1/2 (+ A1 A5)))+				 (A11 (* 1/2 (+ A2 A6)))+				 (A12 (* 1/2 (- A1 A5)))+				 (A13 (* 3/2 A4 A8))+				 (A14 (* 3/2 A4 A11))+				 (A15 (* 3/4 A4 A4 A11))+				 (A16 (* 3/4 A4 A4 A8))+				 (A17 (+ A3 (* 1/4 A4 A4))))+			    (* -1/6 0+i (+ (- A9 A12)+					   (* A4 (+ (/ (+ A8 (* A17 A12)) (* 2 (expt (+ 6 A13 A15 A9) 1/3)))+						    (/ (+ A11 (* A17 A9)) (* -2 (expt (+ 6 A16 A14 A12) 1/3)))+						    (* 1/4 A4 (- (expt (+ 6 A13 A15 A9) 1/3) (expt (+ 6 A16 A14 A12) 1/3)))))))))++			((= n 257)+			 `(let* ((A1 (sqrt (- 514 (* 2 (sqrt 257)))))+				 (A2 (- 257 (* 15 (sqrt 257))))+				 (A3 (+ 257 (* 15 (sqrt 257))))+				 (A4 (- 257 (sqrt 257)))+				 (A5 (+ (sqrt 257) 257))+				 (A7 (+ 257 (* 9 (sqrt 257))))+				 (A8 (- 514 (* 18 (sqrt 257))))+				 (AA (sqrt (* 2 A5)))+				 (A9 (sqrt (+ A2 (* 8 A1) (* -7 AA))))+				 (A10 (sqrt (+ A2 (* -8 A1) (* 7 AA))))+				 (A11 (sqrt (+ A3 (* 7 A1) (* 8 AA))))+				 (A12 (sqrt (+ A3 (* -7 A1) (* -8 AA))))+				 (A13 (sqrt (+ A8 (* 6 A1) (* 8 A9) (* -24 A10) (* 12 A11))))+				 (A14 (* 4 (sqrt (+ A8 (* 6 A1) (* -8 A9) (* 24 A10) (* -12 A11)))))+				 (A15 (* 4 (sqrt (+ A8 (* -6 A1) (* -12 A12) (* 24 A9) (* 8 A10)))))+				 (A16 (* 4 (sqrt (* 2 (+ (- 257 (* 9 (sqrt 257))) (* -3 A1) (* 6 A12) (* -12 A9) (* -4 A10))))))+				 (A17 (sqrt (* 2 (+ A7 (* -3 AA) (* -4 A12) (* 6 A9) (* 12 A11)))))+				 (A18 (sqrt (* 2 (+ A7 (* 3 AA) (* 12 A12) (* -6 A10) (* 4 A11)))))+				 (A19 (* 4 (sqrt (* 2 (+ A7 (* 3 AA) (* -12 A12) (* 6 A10) (* -4 A11))))))+				 (A20 (* 4 (sqrt (* 2 (+ A7 (* -3 AA) (* 4 A12) (* -6 A9) (* -12 A11))))))+				 (A22 (+ A4 (* 3 A1) (* -4 AA) (* -4 A12) (* 4 A9) (* -4 A10) (* 2 A11)))+				 (A23 (+ A5 (* -4 A1) (* -3 AA) (* -4 A12) (* 2 A9) (* 4 A10) (* 4 A11)))+				 (A24 (+ A5 (* 4 A1) (* 3 AA) (* 4 A12) (* 4 A9) (* -2 A10) (* 4 A11)))+				 (A26 (sqrt (+ A22 (+ (- A16) (- A19) (* 4 A17) (* -6 A13)))))+				 (A27 (sqrt (+ A22 (+ A16 A19 (* -4 A17) (* 6 A13)))))+				 (A28 (+ 257 (* 7 (sqrt 257)) (* 3 A1) (* -4 A9) (* 4 A10) (* 6 A11)))+				 (A29 (* 8 (sqrt (+ A24 A15 (- A20) (* -6 A18) (* -4 A13)))))+				 (A30 (+ A28 (* -4 A18) (* -4 A17) (* -2 A13)))+				 (A31 (+ (* 8 (sqrt (+ A23 A15 A14 (* 4 A18) (* -6 A17)))) (* 4 A26) A29 (* -8 A27))))+			    (* 1/16 (sqrt (* 1/2 (+ A4 (- A1) (* -2 A11) (* -2 A13) (* -4 A26)+						    (* -4 (sqrt (* 2 (+ A30 (- A31)))))+						    (* -8 (sqrt (+ A4 (- A1) (* -2 A11) (* 6 A13) (* -4 A26) (* -8 A27)+								   (* 4 (sqrt (* 2 (+ A30 A31))))+								   (* -8 (sqrt (* 2 (+ A28 (* 4 A18) (* 4 A17) (* 2 A13) (* -8 A26) (* -4 A27)+										       (* -8 (sqrt (+ A23 (- A15) (- A14) (* -4 A18) (* 6 A17))))+										       (* -8 (sqrt (+ A24 (- A15) A20 (* 6 A18) (* 4 A13)))))))))))))))))++			((or (= (modulo n 2) 0) (= (modulo n 3) 0) (= (modulo n 5) 0) (= (modulo n 7) 0)+			     (= (modulo n 17) 0) (= (modulo n 13) 0) (= (modulo n 257) 0) (= (modulo n 11) 0))+			 (let ((divisor (if (= (modulo n 2) 0) 2+					    (if (= (modulo n 3) 0) 3+						(if (= (modulo n 5) 0) 5+						    (if (= (modulo n 7) 0) 7+							(if (= (modulo n 17) 0) 17+							    (if (= (modulo n 13) 0) 13+								(if (= (modulo n 11) 0) 11+								    257)))))))))+			   (let ((val (sin-m*pi/n 1 (/ n divisor))))+			     (and val+				  `(let ((ex ,val))+				     (/ (- (expt (+ (sqrt (- 1 (* ex ex))) (* 0+i ex)) (/ 1 ,divisor))+					   (expt (- (sqrt (- 1 (* ex ex))) (* 0+i ex)) (/ 1 ,divisor)))+					0+2i))))))++			(else #f))))))++      (let ((maxerr 0.0)+	    (max-case #f)+	    (cases 0))+	(do ((n 1 (+ n 1)))+	    ((= n 100))+	  (do ((m 1 (+ m 1)))+	      ((= m 4))+	    (letrec ((bigify (lambda (lst)+			       (if (pair? lst)+				   (cons (if (number? (car lst))+					     (list 'bignum (number->string (car lst)))+					     (bigify (car lst)))+					 (bigify (cdr lst)))+				   lst))))+	      (let ((val (sin (/ (* m our-pi) n)))+		    (expr (bigify (sin-m*pi/n m n))))+		(if expr+		    (let ((err (magnitude (- val (eval expr)))))+		      (set! cases (+ cases 1))+		      (if (> err maxerr)+			  (begin+			    (set! max-case (/ m n))+			    (set! maxerr err)))))))))+	(if (> maxerr 1e-35)+	    (format #t "sin-m*pi/n (~A cases) max err ~A at ~A~%" cases maxerr max-case))))+    )+++(test (integer? (expt 2.3 54)) #f)+(test (zero? (- (expt 2.3 54) (floor (expt 2.3 54)))) #f)+(test (integer? 10000000000000000.5) #f)+(test (integer? (expt 2 54)) #t)+(num-test (+ 1 (expt 2 54)) 18014398509481985)+(num-test (- (expt 2 54) 18014398509481984) 0)+(num-test (- (expt 2 54) 18014398509481983) 1)+(num-test (+ 10000000000000000 1) 10000000000000001)+(num-test (- 10000000000000000 9999999999999999) 1)+(num-test (/ (expt 2 -53) 2) (expt 2 -54))+(num-test (* 1/18014398509481984 1/2) (expt 2 -55))+(num-test (/ (expt 2.3 50) (expt 2.3 49)) 2.3)+(num-test (/ 1e-10 1e10) 1e-20)+;(num-test (/ 1e-20 1e300) 1e-321)+;;; why: (- 1e-2 (expt 10 -2)) = 2.081668171172168513294235909273361692968E-19? in guile it's 0.0+(num-test (/ (expt 10 -20) (expt 10 -20)) 1)+(num-test (/ (expt 10 -200) (expt 10 -200)) 1)+(num-test (* .000000000000123 .000000000000123) 1.5129e-26)+(num-test (sqrt (* 1.2345e-27 1.2345e-27)) 1.2345e-27)+(num-test (sqrt (* 1.2345e-127 1.2345e-127)) 1.2345e-127)++(if with-bigfloats+    (begin++      (num-test (/ (sqrt (* 1.2345e-170 1.2345e-170))) 8.100445524503847216161209708816501953798E169)+      (num-test (/ (expt (* 1.2345e-170 1.2345e-170) 1/100)) 2.501325312985302606641508258507698932691E3)+      (num-test (/ (+ 1.2345e-15 1 -1)) 8.1004455245038e+14)+      (num-test (/ (+ 1 1.2345e-14 -1)) 81004455245038.0)+      (num-test (/ (+ 1 1.2345e-10 -1)) 8100445524.5038)+      (num-test (* 1.2345e-15 8.1004455245038e+14) 9.999999999999941444123044301452428384978E-1) ; the inverse is not exact+      (num-test (+ 1.23456789 1.0e11 -1.0e11) 1.23456789)+      (num-test (- 1.0e11 -1.23456789 1.0e11) 1.23456789)+      (num-test (* 2.0e-170 3.0e-170 4.0e170 5.0e170) 120.0)+      (num-test (* 4.0e170 5.0e170 2.0e-170 3.0e-170) 120.0)+      (num-test (* 1000000.0 (+ 1.0 1.2345e-10 -1.0)) 1.2345e-4)+      (num-test (* 1000000.0 (- 1.0 -1.2345e-10 1.0)) 1.2345e-4)++      (let ((p (lambda (x y) (+ (* 2 y y) (* 9 x x x x) (* -1 y y y y)))))+	(num-test (p 408855776 708158977) 1))+      (let ((p (lambda (x y) (+ (* 2 y y) (* (- (* 3 x x) (* y y)) (+ (* 3 x x) (* y y)))))))+	(num-test (p 408855776 708158977) 1))++      ))++(num-test (tan (/ our-pi 4)) 1.0)++(num-test (+ (/ (expt 2 11) (+ (expt 2 10) 1)) (/ (+ (expt 2 11) 1) (expt 2 10)))+	  4197377/1049600)+(num-test (- (/ (expt 2 11) (+ (expt 2 10) 1)) (/ (+ (expt 2 11) 1) (expt 2 10)))+	  -3073/1049600)+(num-test (* (/ (expt 2 11) (+ (expt 2 10) 1)) (/ (+ (expt 2 11) 1) (expt 2 10)))+	  4098/1025)+(num-test (/ (/ (expt 2 11) (+ (expt 2 10) 1)) (/ (+ (expt 2 11) 1) (expt 2 10)))+	  2097152/2100225)++(if with-64-bit-ints+    (begin+      (num-test (+ (/ (expt 2 21) (+ (expt 2 20) 1)) (/ (+ (expt 2 21) 1) (expt 2 20)))+		4398049656833/1099512676352)+      (num-test (- (/ (expt 2 21) (+ (expt 2 20) 1)) (/ (+ (expt 2 21) 1) (expt 2 20)))+		-3145729/1099512676352)+      (num-test (* (/ (expt 2 21) (+ (expt 2 20) 1)) (/ (+ (expt 2 21) 1) (expt 2 20)))+		4194306/1048577)+      (num-test (/ (/ (expt 2 21) (+ (expt 2 20) 1)) (/ (+ (expt 2 21) 1) (expt 2 20)))+		2199023255552/2199026401281)++      (num-test (+ (/ (expt 2 31) (+ (expt 2 20) 1)) (/ (+ (expt 2 31) 1) (expt 2 20)))+		4503601775902721/1099512676352)+      (num-test (- (/ (expt 2 31) (+ (expt 2 20) 1)) (/ (+ (expt 2 31) 1) (expt 2 20)))+		-2148532225/1099512676352)+      (if (not with-bignums)+	  (num-test (* (/ (expt 2 31) (+ (expt 2 20) 1)) (/ (+ (expt 2 31) 1) (expt 2 20)))+		    4194300.0019569)+	  (num-test (* (/ (expt 2 31) (+ (expt 2 20) 1)) (/ (+ (expt 2 31) 1) (expt 2 20)))+		    4398046513152/1048577))+      (num-test (/ (/ (expt 2 31) (+ (expt 2 20) 1)) (/ (+ (expt 2 31) 1) (expt 2 20)))+		2251799813685248/2251801962217473)+      ))++(if with-bignums+    (begin+      (num-test (+ (/ (expt 2 61) (+ (expt 2 40) 1)) (/ (+ (expt 2 61) 1) (expt 2 40)))+		5070602400915223450095538143233/1208925819615728686333952)+      (num-test (- (/ (expt 2 61) (+ (expt 2 40) 1)) (/ (+ (expt 2 61) 1) (expt 2 40)))+		-2305844108725321729/1208925819615728686333952)+      (num-test (* (/ (expt 2 61) (+ (expt 2 40) 1)) (/ (+ (expt 2 61) 1) (expt 2 40)))+		4835703278458516700921856/1099511627777)+      (num-test (/ (/ (expt 2 61) (+ (expt 2 40) 1)) (/ (+ (expt 2 61) 1) (expt 2 40)))+		2535301200456458802993406410752/2535301200458764647102131732481)+      ))++(if (and (not with-bignums) (not with-64-bit-ints))+    (begin+      (num-test (+ 1/98947 2/97499 3/76847) 6.9658060696377e-05)+      (num-test (- 1/98947 2/97499 3/76847) -4.9445219478352e-05)+      (num-test (* 1/98947 2/97499 3/76847) 8.0932236106886e-15)+      (num-test (/ 1/98947 2/97499 3/76847) 12620.402257437)+      )+    (begin+      (num-test (+ 1/98947 2/97499 3/76847) 51641766530/741360956847391)+      (num-test (- 1/98947 2/97499 3/76847) -36656755224/741360956847391)+      (num-test (* 1/98947 2/97499 3/76847) 6/741360956847391)+      (num-test (/ 1/98947 2/97499 3/76847) 7492505653/593682)+      ))++(if (and (not with-bignums) (not with-64-bit-ints))+    (begin+      (num-test (+ 500009/500029 500057/500041) 1.99999199969608)+      (num-test (- 500009/500029 500057/500041) -7.19950563497026e-5)+      (num-test (* 500009/500029 500057/500041) 0.99999199841626)+      (num-test (/ 500009/500029 500057/500041) 0.999928007247229))+    (begin+      (num-test (+ 500009/500029 500057/500041) 500068002022/250035001189)+      (num-test (- 500009/500029 500057/500041) -18001284/250035001189)+      (num-test (* 500009/500029 500057/500041) 250033000513/250035001189)+      (num-test (/ 500009/500029 500057/500041) 250025000369/250043001653)))++(if (not with-bignums)+    (begin+      (num-test (+ 500009/500029 500057/500041 500083/500069) 3.00001999583261)+      (num-test (- 500009/500029 500057/500041 500083/500069) -1.00009999119288)+      (num-test (* 500009/500029 500057/500041 500083/500069) 1.00001999432878)+      (num-test (/ 500009/500029 500057/500041 500083/500069) 0.999900013909921))+    (begin+      (num-test (+ 500009/500029 500057/500041 500083/500069) 375106759202738205/125034753009582041)+      (num-test (- 500009/500029 500057/500041 500083/500069) -125047255383687283/125034753009582041)+      (num-test (* 500009/500029 500057/500041 500083/500069) 125037252995542579/125034753009582041)+      (num-test (/ 500009/500029 500057/500041 500083/500069) 125029751909525461/125042254395637199)))++(if (not with-bignums)+    (begin+      (num-test (+ 1/98947 2/97499 3/76847 4/61981) 0.00013419396686117)+      (num-test (- 1/98947 2/97499 3/76847 4/61981) -0.00011398112564314)+      (num-test (* 1/98947 2/97499 3/76847 4/61981) 5.2230351951008e-19)+      (if with-64-bit-ints+	  (num-test (/ 1/98947 2/97499 3/76847 4/61981) 464392992878593/2374728) ;195556288.07955 -- seems to fit+	  (num-test (/ 1/98947 2/97499 3/76847 4/61981) 195556288.07955))+      )+    (begin+      (num-test (+ 1/98947 2/97499 3/76847 4/61981) 6166252158685494/45950293466358141571)+      (num-test (- 1/98947 2/97499 3/76847 4/61981) -5237466172928308/45950293466358141571)+      (num-test (* 1/98947 2/97499 3/76847 4/61981) 24/45950293466358141571)+      (num-test (/ 1/98947 2/97499 3/76847 4/61981) 464392992878593/2374728)+      ))++(if (not with-bignums)+    (begin+      (num-test (+ 1/98947 2/97499 3/76847 4/61981 5/59981) 0.00021755369744252)+      (num-test (- 1/98947 2/97499 3/76847 4/61981 5/59981) -0.00019734085622449)+      (num-test (* 1/98947 2/97499 3/76847 4/61981 5/59981) 4.3539080668052e-23)+      (num-test (/ 1/98947 2/97499 3/76847 4/61981 5/59981) 2345932343059.9)+      )+    (begin+      (num-test (+ 1/98947 2/97499 3/76847 4/61981 5/59981) 599609438061905323469/2756144552405627689570151)+      (num-test (- 1/98947 2/97499 3/76847 4/61981 5/59981) -543899925850203550003/2756144552405627689570151)+      (num-test (* 1/98947 2/97499 3/76847 4/61981 5/59981) 120/2756144552405627689570151)+      (num-test (/ 1/98947 2/97499 3/76847 4/61981 5/59981) 27854756105850886733/11873640)+      ))++(if (not with-bignums)+    (begin+      (num-test (+ 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) 0.00030764243484887)+      (num-test (- 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) -0.00028742959363084)+      (num-test (* 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) 3.9223808052178e-27)+      (num-test (/ 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) 2.6040239996689e+16)+      )+    (begin+      (num-test (+ 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) 56471455498794722585779775/183561983334767209753061626751)+      (num-test (- 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) -52761146275983172771170709/183561983334767209753061626751)+      (num-test (* 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) 720/183561983334767209753061626751)+      (num-test (/ 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) 1855154611405774907304533/71241840)+      ))++(if (not with-bignums)+    (begin+      (num-test (+ 98947 2/97499 76847 4/61981 5/59981) 175794.00016841)+      (num-test (- 98947 2/97499 76847 4/61981 5/59981) 22099.999831591)+      (if with-64-bit-ints+	  (num-test (* 98947 2/97499 76847 4/61981 5/59981) 304151204360/362470312515139) ;0.00083910652502692+	  (num-test (* 98947 2/97499 76847 4/61981 5/59981) 0.00083910652502692))+      (num-test (/ 98947 2/97499 76847 4/61981 5/59981) 11667778186668.0)+      )+    (begin+      (num-test (+ 98947 2/97499 76847 4/61981 5/59981) 63720106179329487759/362470312515139)+      (num-test (- 98947 2/97499 76847 4/61981 5/59981) 8010593845541429507/362470312515139)+      (num-test (* 98947 2/97499 76847 4/61981 5/59981) 304151204360/362470312515139)+      (num-test (/ 98947 2/97499 76847 4/61981 5/59981) 35865350012435458633/3073880)+      ))++(num-test (* 2 (asin 1)) our-pi)++(num-test (+ 1e100 -1e100) 0.0)+(num-test (+ 1e200 -1e200) 0.0)+(num-test (+ 1e300 -1e300) 0.0)+(num-test (* 1e100 1e-100) 1.0)+(num-test (* 1e200 1e-200) 1.0)+(num-test (* 1e300 1e-300) 1.0)+(num-test (* 1e100 0.001) 1e97)+(test (= 1e100 1e+100) #t)+(num-test (+ 1e100 1e100) 2e100)+(num-test (let ((x 1) (y 2)) (set! x (* 0 (let () (set! y 32) 1))) y) 32)+(num-test (* 11/1234 1234/11 11/1234 1234/11 11/1234 1234/11) 1)++(num-test (/ 1.0 (/ 1.0 our-pi)) our-pi)+(num-test (/ 1 (/ 1 1234)) 1234)+(num-test (* our-pi (+ 1.0 (atan (tan (acos (cos (asin (sin (/ 1.0 (/ 1.0 our-pi)))))))))) our-pi)+(num-test (/ 1.0 (/ 1.0 1.0+1.0i)) 1.0+1.0i)++(let* ((angle 0.0)+       (z 1.18)+       (result (* z (cos angle))))+  (do ((k 0 (+ 1 k)))+      ((= k 1000))+    (set! result (* z (cos result))))+  ;;result: 0.81194462369499+  ;;(let ((x 0.0))+  ;;  (do ((i 0 (+ 1 i)))+  ;;      ((= i 10000))+  ;;    (set! x (+ x (* (expt -1 i)+  ;;		        (/ (bes-jn (+ 1 (* 2 i)) (* z (+ 1 (* 2 i))))+  ;;		        (+ 1 (* 2 i)))))))+  ;;  (* 2 x))+  ;; 0.81194498071946+  (let ((x (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos 0.0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))+    ;; 47? calls here so we're at around .812 (oscillating around .8119)+    (test (< (abs (- x result)) .001) #t)))++(num-test (exp (make-rectangular 0.0 our-pi)) -1.0)++(if (positive? 2147483648)+    (begin+      (num-test (/ 12341234/111 123456789 12341234/111) 1/123456789)+      (num-test (abs -922337203685477580) 922337203685477580)))++(if (or with-bignums with-64-bit-ints)+    (begin+      (num-test (+ 123456789/3 3/123456789 -123456789/3 -3/123456789) 0)+      (num-test (/ 123412341234) 1/123412341234)+      (num-test (/ 1/123412341234) 123412341234)))+++(let ((dht (lambda (data)+	     ; the Hartley transform of 'data'+	     (let* ((len (vector-length data))+		    (arr (make-vector len 0.0))+		    (w (/ (* 2.0 our-pi) len)))+	       (do ((i 0 (+ 1 i)))+		   ((= i len))+		 (do ((j 0 (+ 1 j)))+		     ((= j len))+		   (vector-set! arr i (+ (vector-ref arr i)+				      (* (vector-ref data j)+					 (+ (cos (* i j w))+					    (sin (* i j w))))))))+	       arr)))+      (data (list->vector '(0.9196 0.9457 0.0268 0.0839 0.1974 0.1060 0.1463 0.3513 0.0391 0.6310+			    0.9556 0.6259 0.9580 0.8848 0.0104 0.1440 0.0542 0.3001 0.1844 0.3781+			    0.9641 0.6051 0.3319 0.6143 0.1828 0.2290 0.4026 0.5990 0.7906 0.0403+			    0.7882 0.1591)))+      (saved-data (make-vector 32 0.0)))+  (do ((i 0 (+ i 1)))+      ((= i 32))+    (vector-set! saved-data i (vector-ref data i)))+  (dht data)+  (dht data)+  (let ((mx 0.0))+    (do ((i 0 (+ i 1)))+	((= i 32))+      (let ((err (abs (- (vector-ref data i) (vector-ref saved-data i)))))+	(if (> err mx)+	    (set! mx err))))+    (if (> mx 1e-6)+	(begin (display "dht error: ") (display mx) (newline)))))++(num-test (+ 3 4) 7 )+(num-test (+ 3) '3 )+(num-test (+) 0 )+(num-test (* 4) 4 )+(num-test (*) 1 )+(num-test (- 3 4) -1 )+(num-test (- 3) -3 )++;;;;From: fred@sce.carleton.ca (Fred J Kaudel)+;;; Modified by jaffer.+(let ((f3.9 (string->number "3.9"))+      (f4.0 (string->number "4.0"))+      (f-3.25 (string->number "-3.25"))+      (f.25 (string->number ".25"))+      (f4.5 (string->number "4.5"))+      (f3.5 (string->number "3.5"))+      (f0.0 (string->number "0.0"))+      (f0.8 (string->number "0.8"))+      (f1.0 (string->number "1.0"))+      (f1e300 (and (string->number "1+3i") (string->number "1e300")))+      (f1e-300 (and (string->number "1+3i") (string->number "1e-300"))))++  (test (eqv? 1 f1.0) #f )+  (test (eqv? 0 f0.0) #f )+  (test (eqv? f0.0 f0.0) #t )+  (test (= f0.0 f0.0) #t )+  (test (= f0.0 (- f0.0)) #t )+  (test (= f0.0 (* -5 f0.0)) #t )+  (test (inexact? f3.9) #t )+  (test (exact->inexact 4) f4.0 )+  (test (exact->inexact 4.0) f4.0 )+  (test (inexact->exact 4) 4 )+  (test (inexact->exact 4.0) 4 )+  (num-test (round f0.0) f0.0 )+  (num-test (round f.25) f0.0 )+  (num-test (round f0.8) f1.0 )+  (num-test (round f3.5) f4.0 )+  (num-test (round f4.5) f4.0 )+  (num-test (expt f0.0 f1.0) f0.0 )+  (num-test (expt f0.0 1) f0.0 )+  (num-test (expt 0    f1.0) f0.0 )+  (num-test (expt -25  f0.0) f1.0 )+  (num-test (expt f-3.25 f0.0) f1.0 )+  (num-test (expt f-3.25 0) 1.0 )+  (num-test (atan 1 1) (atan 1)))++(if with-bignums+    (begin+    (letrec ((tb (lambda (n1 n2)+		   (= n1 (+ (* n2 (quotient n1 n2))+			    (remainder n1 n2))))))+      (let ((b3-3 (string->number "33333333333333333333"))+	    (b3-2 (string->number "33333333333333333332"))+	    (b3-0 (string->number "33333333333333333330"))+	    (b2-0 (string->number "2177452800")))++	(num-test (modulo b3-3 3) 0 )+	(num-test (modulo b3-3 -3) 0 )+	(num-test (remainder b3-3 3) 0 )+	(num-test (remainder b3-3 -3) 0 )+	(num-test (modulo b3-2 3) 2 )+	(num-test (modulo b3-2 -3) -1 )+	(num-test (remainder b3-2 3) 2 )+	(num-test (remainder b3-2 -3) 2 )+	(num-test (modulo (- b3-2) 3) 1 )+	(num-test (modulo (- b3-2) -3) -2 )+	(num-test (remainder (- b3-2) 3) -2 )+	(num-test (remainder (- b3-2) -3) -2 )++	(num-test (modulo 3 b3-3) 3 )+	(num-test (modulo -3 b3-3) b3-0 )+	(num-test (remainder 3 b3-3) 3 )+	(num-test (remainder -3 b3-3) -3 )+	(num-test (modulo -3 (- b3-3)) -3 )+	(num-test (remainder 3 (- b3-3)) 3 )+	(num-test (remainder -3 (- b3-3)) -3 )++	(num-test (modulo (- b2-0) 86400) 0 )+	(num-test (modulo b2-0 -86400) 0 )+	(num-test (modulo b2-0 86400) 0 )+	(num-test (modulo (- b2-0) -86400) 0 )+	(num-test (modulo  0 (- b2-0)) 0 ))++      (num-test (abs -12345678901234567890) 12345678901234567890)+      (num-test (abs 12345678901234567890) 12345678901234567890)+      (num-test (modulo 12345678901234567890 3123) 1071)+      (num-test (modulo 12345678901234567890 12345678901234567) 890)++      (test (even? 12345678901234567890) #t)+      (test (even? 12345678901234567891) #f)+      (test (odd? 12345678901234567891) #t)+      (test (odd? 12345678901234567890) #f)+      (test (positive? 12345678901234567890) #t)+      (test (positive? -12345678901234567890) #f)+      (test (negative? 12345678901234567890) #f)+      (test (negative? -12345678901234567890) #t)+      (test (zero? 12345678901234567890) #f)+      (test (exact? 12345678901234567890) #t)+      (test (inexact? 12345678901234567890) #f)+      (test (> 12345678901234567890 12345678901234567891) #f)+      (test (< 12345678901234567890 12345678901234567891) #t)+      (test (>= 12345678901234567890 12345678901234567891) #f)+      (test (<= 12345678901234567890 12345678901234567891) #t)+      (test (= 12345678901234567890 12345678901234567891) #f)++      (num-test (max 12345678901234567890 12345678901234567891) 12345678901234567891)+      (num-test (min 12345678901234567890 12345678901234567891) 12345678901234567890)+      (num-test (gcd 12345678901234567890 12345) 15)++      ;;  (test (not (= (sin 12345678901234567890) (cos 12345678901234567890))) #t) ; and so on++      (num-test (+ 4611686018427387904 1) 4611686018427387905) ; (expt 2 62) + 1 -- should work in both cases+      (num-test (+ 4611686018427387904 -1) 4611686018427387903)+      (num-test (+ 4611686018427387904 4611686018427387904) 9223372036854775808)+      (num-test (+ 4611686018427387904 -4611686018427387904) 0)+      (num-test (+ 8589934592 4611686018427387904) 4611686027017322496)+      (num-test (+ 2147483648 4611686018427387904) 4611686020574871552)+      (num-test (+ 2147483647 4611686018427387904) 4611686020574871551)+      (num-test (+ 2147483649 4611686018427387904) 4611686020574871553)+      (num-test (+ 8589934591 4611686018427387904) 4611686027017322495)+      (num-test (+ -8589934591 4611686018427387904) 4611686009837453313)+      (num-test (+ -8589934591 -4611686018427387904) -4611686027017322495)+      (num-test (+ 8589934591 -4611686018427387904) -4611686009837453313)+      (num-test (+ 2147483649 4611686018427387904 2147483649 4611686018427387904) 9223372041149743106)+      (num-test (+ 9223372041149743106 9223372041149743106) 18446744082299486212)+      (num-test (+ 9223372041149743106 -9223372041149743106) 0)+      (num-test (+ 18446744082299486212 1) 18446744082299486213)+      (num-test (+ 9223372036854775807 -1) 9223372036854775806)+      (num-test (+ -9223372036854775807 -1) -9223372036854775808)+      (num-test (+ -9223372036854775807 1) -9223372036854775806)+      (num-test (+ 1073741825 1073741825) 2147483650)+      (num-test (+ 2147483649 -4611686018427387904 -2147483649 4611686018427387904) 0)+      (num-test (+ 1099511627775 9223372036854775807) 9223373136366403582)+      (num-test (+ 576460752303423488 576460752303423488 576460752303423488 576460752303423488+		   576460752303423488 576460752303423488 576460752303423488 576460752303423488+		   576460752303423488 576460752303423488 576460752303423488 576460752303423488+		   576460752303423488 576460752303423488 576460752303423488 576460752303423488)+		9223372036854775808)+      (num-test (+ -576460752303423488 -576460752303423488 -576460752303423488 -576460752303423488+		   -576460752303423488 -576460752303423488 -576460752303423488 -576460752303423488+		   -576460752303423488 -576460752303423488 -576460752303423488 -576460752303423488+		   -576460752303423488 -576460752303423488 -576460752303423488 -576460752303423488)+		-9223372036854775808) ; this fits in both cases = -(expt 2 63)++      (num-test (+ 1e400 1e399) 1.1e400)++      (test (real? 9223372036854775808) #t)+      (test (integer? 9223372036854775808) #t)+      (test (number? 9223372036854775808) #t)+      (test (rational? 9223372036854775808) #t)+      (test (complex? 9223372036854775808) #t)+      (test (positive? 9223372036854775808) #t)+      (test (negative? 9223372036854775808) #f)+      (test (zero? 9223372036854775808) #f)++      (test (real? 9223372036854775808.1) #t)+      (test (integer? 9223372036854775808.1) #f)+      (test (number? 9223372036854775808.1) #t)+      (test (rational? 9223372036854775808.1) #f)+      (test (complex? 9223372036854775808.1) #t)+      (test (positive? 9223372036854775808.1) #t)+      (test (negative? 9223372036854775808.1) #f)+      (test (zero? 9223372036854775808.1) #f)++      (test (real? 9223372036854775808/3) #t)+      (test (integer? 9223372036854775808/3) #f)+      (test (number? 9223372036854775808/3) #t)+      (test (rational? 9223372036854775808/3) #t)+      (test (complex? 9223372036854775808/3) #t)+      (test (positive? 9223372036854775808/3) #t)+      (test (negative? 9223372036854775808/3) #f)+      (test (zero? 9223372036854775808/3) #f)++      (test (real? 9223372036854775808.1+1.5i) #f)+      (test (integer? 9223372036854775808.1+1.5i) #f)+      (test (number? 9223372036854775808.1+1.5i) #t)+      (test (rational? 9223372036854775808.1+1.5i) #f)+      (test (complex? 9223372036854775808.1+1.5i) #t)+      (test (zero? 9223372036854775808.1+1.5i) #f)++      (num-test (+ 2147483647 1) 2147483648)+      (num-test (+ 2147483648 -1) 2147483647)+      (num-test (+ 2147483647 2) 2147483649)+      (num-test (+ 2147483648 -2) 2147483646)+      (num-test (+ 2147483648 1) 2147483649)+      (num-test (+ 2147483649 -1) 2147483648)++      (num-test (+ 9223372036854775807 1) 9223372036854775808)+      (num-test (+ 9223372036854775808 -1) 9223372036854775807)+      (num-test (+ 9223372036854775807 2) 9223372036854775809)+      (num-test (+ 9223372036854775808 -2) 9223372036854775806)+      (num-test (+ 9223372036854775808 1) 9223372036854775809)+      (num-test (+ 9223372036854775809 -1) 9223372036854775808)++      (test (rational? 1234567891234567890/1234567) #t)+      (test (real? 1234567891234567890/1234567) #t)+      (test (complex? 1234567891234567890/1234567) #t)+      (test (number? 1234567891234567890/1234567) #t)+      (test (integer? 1234567891234567890/1234567) #f)++      (num-test (numerator 1234567891234567890/1234567) 1234567891234567890)+      (num-test (denominator 1234567891234567890/1234567) 1234567)++      (num-test (numerator 9223372036854775808/9223372036854775807) 9223372036854775808)+      (num-test (denominator 9223372036854775808/9223372036854775807) 9223372036854775807)++      (num-test (+ 9223372036854775808/9223372036854775808) 1)+      (test (integer? 9223372036854775808/9223372036854775808) #t)++      (test (even? 9223372036854775808) #t)+      (test (odd? 9223372036854775808) #f)+      (test (even? 1234567891234567891) #f)+      (test (odd? 1234567891234567891) #t)+      (test (even? -9223372036854775808) #t)+      (test (odd? -9223372036854775808) #f)+      (test (even? -1234567891234567891) #f)+      (test (odd? -1231234567891234567891) #t)+      (test (even? 1239223372036854775808) #t)+      (test (odd? 1239223372036854775808) #f)+      (test (even? 1231234567891234567891) #f)+      (test (odd? 1231234567891234567891) #t)+      (test (even? -1239223372036854775808) #t)+      (test (odd? -1239223372036854775808) #f)+      (test (even? -1231234567891234567891) #f)+      (test (odd? -1231234567891234567891) #t)+      (test (even? 2147483647) #f)+      (test (even? 2147483648) #t)+      (test (even? 2147483649) #f)+      (test (odd? 2147483647) #t)+      (test (odd? 2147483648) #f)+      (test (odd? 2147483649) #t)+      (test (even? -2147483647) #f)+      (test (even? -2147483648) #t)+      (test (even? -2147483649) #f)+      (test (odd? -2147483647) #t)+      (test (odd? -2147483648) #f)+      (test (odd? -2147483649) #t)++;      (test (even? 9223372036854775808/9223372036854775807) 'error)++      (num-test (numerator (/ 2 -1)) -2)+      (num-test (denominator (/ 2 -1)) 1)+      (num-test (numerator (/ 9223372036854775808 -9223372036854775807)) -9223372036854775808)+      (num-test (denominator (/ 9223372036854775808 -9223372036854775807)) 9223372036854775807)++      (num-test (+ 9223372036854775808 3/4) 36893488147419103235/4)+      (num-test (+ 3/4 9223372036854775808) 36893488147419103235/4)+      (num-test (+ 9223372036854775808/4 3) 2305843009213693955)+      (num-test (+ 3 9223372036854775808/4) 2305843009213693955)+      (num-test (+ 9223372036854775807/4 3) 9223372036854775819/4)+      (num-test (+ 3 9223372036854775807/4) 9223372036854775819/4)+      (num-test (+ 9223372036854775807/4 3/4) 4611686018427387905/2)+      (num-test (+ 3/4 9223372036854775807/4) 4611686018427387905/2)+      (num-test (+ 9223372036854775807/4 3/4 4611686018427387905/2) 4611686018427387905)+      (num-test (+ 9223372036854775807/4 4611686018427387905/3) 46116860184273879041/12)+      (num-test (+ 1/1231234567891234567891 1/4) 1231234567891234567895/4924938271564938271564)+      (num-test (+ 1/65537 1/65538) 131075/4295163906)+      (num-test (+ 1/65537 1/65536) 131073/4295032832)+      (num-test (+ 1/65537 -1/65536) -1/4295032832)+      (num-test (+ 1/65537 -1/65538) 1/4295163906)+      (num-test (+ 1/2147483648 1/2147483647) 4294967295/4611686016279904256)+      (num-test (+ 2147483648) 2147483648)++      (num-test (lcm 557057 23068673 167772161) 2155967190204955525121)+      (num-test (lcm 132120577 33292289) 4398596432330753)+      (num-test (lcm 132120577 33292289 260046847) 1143841133453061178785791)+      (num-test (lcm 2353913150770005286438421033702874906038383291674012942337 9641628265553941653251772554046975615133217962696757011808257) 22695555569123220026272727097682721551725929819788097280747860983024240452040931523149698041303750665450606153441476609)++      (num-test (gcd 2155967190204955525121 12850565775361 93458656690177) 557057)+      (num-test (gcd 2155967190204955525121 -12850565775361 93458656690177) 557057)+      (num-test (gcd 2155967190204955525121 0) 2155967190204955525121)+      (num-test (+ 132120577/12 33292289/6 260046847/4) 244711424/3)+      (num-test (* 132120577/12 33292289/6 260046847/4) 1143841133453061178785791/288)+      (num-test (/ 132120577/12 33292289/6 260046847/4) 264241154/8657554783862783)+      (num-test (+ 1000000000 1000000000 1000000000) 3000000000)+      (num-test (+ -1000000000 -1000000000 -1000000000) -3000000000)+      (num-test (* 1000000000 1000000000 1000000000) 1000000000000000000000000000)+      (num-test (/ 1 1000000000 1000000000 1000000000) 1/1000000000000000000000000000)++      (if with-bigfloats+	  (begin+	    (num-test (+ 9223372036854775808.0 3.4) 9.2233720368547758114E18)+	    (num-test (+ 9223372036854775808.0+1.5i 3.4) 9.2233720368547758114E18+1.5i)++	    (num-test (+ 1.5 9223372036854775808.0) 9.2233720368547758095E18)+	    (num-test (+ 3/2 9223372036854775808.0) 9.2233720368547758095E18)+	    (num-test (+ 1 1/2 9223372036854775808.0) 9.2233720368547758095E18)+	    (num-test (+ 1 1/2 9223372036854775808.0 0+i) 9.2233720368547758095E18+1.0i)+	    (num-test (+ 1 1/2 9223372036854775808.0 0-i) 9.2233720368547758095E18-1.0i)+	    (num-test (+ 1 1/2 0+9223372036854775808.0i 0-i) 1.5+9.223372036854775807E18i)++	    (num-test (real-part 9223372036854775808.0+1.5i) 9.223372036854775808E18)+	    (num-test (imag-part 9223372036854775808.0+1.5i) 1.5)+	    (num-test (real-part 1.5+9223372036854775808.0i) 1.5)+	    (num-test (imag-part 1.5+9223372036854775808.0i) 9.223372036854775808E18)++	    (num-test (real-part 9223372036854775808.0) 9223372036854775808.0)+	    (num-test (imag-part 9223372036854775808.0) 0)+	    (num-test (real-part 0+9223372036854775808.0i) 0.0)+	    (num-test (imag-part 0+9223372036854775808.0i) 9223372036854775808.0)+	    (num-test (real-part 0+1e400i) 0.0)+	    (num-test (imag-part 0+1e400i) 1e400)++	    (num-test (abs 9223372036854775808.0) 9223372036854775808.0)+	    (num-test (abs -9223372036854775808.0) 9223372036854775808.0)++	    (test (exact? 9223372036854775808.1) #f)+	    (test (exact? 9223372036854775808) #t)+	    (test (exact? 9223372036854775808/3) #t)+	    (test (exact? 9223372036854775808.1+1.0i) #f)++	    (test (inexact? 9223372036854775808.1) #t)+	    (test (inexact? 9223372036854775808) #f)+	    (test (inexact? 9223372036854775808/3) #f)+	    (test (inexact? 9223372036854775808.1+1.0i) #t)++	    (num-test (magnitude 9223372036854775808.1) 9223372036854775808.1)+	    (num-test (magnitude 9223372036854775808) 9223372036854775808)+	    (num-test (magnitude 9223372036854775808/3) 9223372036854775808/3)+	    (num-test (magnitude 9223372036854775808.1+1.0e19i) 1.360406526484765934746566522678055771386E19)+	    (num-test (magnitude 1.0e19+9223372036854775808.1i) 1.360406526484765934746566522678055771386E19)+	    ;; maxima's sqrt(2.0) is not very accurate!  use arprec:+	    (num-test (magnitude 14142135623730950488.0168872420969+14142135623730950488.0168872420969i) 1.9999999999999999999999999999999885751772054578776001965575456E19)+++	    ;; these can be checked against arprec -- get tables of the others as well+	    ;;	(num-test (sin 31415926535897932384626433832795028841.971693993751058209749445) 6.8290634690588564658126265428876656461078982456442870201741792E-24)+	    ;; this test requires 500 bits of precision+	    (num-test (sin 31415926535897932384626433832795028841) -8.2584214320186030736155068085595298665361290626210864656288000E-1)+	    (num-test (sin 1.0) 0.84147098480789650665250232163029899962256306079837106567275170999191) ; if bignum here++	    ;;	(num-test (cos 31415926535897932384626433832795028841.971693993751058209749445) 9.9999999999999999999999999999999999999999999997668194606778265E-1)+	    ;; 500 bits+	    (num-test (cos 1.0) 5.4030230586813971740093660744297660373231042061792222767009714E-1)++	      (set! (bignum-precision) old-prec)+	      )))++      (num-test (abs 9223372036854775808/3) 9223372036854775808/3)+      (num-test (abs -9223372036854775808/3) 9223372036854775808/3)++      (num-test (abs 9223372036854775808) 9223372036854775808)+      (num-test (abs -9223372036854775808) 9223372036854775808)++      (num-test (abs 1231234567891234567895/4924938271564938271564) 1231234567891234567895/4924938271564938271564)+      (num-test (abs -1231234567891234567895/4924938271564938271564) 1231234567891234567895/4924938271564938271564)+      (num-test (abs 5/4924938271564938271564) 5/4924938271564938271564)+      (num-test (abs -5/4924938271564938271564) 5/4924938271564938271564)++      (num-test (abs 1231234567891234567895.4924938271564938271564) 1231234567891234567895.4924938271564938271564)+      (num-test (abs -1231234567891234567895.4924938271564938271564) 1231234567891234567895.4924938271564938271564)+      ))+++++;;; --------------------------------------------------------------------------------+;;; string->number and number->string++(test (string->number "+#.#") #f)+(test (string->number "-#.#") #f)+(test (string->number "#.#") #f)+(test (string->number "#i") #f)+(test (string->number "#e") #f)+(test (string->number "#") #f)++;(let ((number-to-string-top 0))+;  (let* ((last-good 0)+;         (first-bad+;          (call/cc+;           (lambda (return)+;             (do ((i 1 (+ i 1))+;                  (k 1 (* k 2)))+;                 ((= i 200) #f)+;               (if (and (eqv? k (string->number (number->string k)))+;                        (eqv? (- k) (string->number (number->string (- k))))+;                        (not (negative? k))) ; might hit sign bit+;                   (set! last-good k)+;                   (if (not (positive? k))+;                       (return (- (* 2 last-good) 1))+;                       (letrec ((search+;                                 (lambda (lo hi)+;                                   (if (= lo hi)+;                                       hi+;                                       (let ((mid (inexact->exact (floor (/ (+ hi lo) 2)))))+;                                         (if (or (>= mid hi)+;                                                 (<= mid lo))+;                                             mid+;                                             (if (and (eqv? mid (string->number (number->string mid)))+;                                                      (eqv? (- mid) (string->number (number->string (- mid)))))+;                                                 (search mid hi)+;                                                 (search lo mid))))))))+;                         (return (search last-good (- (* 2 last-good) 1)))))))))))+;    (set! number-to-string-top first-bad)+;    (if (and (integer? first-bad)+;             (or (not (defined? 'most-positive-fixnum))+;                 (< first-bad most-positive-fixnum)))+;        (begin+;          (display "string->number ints fail around ")+;          (display first-bad)+;          (display " (2^")+;          (display (/ (log first-bad) (log 2.0)))+;          (display ")")+;          (newline))))++;(let* ((last-good 0)+;       (first-bad+;        (call/cc+;         (lambda (return)+;           (do ((i 1 (+ i 1))+;                (k 1.0 (* k 2.0)))+;               ((= i 1200) #f)+;             (if (and (eqv? k (string->number (number->string k)))+;                      (eqv? (- k) (string->number (number->string (- k)))))+;                 (set! last-good k)+;                 (letrec ((search+;                           (lambda (lo hi)+;                             (if (= (inexact->exact (floor lo)) (inexact->exact (floor hi)))+;                                 hi+;                                 (let ((mid (/ (+ hi lo) 2)))+;                                   (if (or (>= mid hi)+;                                           (<= mid lo))+;                                       mid+;                                       (if (and (eqv? mid (string->number (number->string mid)))+;                                                (eqv? (- mid) (string->number (number->string (- mid)))))+;                                           (search mid hi)+;                                           (search lo mid))))))))+;                   (return (search last-good (* 2 last-good))))))))))+;  (if (and (number? first-bad)+;           (< first-bad (+ 1.0 first-bad))) ; else infinite I guess+;      (begin+;        (display "string->number floats fail around ")  ; (eqv? (string->number (number->string 1e-10)) 1e-10)+;        (display first-bad)+;        (display " (2^")+;        (display (/ (log first-bad) (log 2.0)))+;        (display ")")+;        (newline))))++;(let* ((last-good 0)+;       (first-bad+;        (call/cc+;         (lambda (return)+;           (do ((i 1 (+ i 1))+;                (k 1.0 (/ k 2.0)))+;               ((= i 100) #f)+;             (if (and (< (abs (- k (string->number (number->string k)))) (/ k 1e14)) ; 1e18 is ok too+;                      (< (abs (- (- k) (string->number (number->string (- k))))) (/ k 1e14)))+;                 ;; this gets confused (in eqv?) by .999.... -> 1+;                 (set! last-good k)+;                 (letrec ((search+;                           (lambda (lo hi)+;                             (if (= (inexact->exact (floor (/ 1.0 lo))) (inexact->exact (floor (/ 1.0 hi))))+;                                 hi+;                                 (let ((mid (/ (+ hi lo) 2)))+;                                   (if (or (>= mid hi)+;                                           (<= mid lo))+;                                       mid+;                                       (if (and (eqv? mid (string->number (number->string mid)))+;                                                (eqv? (- mid) (string->number (number->string (- mid)))))+;                                           (search mid hi)+;                                           (search lo mid))))))))+;                   (return (search (/ last-good 2.0) last-good)))))))))+;  (if (number? first-bad)+;      (begin+;        (display "string->number floats fail around ")+;        (display first-bad)+;        (display " (2^")+;        (display (/ (log first-bad) (log 2.0)))+;        (display ")")+;        (newline))))++;(let* ((last-good 0)+;       (first-bad+;        (call/cc+;         (lambda (return)+;           (do ((i 1 (+ i 1))+;                (k 1/3 (* k 2)))+;               ((= i 100) #f)+;             (if (and (eqv? k (string->number (number->string k)))+;                      (eqv? (- k) (string->number (number->string (- k)))))+;                 (set! last-good k)+;                 (letrec ((search+;                           (lambda (lo hi)+;                             (if (= (inexact->exact (floor lo)) (inexact->exact (floor hi)))+;                                 hi+;                                 (let ((mid (/ (+ hi lo) 2)))+;                                   (if (or (>= mid hi)+;                                           (<= mid lo))+;                                       mid+;                                       (if (and (eqv? mid (string->number (number->string mid)))+;                                                (eqv? (- mid) (string->number (number->string (- mid)))))+;                                           (search mid hi)+;                                           (search lo mid))))))))+;                   (return (search last-good (* 2 last-good))))))))))+;  (if (number? first-bad)+;      (begin+;        (display "string->number ratios fail around ")+;        (display first-bad)+;        (display " (2^")+;        (display (/ (log first-bad) (log 2.0)))+;        (display ")")+;        (newline))))+++;(if (not (eqv? 0 (string->number (number->string 0))))+;    (begin (display "(string<->number 0) -> ") (display (number->string 0))+;           (display " -> ") (display (string->number (number->string 0))) (newline)))+;(if (not (eqv? 1 (string->number (number->string 1))))+;    (begin (display "(string<->number 1) -> ") (display (number->string 1))+;           (display " -> ") (display (string->number (number->string 1))) (newline)))+;(if (not (eqv? 2 (string->number (number->string 2))))+;    (begin (display "(string<->number 2) -> ") (display (number->string 2))+;           (display " -> ") (display (string->number (number->string 2))) (newline)))+;(if (not (eqv? 3 (string->number (number->string 3))))+;    (begin (display "(string<->number 3) -> ") (display (number->string 3))+;           (display " -> ") (display (string->number (number->string 3))) (newline)))+;(if (not (eqv? 10 (string->number (number->string 10))))+;    (begin (display "(string<->number 10) -> ") (display (number->string 10))+;           (display " -> ") (display (string->number (number->string 10))) (newline)))+;(if (not (eqv? 1234 (string->number (number->string 1234))))+;    (begin (display "(string<->number 1234) -> ") (display (number->string 1234))+;           (display " -> ") (display (string->number (number->string 1234))) (newline)))+;(if (not (eqv? 1234000000 (string->number (number->string 1234000000))))+;    (begin (display "(string<->number 1234000000) -> ") (display (number->string 1234000000))+;           (display " -> ") (display (string->number (number->string 1234000000))) (newline)))+;(if (not (eqv? 500029 (string->number (number->string 500029))))+;    (begin (display "(string<->number 500029) -> ") (display (number->string 500029))+;           (display " -> ") (display (string->number (number->string 500029))) (newline)))+;(if (not (eqv? 362880 (string->number (number->string 362880))))+;    (begin (display "(string<->number 362880) -> ") (display (number->string 362880))+;           (display " -> ") (display (string->number (number->string 362880))) (newline)))+;(if (not (eqv? 0/1 (string->number (number->string 0/1))))+;        (begin (display "(string<->number 0/1) -> ") (display (number->string 0/1))+;               (display " -> ") (display (string->number (number->string 0/1))) (newline)))+;(if (not (eqv? 0/2 (string->number (number->string 0/2))))+;        (begin (display "(string<->number 0/2) -> ") (display (number->string 0/2))+;               (display " -> ") (display (string->number (number->string 0/2))) (newline)))+;(if (not (eqv? 0/3 (string->number (number->string 0/3))))+;        (begin (display "(string<->number 0/3) -> ") (display (number->string 0/3))+;               (display " -> ") (display (string->number (number->string 0/3))) (newline)))+;(if (not (eqv? 0/10 (string->number (number->string 0/10))))+;        (begin (display "(string<->number 0/10) -> ") (display (number->string 0/10))+;               (display " -> ") (display (string->number (number->string 0/10))) (newline)))+;(if (not (eqv? 0/1234 (string->number (number->string 0/1234))))+;        (begin (display "(string<->number 0/1234) -> ") (display (number->string 0/1234))+;               (display " -> ") (display (string->number (number->string 0/1234))) (newline)))+;(if (not (eqv? 0/1234000000 (string->number (number->string 0/1234000000))))+;        (begin (display "(string<->number 0/1234000000) -> ") (display (number->string 0/1234000000))+;               (display " -> ") (display (string->number (number->string 0/1234000000))) (newline)))+;(if (not (eqv? 0/500029 (string->number (number->string 0/500029))))+;        (begin (display "(string<->number 0/500029) -> ") (display (number->string 0/500029))+;               (display " -> ") (display (string->number (number->string 0/500029))) (newline)))+;(if (not (eqv? 0/362880 (string->number (number->string 0/362880))))+;        (begin (display "(string<->number 0/362880) -> ") (display (number->string 0/362880))+;               (display " -> ") (display (string->number (number->string 0/362880))) (newline)))+;(if (not (eqv? 1/1 (string->number (number->string 1/1))))+;        (begin (display "(string<->number 1/1) -> ") (display (number->string 1/1))+;               (display " -> ") (display (string->number (number->string 1/1))) (newline)))+;(if (not (eqv? 1/2 (string->number (number->string 1/2))))+;        (begin (display "(string<->number 1/2) -> ") (display (number->string 1/2))+;               (display " -> ") (display (string->number (number->string 1/2))) (newline)))+;(if (not (eqv? 1/3 (string->number (number->string 1/3))))+;        (begin (display "(string<->number 1/3) -> ") (display (number->string 1/3))+;               (display " -> ") (display (string->number (number->string 1/3))) (newline)))+;(if (not (eqv? 1/10 (string->number (number->string 1/10))))+;        (begin (display "(string<->number 1/10) -> ") (display (number->string 1/10))+;               (display " -> ") (display (string->number (number->string 1/10))) (newline)))+;(if (not (eqv? 1/1234 (string->number (number->string 1/1234))))+;        (begin (display "(string<->number 1/1234) -> ") (display (number->string 1/1234))+;               (display " -> ") (display (string->number (number->string 1/1234))) (newline)))+;(if (not (eqv? 1/1234000000 (string->number (number->string 1/1234000000))))+;        (begin (display "(string<->number 1/1234000000) -> ") (display (number->string 1/1234000000))+;               (display " -> ") (display (string->number (number->string 1/1234000000))) (newline)))+;(if (not (eqv? 1/500029 (string->number (number->string 1/500029))))+;        (begin (display "(string<->number 1/500029) -> ") (display (number->string 1/500029))+;               (display " -> ") (display (string->number (number->string 1/500029))) (newline)))+;(if (not (eqv? 1/362880 (string->number (number->string 1/362880))))+;        (begin (display "(string<->number 1/362880) -> ") (display (number->string 1/362880))+;               (display " -> ") (display (string->number (number->string 1/362880))) (newline)))+;(if (not (eqv? 2/1 (string->number (number->string 2/1))))+;        (begin (display "(string<->number 2/1) -> ") (display (number->string 2/1))+;               (display " -> ") (display (string->number (number->string 2/1))) (newline)))+;(if (not (eqv? 2/2 (string->number (number->string 2/2))))+;        (begin (display "(string<->number 2/2) -> ") (display (number->string 2/2))+;               (display " -> ") (display (string->number (number->string 2/2))) (newline)))+;(if (not (eqv? 2/3 (string->number (number->string 2/3))))+;        (begin (display "(string<->number 2/3) -> ") (display (number->string 2/3))+;               (display " -> ") (display (string->number (number->string 2/3))) (newline)))+;(if (not (eqv? 2/10 (string->number (number->string 2/10))))+;        (begin (display "(string<->number 2/10) -> ") (display (number->string 2/10))+;               (display " -> ") (display (string->number (number->string 2/10))) (newline)))+;(if (not (eqv? 2/1234 (string->number (number->string 2/1234))))+;        (begin (display "(string<->number 2/1234) -> ") (display (number->string 2/1234))+;               (display " -> ") (display (string->number (number->string 2/1234))) (newline)))+;(if (not (eqv? 2/1234000000 (string->number (number->string 2/1234000000))))+;        (begin (display "(string<->number 2/1234000000) -> ") (display (number->string 2/1234000000))+;               (display " -> ") (display (string->number (number->string 2/1234000000))) (newline)))+;(if (not (eqv? 2/500029 (string->number (number->string 2/500029))))+;        (begin (display "(string<->number 2/500029) -> ") (display (number->string 2/500029))+;               (display " -> ") (display (string->number (number->string 2/500029))) (newline)))+;(if (not (eqv? 2/362880 (string->number (number->string 2/362880))))+;        (begin (display "(string<->number 2/362880) -> ") (display (number->string 2/362880))+;               (display " -> ") (display (string->number (number->string 2/362880))) (newline)))+;(if (not (eqv? 3/1 (string->number (number->string 3/1))))+;        (begin (display "(string<->number 3/1) -> ") (display (number->string 3/1))+;               (display " -> ") (display (string->number (number->string 3/1))) (newline)))+;(if (not (eqv? 3/2 (string->number (number->string 3/2))))+;        (begin (display "(string<->number 3/2) -> ") (display (number->string 3/2))+;               (display " -> ") (display (string->number (number->string 3/2))) (newline)))+;(if (not (eqv? 3/3 (string->number (number->string 3/3))))+;        (begin (display "(string<->number 3/3) -> ") (display (number->string 3/3))+;               (display " -> ") (display (string->number (number->string 3/3))) (newline)))+;(if (not (eqv? 3/10 (string->number (number->string 3/10))))+;        (begin (display "(string<->number 3/10) -> ") (display (number->string 3/10))+;               (display " -> ") (display (string->number (number->string 3/10))) (newline)))+;(if (not (eqv? 3/1234 (string->number (number->string 3/1234))))+;        (begin (display "(string<->number 3/1234) -> ") (display (number->string 3/1234))+;               (display " -> ") (display (string->number (number->string 3/1234))) (newline)))+;(if (not (eqv? 3/1234000000 (string->number (number->string 3/1234000000))))+;        (begin (display "(string<->number 3/1234000000) -> ") (display (number->string 3/1234000000))+;               (display " -> ") (display (string->number (number->string 3/1234000000))) (newline)))+;(if (not (eqv? 3/500029 (string->number (number->string 3/500029))))+;        (begin (display "(string<->number 3/500029) -> ") (display (number->string 3/500029))+;               (display " -> ") (display (string->number (number->string 3/500029))) (newline)))+;(if (not (eqv? 3/362880 (string->number (number->string 3/362880))))+;        (begin (display "(string<->number 3/362880) -> ") (display (number->string 3/362880))+;               (display " -> ") (display (string->number (number->string 3/362880))) (newline)))+;(if (not (eqv? 10/1 (string->number (number->string 10/1))))+;        (begin (display "(string<->number 10/1) -> ") (display (number->string 10/1))+;               (display " -> ") (display (string->number (number->string 10/1))) (newline)))+;(if (not (eqv? 10/2 (string->number (number->string 10/2))))+;        (begin (display "(string<->number 10/2) -> ") (display (number->string 10/2))+;               (display " -> ") (display (string->number (number->string 10/2))) (newline)))+;(if (not (eqv? 10/3 (string->number (number->string 10/3))))+;        (begin (display "(string<->number 10/3) -> ") (display (number->string 10/3))+;               (display " -> ") (display (string->number (number->string 10/3))) (newline)))+;(if (not (eqv? 10/10 (string->number (number->string 10/10))))+;        (begin (display "(string<->number 10/10) -> ") (display (number->string 10/10))+;               (display " -> ") (display (string->number (number->string 10/10))) (newline)))+;(if (not (eqv? 10/1234 (string->number (number->string 10/1234))))+;        (begin (display "(string<->number 10/1234) -> ") (display (number->string 10/1234))+;               (display " -> ") (display (string->number (number->string 10/1234))) (newline)))+;(if (not (eqv? 10/1234000000 (string->number (number->string 10/1234000000))))+;        (begin (display "(string<->number 10/1234000000) -> ") (display (number->string 10/1234000000))+;               (display " -> ") (display (string->number (number->string 10/1234000000))) (newline)))+;(if (not (eqv? 10/500029 (string->number (number->string 10/500029))))+;        (begin (display "(string<->number 10/500029) -> ") (display (number->string 10/500029))+;               (display " -> ") (display (string->number (number->string 10/500029))) (newline)))+;(if (not (eqv? 10/362880 (string->number (number->string 10/362880))))+;        (begin (display "(string<->number 10/362880) -> ") (display (number->string 10/362880))+;               (display " -> ") (display (string->number (number->string 10/362880))) (newline)))+;(if (not (eqv? 1234/1 (string->number (number->string 1234/1))))+;        (begin (display "(string<->number 1234/1) -> ") (display (number->string 1234/1))+;               (display " -> ") (display (string->number (number->string 1234/1))) (newline)))+;(if (not (eqv? 1234/2 (string->number (number->string 1234/2))))+;        (begin (display "(string<->number 1234/2) -> ") (display (number->string 1234/2))+;               (display " -> ") (display (string->number (number->string 1234/2))) (newline)))+;(if (not (eqv? 1234/3 (string->number (number->string 1234/3))))+;        (begin (display "(string<->number 1234/3) -> ") (display (number->string 1234/3))+;               (display " -> ") (display (string->number (number->string 1234/3))) (newline)))+;(if (not (eqv? 1234/10 (string->number (number->string 1234/10))))+;        (begin (display "(string<->number 1234/10) -> ") (display (number->string 1234/10))+;               (display " -> ") (display (string->number (number->string 1234/10))) (newline)))+;(if (not (eqv? 1234/1234 (string->number (number->string 1234/1234))))+;        (begin (display "(string<->number 1234/1234) -> ") (display (number->string 1234/1234))+;               (display " -> ") (display (string->number (number->string 1234/1234))) (newline)))+;(if (not (eqv? 1234/1234000000 (string->number (number->string 1234/1234000000))))+;        (begin (display "(string<->number 1234/1234000000) -> ") (display (number->string 1234/1234000000))+;               (display " -> ") (display (string->number (number->string 1234/1234000000))) (newline)))+;(if (not (eqv? 1234/500029 (string->number (number->string 1234/500029))))+;        (begin (display "(string<->number 1234/500029) -> ") (display (number->string 1234/500029))+;               (display " -> ") (display (string->number (number->string 1234/500029))) (newline)))+;(if (not (eqv? 1234/362880 (string->number (number->string 1234/362880))))+;        (begin (display "(string<->number 1234/362880) -> ") (display (number->string 1234/362880))+;               (display " -> ") (display (string->number (number->string 1234/362880))) (newline)))+;(if (not (eqv? 1234000000/1 (string->number (number->string 1234000000/1))))+;        (begin (display "(string<->number 1234000000/1) -> ") (display (number->string 1234000000/1))+;               (display " -> ") (display (string->number (number->string 1234000000/1))) (newline)))+;(if (not (eqv? 1234000000/2 (string->number (number->string 1234000000/2))))+;        (begin (display "(string<->number 1234000000/2) -> ") (display (number->string 1234000000/2))+;               (display " -> ") (display (string->number (number->string 1234000000/2))) (newline)))+;(if (not (eqv? 1234000000/3 (string->number (number->string 1234000000/3))))+;        (begin (display "(string<->number 1234000000/3) -> ") (display (number->string 1234000000/3))+;               (display " -> ") (display (string->number (number->string 1234000000/3))) (newline)))+;(if (not (eqv? 1234000000/10 (string->number (number->string 1234000000/10))))+;        (begin (display "(string<->number 1234000000/10) -> ") (display (number->string 1234000000/10))+;               (display " -> ") (display (string->number (number->string 1234000000/10))) (newline)))+;(if (not (eqv? 1234000000/1234 (string->number (number->string 1234000000/1234))))+;        (begin (display "(string<->number 1234000000/1234) -> ") (display (number->string 1234000000/1234))+;               (display " -> ") (display (string->number (number->string 1234000000/1234))) (newline)))+;(if (not (eqv? 1234000000/1234000000 (string->number (number->string 1234000000/1234000000))))+;        (begin (display "(string<->number 1234000000/1234000000) -> ") (display (number->string 1234000000/1234000000))+;               (display " -> ") (display (string->number (number->string 1234000000/1234000000))) (newline)))+;(if (not (eqv? 1234000000/500029 (string->number (number->string 1234000000/500029))))+;        (begin (display "(string<->number 1234000000/500029) -> ") (display (number->string 1234000000/500029))+;               (display " -> ") (display (string->number (number->string 1234000000/500029))) (newline)))+;(if (not (eqv? 1234000000/362880 (string->number (number->string 1234000000/362880))))+;        (begin (display "(string<->number 1234000000/362880) -> ") (display (number->string 1234000000/362880))+;               (display " -> ") (display (string->number (number->string 1234000000/362880))) (newline)))+;(if (not (eqv? 500029/1 (string->number (number->string 500029/1))))+;        (begin (display "(string<->number 500029/1) -> ") (display (number->string 500029/1))+;               (display " -> ") (display (string->number (number->string 500029/1))) (newline)))+;(if (not (eqv? 500029/2 (string->number (number->string 500029/2))))+;        (begin (display "(string<->number 500029/2) -> ") (display (number->string 500029/2))+;               (display " -> ") (display (string->number (number->string 500029/2))) (newline)))+;(if (not (eqv? 500029/3 (string->number (number->string 500029/3))))+;        (begin (display "(string<->number 500029/3) -> ") (display (number->string 500029/3))+;               (display " -> ") (display (string->number (number->string 500029/3))) (newline)))+;(if (not (eqv? 500029/10 (string->number (number->string 500029/10))))+;        (begin (display "(string<->number 500029/10) -> ") (display (number->string 500029/10))+;               (display " -> ") (display (string->number (number->string 500029/10))) (newline)))+;(if (not (eqv? 500029/1234 (string->number (number->string 500029/1234))))+;        (begin (display "(string<->number 500029/1234) -> ") (display (number->string 500029/1234))+;               (display " -> ") (display (string->number (number->string 500029/1234))) (newline)))+;(if (not (eqv? 500029/1234000000 (string->number (number->string 500029/1234000000))))+;        (begin (display "(string<->number 500029/1234000000) -> ") (display (number->string 500029/1234000000))+;               (display " -> ") (display (string->number (number->string 500029/1234000000))) (newline)))+;(if (not (eqv? 500029/500029 (string->number (number->string 500029/500029))))+;        (begin (display "(string<->number 500029/500029) -> ") (display (number->string 500029/500029))+;               (display " -> ") (display (string->number (number->string 500029/500029))) (newline)))+;(if (not (eqv? 500029/362880 (string->number (number->string 500029/362880))))+;        (begin (display "(string<->number 500029/362880) -> ") (display (number->string 500029/362880))+;               (display " -> ") (display (string->number (number->string 500029/362880))) (newline)))+;(if (not (eqv? 362880/1 (string->number (number->string 362880/1))))+;        (begin (display "(string<->number 362880/1) -> ") (display (number->string 362880/1))+;               (display " -> ") (display (string->number (number->string 362880/1))) (newline)))+;(if (not (eqv? 362880/2 (string->number (number->string 362880/2))))+;        (begin (display "(string<->number 362880/2) -> ") (display (number->string 362880/2))+;               (display " -> ") (display (string->number (number->string 362880/2))) (newline)))+;(if (not (eqv? 362880/3 (string->number (number->string 362880/3))))+;        (begin (display "(string<->number 362880/3) -> ") (display (number->string 362880/3))+;               (display " -> ") (display (string->number (number->string 362880/3))) (newline)))+;(if (not (eqv? 362880/10 (string->number (number->string 362880/10))))+;        (begin (display "(string<->number 362880/10) -> ") (display (number->string 362880/10))+;               (display " -> ") (display (string->number (number->string 362880/10))) (newline)))+;(if (not (eqv? 362880/1234 (string->number (number->string 362880/1234))))+;        (begin (display "(string<->number 362880/1234) -> ") (display (number->string 362880/1234))+;               (display " -> ") (display (string->number (number->string 362880/1234))) (newline)))+;(if (not (eqv? 362880/1234000000 (string->number (number->string 362880/1234000000))))+;        (begin (display "(string<->number 362880/1234000000) -> ") (display (number->string 362880/1234000000))+;               (display " -> ") (display (string->number (number->string 362880/1234000000))) (newline)))+;(if (not (eqv? 362880/500029 (string->number (number->string 362880/500029))))+;        (begin (display "(string<->number 362880/500029) -> ") (display (number->string 362880/500029))+;               (display " -> ") (display (string->number (number->string 362880/500029))) (newline)))+;(if (not (eqv? 362880/362880 (string->number (number->string 362880/362880))))+;        (begin (display "(string<->number 362880/362880) -> ") (display (number->string 362880/362880))+;               (display " -> ") (display (string->number (number->string 362880/362880))) (newline)))++;(let ((fequal? (lambda (a b) (< (magnitude (- a b)) 1e-14))))+;  (if (not (fequal? 0.000000 (string->number (number->string 0.000000))))+;      (begin (display "(string<->number 0.000000) -> ") (display (number->string 0.000000))+;             (display " -> ") (display (string->number (number->string 0.000000))) (newline)))+;  (if (not (fequal? 0.000000 (string->number (number->string 0.000000))))+;      (begin (display "(string<->number 0.000000) -> ") (display (number->string 0.000000))+;             (display " -> ") (display (string->number (number->string 0.000000))) (newline)))+;  (if (not (fequal? 1.000000 (string->number (number->string 1.000000))))+;      (begin (display "(string<->number 1.000000) -> ") (display (number->string 1.000000))+;             (display " -> ") (display (string->number (number->string 1.000000))) (newline)))+;  (if (not (fequal? 3.141593 (string->number (number->string 3.141593))))+;      (begin (display "(string<->number 3.141593) -> ") (display (number->string 3.141593))+;             (display " -> ") (display (string->number (number->string 3.141593))) (newline)))+;  (if (not (fequal? 2.718282 (string->number (number->string 2.718282))))+;      (begin (display "(string<->number 2.718282) -> ") (display (number->string 2.718282))+;             (display " -> ") (display (string->number (number->string 2.718282))) (newline)))+;  (if (not (fequal? 1234.000000 (string->number (number->string 1234.000000))))+;      (begin (display "(string<->number 1234.000000) -> ") (display (number->string 1234.000000))+;             (display " -> ") (display (string->number (number->string 1234.000000))) (newline)))+;  (if (not (fequal? 1234000000.000000 (string->number (number->string 1234000000.000000))))+;      (begin (display "(string<->number 1234000000.000000) -> ") (display (number->string 1234000000.000000))+;             (display " -> ") (display (string->number (number->string 1234000000.000000))) (newline)))+;  (if (not (fequal? 0.000000+0.000000i (string->number (number->string 0.000000+0.000000i))))+;      (begin (display "(string<->number 0.000000+0.000000i) -> ") (display (number->string 0.000000+0.000000i))+;             (display " -> ") (display (string->number (number->string 0.000000+0.000000i))) (newline)))+;  (if (not (fequal? 0.000000+0.000000i (string->number (number->string 0.000000+0.000000i))))+;      (begin (display "(string<->number 0.000000+0.000000i) -> ") (display (number->string 0.000000+0.000000i))+;             (display " -> ") (display (string->number (number->string 0.000000+0.000000i))) (newline)))+;  (if (not (fequal? 0.000000+1.000000i (string->number (number->string 0.000000+1.000000i))))+;      (begin (display "(string<->number 0.000000+1.000000i) -> ") (display (number->string 0.000000+1.000000i))+;             (display " -> ") (display (string->number (number->string 0.000000+1.000000i))) (newline)))+;  (if (not (fequal? 0.000000+3.141593i (string->number (number->string 0.000000+3.141593i))))+;      (begin (display "(string<->number 0.000000+3.141593i) -> ") (display (number->string 0.000000+3.141593i))+;             (display " -> ") (display (string->number (number->string 0.000000+3.141593i))) (newline)))+;  (if (not (fequal? 0.000000+2.718282i (string->number (number->string 0.000000+2.718282i))))+;      (begin (display "(string<->number 0.000000+2.718282i) -> ") (display (number->string 0.000000+2.718282i))+;             (display " -> ") (display (string->number (number->string 0.000000+2.718282i))) (newline)))+;  (if (not (fequal? 0.000000+1234.000000i (string->number (number->string 0.000000+1234.000000i))))+;      (begin (display "(string<->number 0.000000+1234.000000i) -> ") (display (number->string 0.000000+1234.000000i))+;             (display " -> ") (display (string->number (number->string 0.000000+1234.000000i))) (newline)))+;  (if (not (fequal? 0.000000+1234000000.000000i (string->number (number->string 0.000000+1234000000.000000i))))+;      (begin (display "(string<->number 0.000000+1234000000.000000i) -> ") (display (number->string 0.000000+1234000000.000000i))+;             (display " -> ") (display (string->number (number->string 0.000000+1234000000.000000i))) (newline)))+;  (if (not (fequal? 0.000000+0.000000i (string->number (number->string 0.000000+0.000000i))))+;      (begin (display "(string<->number 0.000000+0.000000i) -> ") (display (number->string 0.000000+0.000000i))+;             (display " -> ") (display (string->number (number->string 0.000000+0.000000i))) (newline)))+;  (if (not (fequal? 0.000000+0.000000i (string->number (number->string 0.000000+0.000000i))))+;      (begin (display "(string<->number 0.000000+0.000000i) -> ") (display (number->string 0.000000+0.000000i))+;             (display " -> ") (display (string->number (number->string 0.000000+0.000000i))) (newline)))+;  (if (not (fequal? 0.000000+1.000000i (string->number (number->string 0.000000+1.000000i))))+;      (begin (display "(string<->number 0.000000+1.000000i) -> ") (display (number->string 0.000000+1.000000i))+;             (display " -> ") (display (string->number (number->string 0.000000+1.000000i))) (newline)))+;  (if (not (fequal? 0.000000+3.141593i (string->number (number->string 0.000000+3.141593i))))+;      (begin (display "(string<->number 0.000000+3.141593i) -> ") (display (number->string 0.000000+3.141593i))+;             (display " -> ") (display (string->number (number->string 0.000000+3.141593i))) (newline)))+;  (if (not (fequal? 0.000000+2.718282i (string->number (number->string 0.000000+2.718282i))))+;      (begin (display "(string<->number 0.000000+2.718282i) -> ") (display (number->string 0.000000+2.718282i))+;             (display " -> ") (display (string->number (number->string 0.000000+2.718282i))) (newline)))+;  (if (not (fequal? 0.000000+1234.000000i (string->number (number->string 0.000000+1234.000000i))))+;      (begin (display "(string<->number 0.000000+1234.000000i) -> ") (display (number->string 0.000000+1234.000000i))+;             (display " -> ") (display (string->number (number->string 0.000000+1234.000000i))) (newline)))+;  (if (not (fequal? 0.000000+1234000000.000000i (string->number (number->string 0.000000+1234000000.000000i))))+;      (begin (display "(string<->number 0.000000+1234000000.000000i) -> ") (display (number->string 0.000000+1234000000.000000i))+;             (display " -> ") (display (string->number (number->string 0.000000+1234000000.000000i))) (newline)))+;  (if (not (fequal? 1.000000+0.000000i (string->number (number->string 1.000000+0.000000i))))+;      (begin (display "(string<->number 1.000000+0.000000i) -> ") (display (number->string 1.000000+0.000000i))+;             (display " -> ") (display (string->number (number->string 1.000000+0.000000i))) (newline)))+;  (if (not (fequal? 1.000000+0.000000i (string->number (number->string 1.000000+0.000000i))))+;      (begin (display "(string<->number 1.000000+0.000000i) -> ") (display (number->string 1.000000+0.000000i))+;             (display " -> ") (display (string->number (number->string 1.000000+0.000000i))) (newline)))+;  (if (not (fequal? 1.000000+1.000000i (string->number (number->string 1.000000+1.000000i))))+;      (begin (display "(string<->number 1.000000+1.000000i) -> ") (display (number->string 1.000000+1.000000i))+;             (display " -> ") (display (string->number (number->string 1.000000+1.000000i))) (newline)))+;  (if (not (fequal? 1.000000+3.141593i (string->number (number->string 1.000000+3.141593i))))+;      (begin (display "(string<->number 1.000000+3.141593i) -> ") (display (number->string 1.000000+3.141593i))+;             (display " -> ") (display (string->number (number->string 1.000000+3.141593i))) (newline)))+;  (if (not (fequal? 1.000000+2.718282i (string->number (number->string 1.000000+2.718282i))))+;      (begin (display "(string<->number 1.000000+2.718282i) -> ") (display (number->string 1.000000+2.718282i))+;             (display " -> ") (display (string->number (number->string 1.000000+2.718282i))) (newline)))+;  (if (not (fequal? 1.000000+1234.000000i (string->number (number->string 1.000000+1234.000000i))))+;      (begin (display "(string<->number 1.000000+1234.000000i) -> ") (display (number->string 1.000000+1234.000000i))+;             (display " -> ") (display (string->number (number->string 1.000000+1234.000000i))) (newline)))+;  (if (not (fequal? 1.000000+1234000000.000000i (string->number (number->string 1.000000+1234000000.000000i))))+;      (begin (display "(string<->number 1.000000+1234000000.000000i) -> ") (display (number->string 1.000000+1234000000.000000i))+;             (display " -> ") (display (string->number (number->string 1.000000+1234000000.000000i))) (newline)))+;  (if (not (fequal? 3.141593+0.000000i (string->number (number->string 3.141593+0.000000i))))+;      (begin (display "(string<->number 3.141593+0.000000i) -> ") (display (number->string 3.141593+0.000000i))+;             (display " -> ") (display (string->number (number->string 3.141593+0.000000i))) (newline)))+;  (if (not (fequal? 3.141593+0.000000i (string->number (number->string 3.141593+0.000000i))))+;      (begin (display "(string<->number 3.141593+0.000000i) -> ") (display (number->string 3.141593+0.000000i))+;             (display " -> ") (display (string->number (number->string 3.141593+0.000000i))) (newline)))+;  (if (not (fequal? 3.141593+1.000000i (string->number (number->string 3.141593+1.000000i))))+;      (begin (display "(string<->number 3.141593+1.000000i) -> ") (display (number->string 3.141593+1.000000i))+;             (display " -> ") (display (string->number (number->string 3.141593+1.000000i))) (newline)))+;  (if (not (fequal? 3.141593+3.141593i (string->number (number->string 3.141593+3.141593i))))+;      (begin (display "(string<->number 3.141593+3.141593i) -> ") (display (number->string 3.141593+3.141593i))+;             (display " -> ") (display (string->number (number->string 3.141593+3.141593i))) (newline)))+;  (if (not (fequal? 3.141593+2.718282i (string->number (number->string 3.141593+2.718282i))))+;      (begin (display "(string<->number 3.141593+2.718282i) -> ") (display (number->string 3.141593+2.718282i))+;             (display " -> ") (display (string->number (number->string 3.141593+2.718282i))) (newline)))+;  (if (not (fequal? 3.141593+1234.000000i (string->number (number->string 3.141593+1234.000000i))))+;      (begin (display "(string<->number 3.141593+1234.000000i) -> ") (display (number->string 3.141593+1234.000000i))+;             (display " -> ") (display (string->number (number->string 3.141593+1234.000000i))) (newline)))+;  (if (not (fequal? 3.141593+1234000000.000000i (string->number (number->string 3.141593+1234000000.000000i))))+;      (begin (display "(string<->number 3.141593+1234000000.000000i) -> ") (display (number->string 3.141593+1234000000.000000i))+;             (display " -> ") (display (string->number (number->string 3.141593+1234000000.000000i))) (newline)))+;  (if (not (fequal? 2.718282+0.000000i (string->number (number->string 2.718282+0.000000i))))+;      (begin (display "(string<->number 2.718282+0.000000i) -> ") (display (number->string 2.718282+0.000000i))+;             (display " -> ") (display (string->number (number->string 2.718282+0.000000i))) (newline)))+;  (if (not (fequal? 2.718282+0.000000i (string->number (number->string 2.718282+0.000000i))))+;      (begin (display "(string<->number 2.718282+0.000000i) -> ") (display (number->string 2.718282+0.000000i))+;             (display " -> ") (display (string->number (number->string 2.718282+0.000000i))) (newline)))+;  (if (not (fequal? 2.718282+1.000000i (string->number (number->string 2.718282+1.000000i))))+;      (begin (display "(string<->number 2.718282+1.000000i) -> ") (display (number->string 2.718282+1.000000i))+;             (display " -> ") (display (string->number (number->string 2.718282+1.000000i))) (newline)))+;  (if (not (fequal? 2.718282+3.141593i (string->number (number->string 2.718282+3.141593i))))+;      (begin (display "(string<->number 2.718282+3.141593i) -> ") (display (number->string 2.718282+3.141593i))+;             (display " -> ") (display (string->number (number->string 2.718282+3.141593i))) (newline)))+;  (if (not (fequal? 2.718282+2.718282i (string->number (number->string 2.718282+2.718282i))))+;      (begin (display "(string<->number 2.718282+2.718282i) -> ") (display (number->string 2.718282+2.718282i))+;             (display " -> ") (display (string->number (number->string 2.718282+2.718282i))) (newline)))+;  (if (not (fequal? 2.718282+1234.000000i (string->number (number->string 2.718282+1234.000000i))))+;      (begin (display "(string<->number 2.718282+1234.000000i) -> ") (display (number->string 2.718282+1234.000000i))+;             (display " -> ") (display (string->number (number->string 2.718282+1234.000000i))) (newline)))+;  (if (not (fequal? 2.718282+1234000000.000000i (string->number (number->string 2.718282+1234000000.000000i))))+;      (begin (display "(string<->number 2.718282+1234000000.000000i) -> ") (display (number->string 2.718282+1234000000.000000i))+;             (display " -> ") (display (string->number (number->string 2.718282+1234000000.000000i))) (newline)))+;  (if (not (fequal? 1234.000000+0.000000i (string->number (number->string 1234.000000+0.000000i))))+;      (begin (display "(string<->number 1234.000000+0.000000i) -> ") (display (number->string 1234.000000+0.000000i))+;             (display " -> ") (display (string->number (number->string 1234.000000+0.000000i))) (newline)))+;  (if (not (fequal? 1234.000000+0.000000i (string->number (number->string 1234.000000+0.000000i))))+;      (begin (display "(string<->number 1234.000000+0.000000i) -> ") (display (number->string 1234.000000+0.000000i))+;             (display " -> ") (display (string->number (number->string 1234.000000+0.000000i))) (newline)))+;  (if (not (fequal? 1234.000000+1.000000i (string->number (number->string 1234.000000+1.000000i))))+;      (begin (display "(string<->number 1234.000000+1.000000i) -> ") (display (number->string 1234.000000+1.000000i))+;             (display " -> ") (display (string->number (number->string 1234.000000+1.000000i))) (newline)))+;  (if (not (fequal? 1234.000000+3.141593i (string->number (number->string 1234.000000+3.141593i))))+;      (begin (display "(string<->number 1234.000000+3.141593i) -> ") (display (number->string 1234.000000+3.141593i))+;             (display " -> ") (display (string->number (number->string 1234.000000+3.141593i))) (newline)))+;  (if (not (fequal? 1234.000000+2.718282i (string->number (number->string 1234.000000+2.718282i))))+;      (begin (display "(string<->number 1234.000000+2.718282i) -> ") (display (number->string 1234.000000+2.718282i))+;             (display " -> ") (display (string->number (number->string 1234.000000+2.718282i))) (newline)))+;  (if (not (fequal? 1234.000000+1234.000000i (string->number (number->string 1234.000000+1234.000000i))))+;      (begin (display "(string<->number 1234.000000+1234.000000i) -> ") (display (number->string 1234.000000+1234.000000i))+;             (display " -> ") (display (string->number (number->string 1234.000000+1234.000000i))) (newline)))+;  (if (not (fequal? 1234.000000+1234000000.000000i (string->number (number->string 1234.000000+1234000000.000000i))))+;      (begin (display "(string<->number 1234.000000+1234000000.000000i) -> ") (display (number->string 1234.000000+1234000000.000000i))+;             (display " -> ") (display (string->number (number->string 1234.000000+1234000000.000000i))) (newline)))+;  (if (not (fequal? 1234000000.000000+0.000000i (string->number (number->string 1234000000.000000+0.000000i))))+;      (begin (display "(string<->number 1234000000.000000+0.000000i) -> ") (display (number->string 1234000000.000000+0.000000i))+;             (display " -> ") (display (string->number (number->string 1234000000.000000+0.000000i))) (newline)))+;  (if (not (fequal? 1234000000.000000+0.000000i (string->number (number->string 1234000000.000000+0.000000i))))+;      (begin (display "(string<->number 1234000000.000000+0.000000i) -> ") (display (number->string 1234000000.000000+0.000000i))+;             (display " -> ") (display (string->number (number->string 1234000000.000000+0.000000i))) (newline)))+;  (if (not (fequal? 1234000000.000000+1.000000i (string->number (number->string 1234000000.000000+1.000000i))))+;      (begin (display "(string<->number 1234000000.000000+1.000000i) -> ") (display (number->string 1234000000.000000+1.000000i))+;             (display " -> ") (display (string->number (number->string 1234000000.000000+1.000000i))) (newline)))+;  (if (not (fequal? 1234000000.000000+3.141593i (string->number (number->string 1234000000.000000+3.141593i))))+;      (begin (display "(string<->number 1234000000.000000+3.141593i) -> ") (display (number->string 1234000000.000000+3.141593i))+;             (display " -> ") (display (string->number (number->string 1234000000.000000+3.141593i))) (newline)))+;  (if (not (fequal? 1234000000.000000+2.718282i (string->number (number->string 1234000000.000000+2.718282i))))+;      (begin (display "(string<->number 1234000000.000000+2.718282i) -> ") (display (number->string 1234000000.000000+2.718282i))+;             (display " -> ") (display (string->number (number->string 1234000000.000000+2.718282i))) (newline)))+;  (if (not (fequal? 1234000000.000000+1234.000000i (string->number (number->string 1234000000.000000+1234.000000i))))+;      (begin (display "(string<->number 1234000000.000000+1234.000000i) -> ") (display (number->string 1234000000.000000+1234.000000i))+;             (display " -> ") (display (string->number (number->string 1234000000.000000+1234.000000i))) (newline)))+;  (if (not (fequal? 1234000000.000000+1234000000.000000i (string->number (number->string 1234000000.000000+1234000000.000000i))))+;      (begin (display "(string<->number 1234000000.000000+1234000000.000000i) -> ") (display (number->string 1234000000.000000+1234000000.000000i))+;             (display " -> ") (display (string->number (number->string 1234000000.000000+1234000000.000000i))) (newline)))+;  (if (not with-bigfloats)+;      (begin+;        (if (not (fequal? 0.0000001 (string->number (number->string 0.0000001))))+;            (begin (display "(string<->number 0.0000001) -> ") (display (number->string 0.0000001))+;                   (display " -> ") (display (string->number (number->string 0.0000001))) (newline)))+;        (if (not (fequal? 0.0000001001 (string->number (number->string 0.0000001001))))+;            (begin (display "(string<->number 0.0000001001) -> ") (display (number->string 0.0000001001))+;                   (display " -> ") (display (string->number (number->string 0.0000001001))) (newline)))))+;  )++;(test (number->string 123 8) "173")+;(test (number->string 123 16) "7b")+;(test (number->string 123 2) "1111011")+;(test (number->string -123 8) "-173")+;(test (number->string -123 16) "-7b")+;(test (number->string -123 2) "-1111011")++;(test (number->string 0 8) "0")+;(test (number->string 0 2) "0")+;(test (number->string 0 16) "0")+;(test (number->string 1 8) "1")+;(test (number->string 1 2) "1")+;(test (number->string 1 16) "1")+;(test (number->string -1 8) "-1")+;(test (number->string -1 2) "-1")+;(test (number->string -1 16) "-1")++;(let ((happy #t))+;  (do ((i 2 (+ i 1)))+;      ((or (not happy)+;           (= i 17)))+;    (if (not (eqv? 0 (string->number (number->string 0 i) i)))+;        (begin+;          (set! happy #f)+;          (display "(string<->number 0 ") (display i) (display " -> ") (display (number->string 0 i))+;          (display " -> ") (display (string->number (number->string 0 i) i)) (newline)))+;    (if (not (eqv? 1234 (string->number (number->string 1234 i) i)))+;        (begin+;          (set! happy #f)+;          (display "(string<->number 1234 ") (display i) (display " -> ") (display (number->string 1234 i))+;          (display " -> ") (display (string->number (number->string 1234 i) i)) (newline)))+;    (if (not (eqv? -1234 (string->number (number->string -1234 i) i)))+;        (begin+;          (set! happy #f)+;          (display "(string<->number -1234 ") (display i) (display " -> ") (display (number->string -1234 i))+;          (display " -> ") (display (string->number (number->string -1234 i) i)) (newline)))))++;(for-each+; (lambda (radix)+;   (let* ((last-good 0)+;          (first-bad+;           (call/cc+;            (lambda (return)+;              (do ((i 1 (+ i 1))+;                   (k 1 (* k 2)))+;                  ((= i 200) #f)+;                (if (and (eqv? k (string->number (number->string k radix) radix))+;                         (eqv? (- k) (string->number (number->string (- k) radix) radix))+;                         (not (negative? k))) ; might hit sign bit+;                    (set! last-good k)+;                    (if (negative? k)+;                        (return (- (* 2 last-good) 1))+;                        (letrec ((search+;                                  (lambda (lo hi)+;                                    (if (= lo hi)+;                                        hi+;                                        (let ((mid (inexact->exact (floor (/ (+ hi lo) 2)))))+;                                          (if (and (eqv? mid (string->number (number->string mid radix) radix))+;                                                   (eqv? (- mid) (string->number (number->string (- mid) radix) radix)))+;                                              (search mid hi)+;                                              (search lo mid)))))))+;                          (return (search last-good (- (* 2 last-good) 1)))))))))))+;     (if (or (and (number? number-to-string-top) ; might have bignums+;                  (number? first-bad)+;                  (not (= first-bad number-to-string-top)))+;             (and (not (number? number-to-string-top))+;                  (number? first-bad)))+;         (if (integer? first-bad)+;             (begin+;               (display "string->number ints (radix ") (display radix) (display ") fail around ")+;               (display first-bad)+;               (display " (2^")+;               (display (/ (log first-bad) (log 2.0)))+;               (display ")")+;               (newline))+;             (begin+;               (display "(string->number ints (radix ") (display radix) (display ") are good out to at least 2^200)")+;               (newline))))))+; (list 2 8 16 7 12)))++;;  (do ((i 0 (+ i 1)) (n 1 (* n 2))) ((= i 63)) (display n) (display " ") (display (number->string n 16)) (newline))++(test (number->string 3/4 2) "11/100")+(test (number->string 3/4 8) "3/4")+(test (number->string 3/4 16) "3/4")+(test (number->string -3/4 2) "-11/100")+(test (number->string -3/4 8) "-3/4")+(test (number->string -3/4 16) "-3/4")++(test (number->string 23/34 2) "10111/100010")+(test (number->string 23/34 8) "27/42")+(test (number->string 23/34 16) "17/22")+(test (number->string -23/34 2) "-10111/100010")+(test (number->string -23/34 8) "-27/42")+(test (number->string -23/34 16) "-17/22")++(num-test (string->number "11/100" 2) 3/4)+(num-test (string->number "10111/100010" 2) 23/34)+(num-test (string->number "27/42" 8) 23/34)+(num-test (string->number "17/22" 16) 23/34)+(num-test (string->number "1234567890123456789012345678901234567890.123456789e-30") 1234567890.1235)+(num-test (string->number "123456789012345678901234567890123456789012345678901234567890.123456789e-50") 1234567890.1235)+(num-test (- 1234567890123456789012345678901234567890123456789012345678901234567890.123456789e-60 12345678901234567890123456789012345678901234567890.123456789e-40) 0.0)+++;(let ((happy #t))+;  (do ((i 2 (+ i 1)))+;      ((or (not happy)+;	   (= i 17)))+;    (if (not (eqv? 3/4 (string->number (number->string 3/4 i) i)))+;	(begin+;	  (set! happy #f)+;	  (display "(string<->number 3/4 ") (display i) (display ") -> ") (display (number->string 3/4 i))+;	  (display " -> ") (display (string->number (number->string 3/4 i) i)) (newline)))+;    (if (not (eqv? 1234/11 (string->number (number->string 1234/11 i) i)))+;	(begin+;	  (set! happy #f)+;	  (display "(string<->number 1234/11 ") (display i) (display ") -> ") (display (number->string 1234/11 i))+;	  (display " -> ") (display (string->number (number->string 1234/11 i) i)) (newline)))+;    (if (not (eqv? -1234/11 (string->number (number->string -1234/11 i) i)))+;	(begin+;	  (set! happy #f)+;	  (display "(string<->number -1234/11 ") (display i) (display ") -> ") (display (number->string -1234/11 i))+;	  (display " -> ") (display (string->number (number->string -1234/11 i) i)) (newline)))))++(test (< (magnitude (- (string->number "3.1415926535897932384626433832795029") 3.1415926535897932384626433832795029)) 1e-7) #t)++(let ((val (catch #t (lambda () (string->number "111.01" 2)) (lambda args 'error))))+  (if (number? val)+      (begin+	(num-test (string->number "111.01" 2) 7.25)+	(num-test (string->number "-111.01" 2) -7.25)+	(num-test (string->number "0.001" 2) 0.125)+	(num-test (string->number "1000000.001" 2) 64.125)++	(num-test (string->number "111.01" 8) 73.015625)+	(num-test (string->number "-111.01" 8) -73.015625)+	(num-test (string->number "0.001" 8) 0.001953125)+	(num-test (string->number "1000000.001" 8) 262144.001953125)++	(num-test (string->number "111.01" 16) 273.00390625)+	(num-test (string->number "-111.01" 16) -273.00390625)+	(num-test (string->number "0.001" 16) 0.000244140625)+	(num-test (string->number "1000000.001" 16) 16777216.000244)++	(num-test (string->number "11.+i" 2) 3+1i)+	(num-test (string->number "0+.1i" 2) 0+0.5i)+	(num-test (string->number "1.+0.i" 2) 1.0)+	(num-test (string->number ".01+.1i" 2) 0.25+0.5i)+	(num-test (string->number "1+0.i" 2) 1.0)+	(num-test (string->number "1+0i" 2) 1.0)++	(test (number->string 0.75 2) "0.11")+	(test (number->string 0.125 8) "0.1")+	(test (number->string 12.5 8) "14.4")+	(test (number->string 12.5 16) "c.8")+	(test (number->string 12.5 2) "1100.1")+	(test (number->string -12.5 8) "-14.4")+	(test (number->string -12.5 16) "-c.8")+	(test (number->string -12.5 2) "-1100.1")+	(test (number->string 12.0+0.75i 2) "1100.0+0.11i")+	(test (number->string -12.5-3.75i 2) "-1100.1-11.11i")+	(test (number->string 12.0+0.75i 8) "14.0+0.6i")+	(test (number->string -12.5-3.75i 8) "-14.4-3.6i")+	(test (number->string 12.0+0.75i 16) "c.0+0.ci")+	(test (number->string -12.5-3.75i 16) "-c.8-3.ci")++	(test (string=? (substring (number->string our-pi 16) 0 14) "3.243f6a8885a3") #t)+;	(test (string=? (substring (number->string our-pi 2) 0 14) "11.0010010000111111011") #t)++;	(for-each+;	 (lambda (expchar)+;	   (let ((exponent (string expchar)))+;	     (do ((base 2 (+ base 1)))+;		 ((= base 11))+;	       (let ((val (string->number (string-append "1" exponent "1") base)))+;		   (if (and (number? val)+;			    (not (= val base)))+;		       (begin+;			 (display "(string->number ") (display (string-append "1" exponent "1")) (display " ") (display base)+;			 (display ") returned ") (display (string->number (string-append "1" exponent "1") base))+;			 (display "?") (newline)))))+;+;	     (do ((base 2 (+ base 1)))+;		 ((= base 11))+;	       (let ((val (string->number (string-append "1.1" exponent "1") base)))+;		   (if (and (number? val)+;			    (not (= val (+ base 1))))+;		       (begin+;			 (display "(string->number ") (display (string-append "1.1" exponent "1")) (display " ") (display base)+;			 (display ") returned ") (display (string->number (string-append "1.1" exponent "1") base))+;			 (display "?") (newline)))))+;+;	     (do ((base 2 (+ base 1)))+;		 ((= base 11))+;	       (let ((val (string->number (string-append "1" exponent "+1") base)))+;		 (if (and (number? val)+;			  (not (= val base)))+;		       (begin+;			 (display "(string->number ") (display (string-append "1" exponent "+1")) (display " ") (display base)+;			 (display ") returned ") (display (string->number (string-append "1" exponent "+1") base))+;			 (display "?") (newline)))))+;					; in base 16 this is still not a number because of the + (or -)+;					; but "1e+1i" is a number -- gad!+;+;	     (do ((base 2 (+ base 1)))+;		 ((= base 11))+;	       (let ((val (string->number (string-append "1" exponent "-1+1i") base)))+;		 (if (and (number? val)+;			  (> (magnitude (- val (make-rectangular (/ base) 1))) 1e-6))+;		       (begin+;			 (display "(string->number ") (display (string-append "1" exponent "-1+1i")) (display " ") (display base)+;			 (display ") returned ") (display (string->number (string-append "1" exponent "-1+1i") base))+;			 (display "?") (newline)))))))+;+;	 (list #\e #\d #\f #\s #\l))++	(test (< (abs (- (string->number "3.1415926535897932384626433832795029" 10) 3.1415926535897932384626433832795029)) 1e-7) #t)+	(num-test (string->number "2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427" 16) 2.4433976119657)+	(num-test (string->number "2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427" 11) 2.6508258818757)++;	(let ((happy #t))+;	  (do ((i 2 (+ i 1)))+;	      ((or (not happy)+;		   (= i 17)))+;	    (let ((val (+ 1.0 i)))+;	      (do ((k 1 (+ k 1))+;		   (incr (/ 1.0 i) (/ incr i)))+;		  ((< incr 1e-14))+;		(set! val (+ val incr)))+;	      (if (> (abs (- val (string->number "11.111111111111111111111111111111111111111111111111111111111111111111111111111111111111" i))) 1e-7)+;		  (begin+;		    (set! happy #f)+;		    (display "(string->number 11.111... ") (display i) (display ") -> ")+;		    (display (string->number "11.111111111111111111111111111111111111111111111111111111111111111111111111111111111111" i))+;		    (display " but expected ") (display val) (newline))))++	    (let* ((digits "00123456789abcdef")+		   (str (make-string 80 (string-ref digits i))))+	      (string-set! str 2 #\.)+	      (let ((val (exact->inexact (* i i))))+		(if (> (abs (- val (string->number str i))) 1e-7)+		    (begin+		      (set! happy #f)+		      (display "(string->number ")+		      (display (string-ref digits i)) (display (string-ref digits i)) (display ".")+		      (display (string-ref digits i)) (display (string-ref digits i)) (display (string-ref digits i)) (display "... ")+		      (display i) (display ") -> ")+		      (display (string->number str i))+		      (display " but expected ") (display val) (newline)))))++	    (let* ((radlim (list 0 0 62 39 31 26 23 22 20 19 18 17 17 16 16 15 15))+		   (digits "00123456789abcdef"))+	      (do ((k (- (list-ref radlim i) 3) (+ k 1)))+		  ((= k (+ (list-ref radlim i) 4)))+		(let ((str (make-string (+ k 3) (string-ref digits i))))+		  (string-set! str 2 #\.)+		  (let ((val (exact->inexact (* i i))))+		    (if (> (abs (- val (string->number str i))) 1e-7)+			(begin+			  (set! happy #f)+			  (display "(string->number ")+			  (display str) (display " ")+			  (display i) (display ") -> ")+			  (display (string->number str i))+			  (display " but expected ") (display val) (newline)))))))))++	;(let ((happy #t))+	;  (do ((i 2 (+ i 1)))+	;      ((or (not happy)+	;           (= i 17)))+	;    (if (> (abs (- 0.75 (string->number (number->string 0.75 i) i))) 1e-6)+	;        (begin+	;          (set! happy #f)+	;          (display "(string<->number 0.75 ") (display i) (display ") -> ") (display (number->string 0.75 i))+	;          (display " -> ") (display (string->number (number->string 0.75 i) i)) (newline)))+	;    (if (> (abs (- 1234.75 (string->number (number->string 1234.75 i) i))) 1e-6)+	;        (begin+	;          (set! happy #f)+	;          (display "(string<->number 1234.75 ") (display i) (display ") -> ") (display (number->string 1234.75 i))+	;          (display " -> ") (display (string->number (number->string 1234.75 i) i)) (newline)))+	;    (if (> (abs (- -1234.25 (string->number (number->string -1234.25 i) i))) 1e-6)+	;        (begin+	;          (set! happy #f)+	;          (display "(string<->number -1234.25 ") (display i) (display ") -> ") (display (number->string -1234.25 i))+	;          (display " -> ") (display (string->number (number->string -1234.25 i) i)) (newline)))++	;    (let ((val (string->number (number->string 12.5+3.75i i) i)))+	;      (if (or (not (number? val))+	;              (> (abs (- (real-part val) 12.5)) 1e-6)+	;              (> (abs (- (imag-part val) 3.75)) 1e-6))+	;          (begin+	;            (set! happy #f)+	;            (display "(string<->number 12.5+3.75i ") (display i) (display ") -> ") (display (number->string 12.5+3.75i i))+	;            (display " -> ") (display (string->number (number->string 12.5+3.75i i) i)) (newline))))++	;    (let ((happy #t))+	;      (do ((base 2 (+ base 1)))+	;          ((or (not happy)+	;               (= base 11))) ;;; see s7.c for an explanation of this limit+	;        (do ((i 0 (+ i 1)))+	;            ((= i 10))+	;          (let* ((rl (- (random 200.0) 100.0))+	;                 (im (- (random 200.0) 100.0))+	;                 (rlstr (number->string rl base))+	;                 (imstr (number->string im base))+	;                 (val (make-rectangular rl im))+	;                 (str (string-append rlstr+	;                                     (if (or (negative? im)+	;                                             (char=? (string-ref imstr 0) #\-)) ; sigh -- -0.0 is not negative!+	;                                         "" "+")+	;                                     imstr+	;                                     "i")))+	;            (let* ((sn (string->number str base))+	;                   (nsn (and (number? sn) (number->string sn base)))+	;                   (nval (and (string? nsn) (string->number nsn base))))+	;              (if (or (not nval)+	;                      (> (abs (- (real-part nval) (real-part val))) 1e-3)+	;                      (> (abs (- (imag-part nval) (imag-part val))) 1e-3))+	;                  (begin+	;                    (set! happy #f)+	;                    (display "number<->string \"")+	;                    (display str)+	;                    (display "\" ")+	;                    (display base)+	;                    (display ") -> ")+	;                    (display nval)+	;                    (display "?")+	;                    (display " [") (display sn) (display " ") (display nsn) (display "]")+	;                    (newline))))))))+	;    ))+	)++(let ((val (number->string 1.0-1.0i)))+  (if (and (not (string=? val "1-1i"))+	   (not (string=? val "1.0-1.0i"))+	   (not (string=? val "1-i"))+	   (not (string=? val "1.0-i")))+      (begin+	(display "(number->string 1.0-1.0i) returned ") (display val) (display "?") (newline))))++(let ((string->number-2 (lambda (str radix)+			  (let ((old-str (if (string? str) (string-copy str) str)))+			    (let ((val (string->number str radix)))+			      (if (not (string=? str old-str))+				  (error 'string->number-messed-up)+				  val)))))+      (string->number-1 (lambda (str)+			  (let ((old-str (if (string? str) (string-copy str) str)))+			    (let ((val (string->number str)))+			      (if (not (string=? str old-str))+				  (error 'string->number-messed-up)+				  val))))))++  (num-test (string->number-1 "100") 100)+  (num-test (string->number-2 "100" 16) 256)+  (num-test (string->number-2 "100" 2) 4)+  (num-test (string->number-2 "100" 8) 64)+  (num-test (string->number-2 "100" 10) 100)+  (num-test (string->number-2 "11" 16) 17)+  (num-test (string->number-2 "-11" 16) -17)+  (num-test (string->number-2 "aa" 16) 170)+  (num-test (string->number-2 "-aa" 16) -170)++;  (for-each+;   (lambda (str rval fval)+;     (let ((happy #t))+;       (do ((radix 3 (+ radix 1)))+;	   ((or (not happy)+;		(= radix 16)))+;	 (let ((val (string->number-2 str radix)))+;	   (if (and (number? val)+;		    (not (fval val (rval radix) radix)))+;	       (begin+;		 (display "(string->number \"") (display str) (display "\" ") (display radix) (display ") = ") (display val) (display "?") (newline)+;		 (set! happy #f)))))))+;   (list "101"+;	 "201.02"+;	 "1/21"+;	 "2e1"+;	 "10.1e-1"+;	 )+;   (list (lambda (radix) (+ 1 (* radix radix)))+;	 (lambda (radix) (+ 1.0 (* 2 radix radix) (/ 2.0 (* radix radix))))+;	 (lambda (radix) (/ 1 (+ 1 (* 2 radix))))+;	 (lambda (radix) (if (< radix 15) (* 2 radix) (+ 1 (* 14 radix) (* 2 radix radix))))+;	 (lambda (radix) (+ 1 (/ 1.0 (* radix radix))))+;	 )+;   (list (lambda (a b radix) (= a b))+;	 (lambda (a b radix) (< (abs (- a b)) (/ 1.0 (* radix radix))))+;	 (lambda (a b radix) (= a b))+;	 (lambda (a b radix) (= a b))+;	 (lambda (a b radix) (< (abs (- a b)) (/ 1.0 (* radix radix radix))))+;	 ))++  (num-test (string->number-2 "34" 2) #f)+  (num-test (string->number-2 "19" 8) #f)+  (num-test (string->number-2 "1c" 10) #f)+  (num-test (string->number-2 "1c" 16) 28)++  (test (string->number-1 "") #f )+  (test (string->number-1 ".") #f )+  (test (string->number-1 "d") #f )+  (test (string->number-1 "D") #f )+  (test (string->number-1 "i") #f )+  (test (string->number-1 "I") #f )+  (test (string->number-1 "3i") #f )+  (test (string->number-1 "3I") #f )+  (test (string->number-1 "33i") #f )+  (test (string->number-1 "33I") #f )+  (test (string->number-1 "3.3i") #f )+  (test (string->number-1 "3.3I") #f )+  (test (string->number-1 "-") #f )+  (test (string->number-1 "+") #f )++  (test (string->number-1 "#i1-1ei") #f)+  (test (string->number-1 "#i-2e+i") #f)+  (test (string->number-1 "#i1+i1i") #f)+  (test (string->number-1 "#i1+1") #f)+  (test (string->number-1 "#i2i.") #f)++  (num-test (string->number-1 "3.4e3") 3400.0)+  (num-test (string->number-1 "0") 0)+  (num-test (string->number-1 "#x#e-2e2") -738)+  )++(test (let* ((str "1+0i") (x (string->number str))) (and (number? x) (string=? str "1+0i"))) #t)++(test (= 1 #e1 1/1 #e1/1 #e1.0 #e1e0 #b1 #x1 #o1 #d1 #o001 #o+1 #o#e1 #e#x1 #e1+0i #e10e-1 #e0.1e1 #e+1-0i #e#b1) #t)+(test (= 0.3 3e-1 3d-1 0.3e0 3e-1) #t)+(test (= 0 +0 0.0 +0.0 0/1 +0/24 0+0i #e0 #b0 #x0 #o0 #e#b0) #t)++(let ((things (vector 123 #e123 #b1111011 #e#b1111011 #b#e1111011 #o173 #e#o173 #o#e173+		      #x7b #e#x7b #x#e7b (string->number "123") 246/2 #e123/1 #d123 #e#d123 #d#e123)))+  (do ((i 0 (+ i 1)))+      ((= i (- (vector-length things) 1)))+    (do ((j (+ i 1) (+ j 1)))+	((= j (vector-length things)))+      (if (not (eqv? (vector-ref things i) (vector-ref things j)))+	  (begin+	    (display "(eqv? ") (display (vector-ref things i)) (display " ") (display (vector-ref things j)) (display ") -> #f?") (newline))))))++(test (exact? #i1) #f)+(test (exact? #e1.0) #t)+(test (exact? #i1.0) #f)+(test (exact? #e1) #t)+(test (exact? #i#b1) #f)+(test (exact? #e#b1) #t)++(for-each+  (lambda (n)+    (let ((nb+	   (catch #t+		  (lambda ()+		    (number? n))+		  (lambda args+		    'error))))+      (if (not nb)+	  (begin+	    (display "(number? ") (display n) (display ") returned #f?") (newline)))))+  (list 1 -1 +1 +.1 -.1 .1 .0 0. 0.0 -0 +0 -0. +0.+	+1.1 -1.1 1.1+	'1.0e2 '-1.0e2 '+1.0e2+	'1.1e-2 '-1.1e-2 '+1.1e-2+	'1.1e+2 '-1.1e+2 '+1.1e+2+	'1/2 '-1/2 '+1/2+	'1.0s2 '-1.0s2 '+1.0s2+	'1.0d2 '-1.0d2 '+1.0d2+	'1.0f2 '-1.0f2 '+1.0f2+	'1.0l2 '-1.0l2 '+1.0l2+	'1.0+1.0i '1.0-1.0i '-1.0-1.0i '-1.0+1.0i+	'1+i '1-i '-1-i '-1+i+	'2/3+i '2/3-i '-2/3+i+	'1+2/3i '1-2/3i '2/3+2/3i '2.3-2/3i '2/3-2.3i+	'2e2+1e3i '2e2-2e2i '2.0e2+i '1+2.0e2i '2.0e+2-2.0e-1i '2/3-2.0e3i '2e-3-2/3i+	'-2.0e-2-2.0e-2i '+2.0e+2+2.0e+2i '+2/3-2/3i '2e2-2/3i+	'1e1-i '1.-i '.0+i '-.0-1e-1i '1.+.1i '0.-.1i+	'.1+.0i '1.+.0i '.1+.1i '1.-.1i '.0+.00i '.10+.0i '-1.+.0i '.1-.01i '1.0+.1i+	'1e1+.1i '-1.-.10i '1e01+.0i '0e11+.0i '1.e1+.0i '1.00-.0i '-1e1-.0i '1.-.1e0i+	'1.+.001i '1e10-.1i '1e+0-.1i '-0e0-.1i+	'-1.0e-1-1.0e-1i '-111e1-.1i '1.1-.1e11i '-1e-1-.11i '-1.1-.1e1i '-.1+.1i+	))++(for-each+  (lambda (n rl im)+    (if (not (number? n))+	(begin+	  (display "(number? ") (display n) (display ") returned #f?") (newline))+	(begin+	  (if (> (abs (- (real-part n) rl)) .000001)+	      (begin+		(display "real-part: ") (display n) (display " ") (display (real-part n)) (display " ") (display rl) (newline)))+	  (if (> (abs (- (imag-part n) im)) .000001)+	      (begin+		(display "imag-part: ") (display n) (display " ") (display (imag-part n)) (display " ") (display im) (newline)))+	  )))+  (list 1 -1 +1 +.1 -.1 .1 .0 0. 0.0 -0 +0 -0. +0.+	+1.1 -1.1 1.1+	'1.0e2 '-1.0e2 '+1.0e2+	'1.1e-2 '-1.1e-2 '+1.1e-2+	'1.1e+2 '-1.1e+2 '+1.1e+2+	'1/2 '-1/2 '+1/2+	'1.0s2 '-1.0s2 '+1.0s2+	'1.0d2 '-1.0d2 '+1.0d2+	'1.0f2 '-1.0f2 '+1.0f2+	'1.0l2 '-1.0l2 '+1.0l2+	'1.0+1.0i '1.0-1.0i '-1.0-1.0i '-1.0+1.0i+	'1+i '1-i '-1-i '-1+i+	'2/3+i '2/3-i '-2/3+i+	'1+2/3i '1-2/3i '2/3+2/3i '2.3-2/3i '2/3-2.3i+	'2e2+1e3i '2e2-2e2i '2.0e2+i '1+2.0e2i '2.0e+2-2.0e-1i '2/3-2.0e3i '2e-3-2/3i+	'-2.0e-2-2.0e-2i '+2.0e+2+2.0e+2i '+2/3-2/3i '2e2-2/3i+	'1e1-i '1.-i '.0+i '-.0-1e-1i '1.+.1i '0.-.1i+	'.1+.0i '1.+.0i '.1+.1i '1.-.1i '.0+.00i '.10+.0i '-1.+.0i '.1-.01i '1.0+.1i+	'1e1+.1i '-1.-.10i '1e01+.0i '0e11+.0i '1.e1+.0i '1.00-.0i '-1e1-.0i '1.-.1e0i+	'1.+.001i '1e10-.1i '1e+0-.1i '-0e0-.1i+	'-1.0e-1-1.0e-1i '-111e1-.1i '1.1-.1e11i '-1e-1-.11i '-1.1-.1e1i)++  (list 1.0 -1.0 1.0 0.1 -0.1 0.1 0.0 0.0 0.0 0.0 0.0 -0.0 0.0 1.1 -1.1 1.1 100.0 -100.0+	100.0 0.011 -0.011 0.011 110.0 -110.0 110.0 0.5 -0.5 0.5 100.0 -100.0 100.0 100.0+	-100.0 100.0 100.0 -100.0 100.0 100.0 -100.0 100.0 1.0 1.0 -1.0 -1.0 1.0 1.0 -1.0+	-1.0 0.66666666666667 0.66666666666667 -0.66666666666667 1.0 1.0 0.66666666666667+	2.3 0.66666666666667 200.0 200.0 200.0 1.0 200.0 0.66666666666667 0.002 -0.02 200.0+	0.66666666666667 200.0 10.0 1.0 0.0 -0.0 1.0 0.0 0.1 1.0 0.1 1.0 0.0 0.1 -1.0 0.1+	1.0 10.0 -1.0 10.0 0.0 10.0 1.0 -10.0 1.0 1.0 10000000000.0 1.0 -0.0 -0.1 -1110.0+	1.1 -0.1 -1.1)++  (list 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0+	0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 -1.0+	-1.0 1.0 1.0 -1.0 -1.0 1.0 1.0 -1.0 1.0 0.66666666666667 -0.66666666666667+	0.66666666666667 -0.66666666666667 -2.3 1000.0 -200.0 1.0 200.0 -0.2 -2000.0+	-0.66666666666667 -0.02 200.0 -0.66666666666667 -0.66666666666667 -1.0 -1.0 1.0+	-0.1 0.1 -0.1 0.0 0.0 0.1 -0.1 0.0 0.0 0.0 -0.01 0.1 0.1 -0.1 0.0 0.0 0.0 0.0+	0.0 -0.1 0.001 -0.1 -0.1 -0.1 -0.1 -0.1 -10000000000.0 -0.11 -1.0))+++;(for-each+; (lambda (n name)+;    (if (number? n)+;	(begin+;	  (display "(number? ") (display name) (display ") returned #t?") (newline)))+;    (if (or (not (symbol? n))+;	    (boolean? n))+;	(begin+;	  (display "(symbol? ") (display name) (display ") returned #f?") (newline)))+;    (if (number? (string->number name))+;	(begin+;	  (display "(string->number ") (display name) (display ") returned ") (display (string->number name)) (display "?") (newline))))+;+; (list '1e '--1 '++1 '+. '+.+ '.. '.- '1e- '+ '- '-e1+;       '1/2/3 '1/2+/2 '/2 '2/ '1+2 '1/+i '1/2e1 '1/2.+;       '1..0 '1.+0 '1--1 '1+- '1.0++i '1.0-ie++2 '1+1 '1.0. '1.0e+;       '1ee2 '1.0e2e2 '1es2 '1e1.0 '1.0.0 '1/2.0 '1+i2 '1+1.0i0+;       '+.i 'i 'e 'e1 '1e.1 '1+.i '1.0e.1+;       '-.1ei '-1.0+1.0 '1.0+1.0i+1.0 '1.1/2 '1/2.0+;       '1/e '1/i 'e/i '1e2/3 '2/1e2 '1e2+1e2ii '1i-1.0 '1.0-i/2+;       '1/2i '2i/3 '2+/i '2+2/i '2+2/-i '2/- '2/+ '2/+3+;       '1e1.0 '1e1e2 '1+ie2 '1ei1 '1e/2 '0-- '1+ '1- '.1. '.1++;       '1//2 '1/-/2 '1/2/ '1// '+/1 '.0.+;       '+0ei '0e++i '+0e+i '0e+-i '+0e-i '+00ei '+.0ei '0+0ei '-01ei '+.1ei+;       '1-1ei '-1.ei '0+.i '0-.i '1+e0i '1+/0i '1-/0i '1+e1i '1+/1i '10+.i+;       '.0+.i '-0+.i '.1+.i '0.+.i '00-.i '.1-.i '1.-.i '1e++0i '1e--1i '.1e++i+;       '+10e+i '1+0e+i '+01e+i '+0e+-i '.1e+-i '1-10ei '0e++00i '1e--.1i '1.e-+1i+;       '1-0.e+i '1.+1e+i '-1.e--i '1.e+-.0i '1-e+01i '1-/101i '1+/10i '1-e10i+;       '-1+e+1i '.1-e-1i '1-/0e1i '1e10+.i '1/1.1+i '1/11.+i+;       '1/2e1-i '-1.0e-1-1-1.0e-1i '-1.0e-1-1.0e-1-1i+;       '1.0e2/3 '-1e--1.e1i '-11e--1e1i '1e--1.1e1i '1.e-1-1.ei '-1.e--1.ei+;       '-1.1e1-e1i '-1.e1-e-1i '.1e1-e-11i+;       '3.-3. '1'2 '+-2 '1?+;       '1a '1.a '-a '+a '1.. '..1 '-..1 '1ee1 '1ef2 '1+ief2 '1.+ '1.0- '1/2+/3+;       '1'2 '1-#i '1-i. '1-ie '1... '1//1...+;       )+; (list "1e" "--1" "++1" "+." "+.+" ".." ".-" "1e-" "+" "-" "-e1"+;       "1/2/3" "1/2+/2" "/2" "2/" "1+2" "1/+i" "1/2e1" "1/2."+;       "1..0" "1.+0" "1--1" "1+-" "1.0++i" "1.0-ie++2" "1+1" "1.0." "1.0e"+;       "1ee2" "1.0e2e2" "1es2" "1e1.0" "1.0.0" "1/2.0" "1+i2" "1+1.0i0"+;       "+.i" "i" "e" "e1" "1e.1" "1+.i" "1.0e.1"+;       "-.1ei" "-1.0+1.0" "1.0+1.0i+1.0" "1.1/2" "1/2.0"+;       "1/e" "1/i" "e/i" "1e2/3" "2/1e2" "1e2+1e2ii" "1i-1.0" "1.0-i/2"+;       "1/2i" "2i/3" "2+/i" "2+2/i" "2+2/-i" "2/-" "2/+" "2/+3"+;       "1e1.0" "1e1e2" "1+ie2" "1ei1" "1e/2" "0--" "1+" "1-" ".1." ".1+"+;       "1//2" "1/-/2" "1/2/" "1//" "+/1" ".0."+;       "+0ei" "0e++i" "+0e+i" "0e+-i" "+0e-i" "+00ei" "+.0ei" "0+0ei" "-01ei" "+.1ei"+;       "1-1ei" "-1.ei" "0+.i" "0-.i" "1+e0i" "1+/0i" "1-/0i" "1+e1i" "1+/1i" "10+.i"+;       ".0+.i" "-0+.i" ".1+.i" "0.+.i" "00-.i" ".1-.i" "1.-.i" "1e++0i" "1e--1i" ".1e++i"+;       "+10e+i" "1+0e+i" "+01e+i" "+0e+-i" ".1e+-i" "1-10ei" "0e++00i" "1e--.1i" "1.e-+1i"+;       "1-0.e+i" "1.+1e+i" "-1.e--i" "1.e+-.0i" "1-e+01i" "1-/101i" "1+/10i" "1-e10i"+;       "-1+e+1i" ".1-e-1i" "1-/0e1i" "1e10+.i" "1/1.1+i" "1/11.+i"+;       "1/2e1-i" "-1.0e-1-1-1.0e-1i" "-1.0e-1-1.0e-1-1i"+;       "1.0e2/3" "-1e--1.e1i" "-11e--1e1i" "1e--1.1e1i" "1.e-1-1.ei" "-1.e--1.ei"+;       "-1.1e1-e1i" "-1.e1-e-1i" ".1e1-e-11i"+;       "3.-3." "'1'2" "'+-2" "'1?"+;       "1a" "1.a" "-a" "+a" "1.." "..1" "-..1" "1ee1" "1ef2" "1+ief2" "1.+" "1.0-" "1/2+/3"+;       "'1'2" "1-#i" "1-i." "1-ie" "1..." "1/1/1/1"+;       ))++(test (number? ''1) #f)+(test (symbol? ''1) #f)+(test (string->number "''1") #f)++(test (let ((val (catch #t (lambda ()+			     (= 1+				01 +1 1.+				001 +01 1/1 1.0 1e0 01. +1.+				0001 +001 1/01 .1e1 01/1 +1/1 1.00 1e00 01.0 +1.0 1e+0 1e-0 01e0 +1e0 1.e0 001. +01. 1+0i 1-0i+				11/11 00001 +0001 1/001 .1e01 01/01 +1/01 .1e+1 10e-1 0.1e1 +.1e1 .10e1 001/1 +01/1 10/10 1.000 1e000 01.00 +1.00 1e+00 1e-00 01e00 +1e00 1.e00 001.0 +01.0 01e+0 +1e+0 1.e+0 01e-0 +1e-0 1.e-0 001e0 +01e0 1.0e0 01.e0 +1.e0 0001. +001. 1+00i 1-00i 1+.0i 1-.0i 01+0i +1+0i 1.+0i 01-0i +1-0i 1.-0i 1+0.i 1-0.i+				11/011 011/11 +11/11 000001 +00001 1/0001 .1e001 01/001 +1/001 .1e+01 10e-01 0.1e01 +.1e01 .10e01 001/01 +01/01 0.1e+1 +.1e+1 .10e+1 010e-1 +10e-1 10.e-1 00.1e1 +0.1e1 0.10e1 +.10e1 .100e1 0001/1 +001/1 10/010 010/10 +10/10 1.0000 1e0000 01.000 +1.000 1e+000 1e-000 01e000 +1e000 1.e000 001.00 +01.00 01e+00 +1e+00 1.e+00 01e-00 +1e-00 1.e-00 001e00 +01e00 1.0e00 01.e00 +1.e00 0001.0 +001.0 001e+0 +01e+0 1.0e+0 01.e+0 +1.e+0 001e-0 +01e-0 1.0e-0 01.e-0 +1.e-0 0001e0 +001e0 1.00e0 01.0e0 +1.0e0 001.e0 +01.e0 00001. +0001. 1+0e1i 1-0e1i 1+0/1i 1-0/1i 1+000i 1-000i 1+.00i 1-.00i 01+00i +1+00i 1.+00i 01-00i +1-00i 1.-00i 1+0.0i 1-0.0i 01+.0i +1+.0i 1.+.0i 01-.0i +1-.0i 1.-.0i 001+0i +01+0i 1/1+0i 1.0+0i 1e0+0i 01.+0i +1.+0i 001-0i +01-0i 1/1-0i 1.0-0i 1e0-0i 01.-0i +1.-0i 1+0e0i 1-0e0i 1+00.i 1-00.i 01+0.i +1+0.i 1.+0.i 01-0.i +1-0.i 1.-0.i+				111/111 11/0011 011/011 +11/011 0011/11 +011/11 101/101 0000001 +000001 1/00001 .1e0001 01/0001 +1/0001 .1e+001 10e-001 0.1e001 +.1e001 .10e001 001/001 +01/001 0.1e+01 +.1e+01 .10e+01 010e-01 +10e-01 10.e-01 00.1e01 +0.1e01 0.10e01 +.10e01 .100e01 0001/01 +001/01 00.1e+1 +0.1e+1 0.10e+1 +.10e+1 .100e+1 0010e-1 +010e-1 10.0e-1 010.e-1 +10.e-1 000.1e1 +00.1e1 00.10e1 +0.10e1 0.100e1 +.100e1 .1000e1 00001/1 +0001/1 110/110 10/0010 010/010 +10/010 0010/10 +010/10 100/100 1.00000 1e00000 01.0000 +1.0000 1e+0000 1e-0000 01e0000 +1e0000 1.e0000 001.000 +01.000 01e+000 +1e+000 1.e+000 01e-000 +1e-000 1.e-000 001e000 +01e000 1.0e000 01.e000 +1.e000 0001.00 +001.00 001e+00 +01e+00 1.0e+00 01.e+00 +1.e+00 001e-00 +01e-00 1.0e-00 01.e-00 +1.e-00 0001e00 +001e00 1.00e00 01.0e00 +1.0e00 001.e00 +01.e00 00001.0 +0001.0 0001e+0 +001e+0 1.00e+0 01.0e+0 +1.0e+0 001.e+0 +01.e+0 0001e-0 +001e-0 1.00e-0 01.0e-0 +1.0e-0 001.e-0 +01.e-0 00001e0 +0001e0 1.000e0 01.00e0 +1.00e0 001.0e0 +01.0e0 0001.e0 +001.e0 000001. +00001. 1+0e11i 1-0e11i 1+0/11i 1-0/11i 1+0e01i 1-0e01i 1+0/01i 1-0/01i 1+0e+1i 1-0e+1i 1+0e-1i 1-0e-1i 1+00e1i 1-00e1i 1+.0e1i 1-.0e1i 01+0e1i +1+0e1i 1.+0e1i 01-0e1i +1-0e1i 1.-0e1i 1+0.e1i 1-0.e1i 1+00/1i 1-00/1i 01+0/1i +1+0/1i 1.+0/1i 01-0/1i +1-0/1i 1.-0/1i 1+0e10i 1-0e10i 1+0/10i 1-0/10i 1+0000i 1-0000i 1+.000i 1-.000i 01+000i +1+000i 1.+000i 01-000i +1-000i 1.-000i 1+0.00i 1-0.00i 01+.00i +1+.00i 1.+.00i 01-.00i +1-.00i 1.-.00i 001+00i +01+00i 1/1+00i 1.0+00i 1e0+00i 01.+00i +1.+00i 001-00i +01-00i 1/1-00i 1.0-00i 1e0-00i 01.-00i +1.-00i 1+0e00i 1-0e00i 1+00.0i 1-00.0i 01+0.0i +1+0.0i 1.+0.0i 01-0.0i +1-0.0i 1.-0.0i 001+.0i +01+.0i 1/1+.0i 1.0+.0i 1e0+.0i 01.+.0i +1.+.0i 001-.0i +01-.0i 1/1-.0i 1.0-.0i 1e0-.0i 01.-.0i +1.-.0i 0001+0i +001+0i 1/01+0i .1e1+0i 01/1+0i +1/1+0i 1.00+0i 1e00+0i 01.0+0i +1.0+0i 1e+0+0i 1e-0+0i 01e0+0i +1e0+0i 1.e0+0i 001.+0i +01.+0i 1+0e+0i 1-0e+0i 0001-0i +001-0i 1/01-0i .1e1-0i 01/1-0i +1/1-0i 1.00-0i 1e00-0i 01.0-0i +1.0-0i 1e+0-0i 1e-0-0i 01e0-0i +1e0-0i 1.e0-0i 001.-0i +01.-0i 1+0e-0i 1-0e-0i 1+00e0i 1-00e0i 1+.0e0i 1-.0e0i 01+0e0i +1+0e0i 1.+0e0i 01-0e0i +1-0e0i 1.-0e0i 1+0.e0i 1-0.e0i 1+000.i 1-000.i 01+00.i +1+00.i 1.+00.i 01-00.i +1-00.i 1.-00.i 001+0.i +01+0.i 1/1+0.i 1.0+0.i 1e0+0.i 01.+0.i +1.+0.i 001-0.i +01-0.i 1/1-0.i 1.0-0.i 1e0-0.i 01.-0.i +1.-0.i+				111/0111 0111/111 +111/111 11/00011 011/0011 +11/0011 0011/011 +011/011 00011/11 +0011/11 101/0101 0101/101 +101/101 00000001 +0000001 1/000001 .1e00001 01/00001 +1/00001 .1e+0001 10e-0001 0.1e0001 +.1e0001 .10e0001 001/0001 +01/0001 0.1e+001 +.1e+001 .10e+001 010e-001 +10e-001 10.e-001 00.1e001 +0.1e001 0.10e001 +.10e001 .100e001 0001/001 +001/001 00.1e+01 +0.1e+01 0.10e+01 +.10e+01 .100e+01 0010e-01 +010e-01 10.0e-01 010.e-01 +10.e-01 000.1e01 +00.1e01 00.10e01 +0.10e01 0.100e01 +.100e01 .1000e01 00001/01 +0001/01 000.1e+1 +00.1e+1 00.10e+1 +0.10e+1 0.100e+1 +.100e+1 .1000e+1 00010e-1 +0010e-1 10.00e-1 010.0e-1 +10.0e-1 0010.e-1 +010.e-1 0000.1e1 +000.1e1 000.10e1 +00.10e1 00.100e1 +0.100e1 0.1000e1 +.1000e1 .10000e1 000001/1 +00001/1 110/0110 0110/110 +110/110 10/00010 010/0010 +10/0010 0010/010 +010/010 00010/10 +0010/10 100/0100 0100/100 +100/100 1.000000 1e000000 01.00000 +1.00000 1e+00000 1e-00000 01e00000 +1e00000 1.e00000 001.0000 +01.0000 01e+0000 +1e+0000 1.e+0000 01e-0000 +1e-0000 1.e-0000 001e0000 +01e0000 1.0e0000 01.e0000 +1.e0000 0001.000 +001.000 001e+000 +01e+000 1.0e+000 01.e+000 +1.e+000 001e-000 +01e-000 1.0e-000 01.e-000 +1.e-000 0001e000 +001e000 1.00e000 01.0e000 +1.0e000 001.e000 +01.e000 00001.00 +0001.00 0001e+00 +001e+00 1.00e+00 01.0e+00 +1.0e+00 001.e+00 +01.e+00 0001e-00 +001e-00 1.00e-00 01.0e-00 +1.0e-00 001.e-00 +01.e-00 00001e00 +0001e00 1.000e00 01.00e00 +1.00e00 001.0e00 +01.0e00 0001.e00 +001.e00 000001.0 +00001.0 00001e+0 +0001e+0 1.000e+0 01.00e+0 +1.00e+0 001.0e+0 +01.0e+0 0001.e+0 +001.e+0 00001e-0 +0001e-0 1.000e-0 01.00e-0 +1.00e-0 001.0e-0 +01.0e-0 0001.e-0 +001.e-0 000001e0 +00001e0 1.0000e0 01.000e0 +1.000e0 001.00e0 +01.00e0 0001.0e0 +001.0e0 00001.e0 +0001.e0 0000001. +000001.))+			(lambda args 'error))))+	val)+      #t)++(for-each+ (lambda (lst)+   (for-each+    (lambda (str)+      (let ((val (catch #t (lambda () (string->number str)) (lambda args 'error))))+	(if (or (not (number? val))+		(not (= val 1)))+	    (begin+	      (display "(string->number \"") (display str) (display "\") = ") (display val) (display "?") (newline)))))+    lst))+ (list+  (list "1")++  (list "01" "+1" "1.")++  (list "001" "+01" "#e1" "#i1" "1/1" "#b1" "#x1" "#d1" "#o1" "1.0" "1e0" "1d0" "1l0" "1s0" "1f0" "9/9" "01." "+1." "1E0" "1D0" "1L0" "1S0" "1F0")++  (list "0001" "+001" "#e01" "#i01" "1/01" "#b01" "#x01" "#d01" "#o01" "#e+1" "#i+1" "#b+1" "#x+1" "#d+1" "#o+1" ".1e1" "01/1" "+1/1" ".1d1" ".1l1" ".1s1" ".1f1" "1.00" "1e00" "1d00" "1l00" "1s00" "1f00" "01.0" "+1.0" "1e+0" "1d+0" "1l+0" "1s+0" "1f+0" "1e-0" "1d-0" "1l-0" "1s-0" "1f-0" "01e0" "+1e0" "1.e0" "01d0" "+1d0" "1.d0" "01l0" "+1l0" "1.l0" "01s0" "+1s0" "1.s0" "01f0" "+1f0" "1.f0" "9/09" "09/9" "+9/9" "001." "+01." "#e1." "#i1." "1+0i" "1-0i" "#d1.")++  (list "11/11" "00001" "+0001" "#e001" "#i001" "1/001" "#b001" "#x001" "#d001" "#o001" "#e+01" "#i+01" "#b+01" "#x+01" "#d+01" "#o+01" ".1e01" "01/01" "+1/01" ".1d01" ".1l01" ".1s01" ".1f01" "91/91" ".1e+1" ".1d+1" ".1l+1" ".1s+1" ".1f+1" "10e-1" "10d-1" "10l-1" "10s-1" "10f-1" "0.1e1" "+.1e1" ".10e1" "#b#e1" "#x#e1" "#d#e1" "#o#e1" "#b#i1" "#x#i1" "#d#i1" "#o#i1" "001/1" "+01/1" "#e1/1" "#i1/1" "#b1/1" "#x1/1" "#d1/1" "#o1/1" "#e#b1" "#i#b1" "#e#x1" "#i#x1" "0.1d1" "+.1d1" ".10d1" "#e#d1" "#i#d1" "#e#o1" "#i#o1" "0.1l1" "+.1l1" ".10l1" "0.1s1" "+.1s1" ".10s1" "0.1f1" "+.1f1" ".10f1" "10/10" "1.000" "1e000" "1d000" "1l000" "1s000" "1f000" "01.00" "+1.00" "1e+00" "1d+00" "1l+00" "1s+00" "1f+00" "1e-00" "1d-00" "1l-00" "1s-00" "1f-00" "01e00" "+1e00" "1.e00" "01d00" "+1d00" "1.d00" "01l00" "+1l00" "1.l00" "01s00" "+1s00" "1.s00" "01f00" "+1f00" "1.f00" "90/90" "001.0" "+01.0" "#e1.0" "#i1.0" "01e+0" "+1e+0" "1.e+0" "01d+0" "+1d+0" "1.d+0" "01l+0" "+1l+0" "1.l+0" "01s+0" "+1s+0" "1.s+0" "01f+0" "+1f+0" "1.f+0" "01e-0" "+1e-0" "1.e-0" "01d-0" "+1d-0" "1.d-0" "01l-0" "+1l-0" "1.l-0" "01s-0" "+1s-0" "1.s-0" "01f-0" "+1f-0" "1.f-0" "001e0" "+01e0" "#e1e0" "#i1e0" "1.0e0" "01.e0" "+1.e0" "001d0" "+01d0" "#e1d0" "#i1d0" "1.0d0" "01.d0" "+1.d0" "001l0" "+01l0" "#e1l0" "#i1l0" "1.0l0" "01.l0" "+1.l0" "001s0" "+01s0" "#e1s0" "#i1s0" "1.0s0" "01.s0" "+1.s0" "001f0" "+01f0" "#e1f0" "#i1f0" "1.0f0" "01.f0" "+1.f0" "19/19" "9/009" "09/09" "+9/09" "99/99" "009/9" "+09/9" "#e9/9" "#i9/9" "#x9/9" "#d9/9" "0001." "+001." "#e01." "#i01." "#e+1." "#i+1." "#xe/e" "1+00i" "1-00i" "1+.0i" "1-.0i" "01+0i" "+1+0i" "1.+0i" "01-0i" "+1-0i" "1.-0i" "1+0.i" "1-0.i" "#xb/b" "#xd/d" "#xf/f" "#d1d0")++;; remove "9":++(list "11/011" "011/11" "+11/11" "000001" "+00001" "#e0001" "#i0001" "1/0001" "#b0001" "#x0001" "#d0001" "#o0001" "#e+001" "#i+001" "#b+001" "#x+001" "#d+001" "#o+001" ".1e001" "01/001" "+1/001" ".1d001" ".1l001" ".1s001" ".1f001" ".1e+01" ".1d+01" ".1l+01" ".1s+01" ".1f+01" "10e-01" "10d-01" "10l-01" "10s-01" "10f-01" "0.1e01" "+.1e01" ".10e01" "#b#e01" "#x#e01" "#d#e01" "#o#e01" "#b#i01" "#x#i01" "#d#i01" "#o#i01" "001/01" "+01/01" "#e1/01" "#i1/01" "#b1/01" "#x1/01" "#d1/01" "#o1/01" "#e#b01" "#i#b01" "#e#x01" "#i#x01" "0.1d01" "+.1d01" ".10d01" "#e#d01" "#i#d01" "#e#o01" "#i#o01" "0.1l01" "+.1l01" ".10l01" "0.1s01" "+.1s01" ".10s01" "0.1f01" "+.1f01" ".10f01" "0.1e+1" "+.1e+1" ".10e+1" "#b#e+1" "#x#e+1" "#d#e+1" "#o#e+1" "#b#i+1" "#x#i+1" "#d#i+1" "#o#i+1" "#e#b+1" "#i#b+1" "#e#x+1" "#i#x+1" "0.1d+1" "+.1d+1" ".10d+1" "#e#d+1" "#i#d+1" "#e#o+1" "#i#o+1" "0.1l+1" "+.1l+1" ".10l+1" "0.1s+1" "+.1s+1" ".10s+1" "0.1f+1" "+.1f+1" ".10f+1" "010e-1" "+10e-1" "10.e-1" "010d-1" "+10d-1" "10.d-1" "010l-1" "+10l-1" "10.l-1" "010s-1" "+10s-1" "10.s-1" "010f-1" "+10f-1" "10.f-1" "00.1e1" "+0.1e1" "#e.1e1" "#i.1e1" "0.10e1" "+.10e1" ".100e1" "0001/1" "+001/1" "#e01/1" "#i01/1" "#b01/1" "#x01/1" "#d01/1" "#o01/1" "#e+1/1" "#i+1/1" "#b+1/1" "#x+1/1" "#d+1/1" "#o+1/1" "00.1d1" "+0.1d1" "#e.1d1" "#i.1d1" "0.10d1" "+.10d1" ".100d1" "00.1l1" "+0.1l1" "#e.1l1" "#i.1l1" "0.10l1" "+.10l1" ".100l1" "00.1s1" "+0.1s1" "#e.1s1" "#i.1s1" "0.10s1" "+.10s1" ".100s1" "00.1f1" "+0.1f1" "#e.1f1" "#i.1f1" "0.10f1" "+.10f1" ".100f1" "10/010" "010/10" "+10/10" "1.0000" "1e0000" "1d0000" "1l0000" "1s0000" "1f0000" "01.000" "+1.000" "1e+000" "1d+000" "1l+000" "1s+000" "1f+000" "1e-000" "1d-000" "1l-000" "1s-000" "1f-000" "01e000" "+1e000" "1.e000" "01d000" "+1d000" "1.d000" "01l000" "+1l000" "1.l000" "01s000" "+1s000" "1.s000" "01f000" "+1f000" "1.f000" "001.00" "+01.00" "#e1.00" "#i1.00" "01e+00" "+1e+00" "1.e+00" "01d+00" "+1d+00" "1.d+00" "01l+00" "+1l+00" "1.l+00" "01s+00" "+1s+00" "1.s+00" "01f+00" "+1f+00" "1.f+00" "01e-00" "+1e-00" "1.e-00" "01d-00" "+1d-00" "1.d-00" "01l-00" "+1l-00" "1.l-00" "01s-00" "+1s-00" "1.s-00" "01f-00" "+1f-00" "1.f-00" "001e00" "+01e00" "#e1e00" "#i1e00" "1.0e00" "01.e00" "+1.e00" "001d00" "+01d00" "#e1d00" "#i1d00" "1.0d00" "01.d00" "+1.d00" "001l00" "+01l00" "#e1l00" "#i1l00" "1.0l00" "01.l00" "+1.l00" "001s00" "+01s00" "#e1s00" "#i1s00" "1.0s00" "01.s00" "+1.s00" "001f00" "+01f00" "#e1f00" "#i1f00" "1.0f00" "01.f00" "+1.f00" "0001.0" "+001.0" "#e01.0" "#i01.0" "#e+1.0" "#i+1.0" "001e+0" "+01e+0" "#e1e+0" "#i1e+0" "1.0e+0" "01.e+0" "+1.e+0" "001d+0" "+01d+0" "#e1d+0" "#i1d+0" "1.0d+0" "01.d+0" "+1.d+0" "001l+0" "+01l+0" "#e1l+0" "#i1l+0" "1.0l+0" "01.l+0" "+1.l+0" "001s+0" "+01s+0" "#e1s+0" "#i1s+0" "1.0s+0" "01.s+0" "+1.s+0" "001f+0" "+01f+0" "#e1f+0" "#i1f+0" "1.0f+0" "01.f+0" "+1.f+0" "001e-0" "+01e-0" "#e1e-0" "#i1e-0" "1.0e-0" "01.e-0" "+1.e-0" "001d-0" "+01d-0" "#e1d-0" "#i1d-0" "1.0d-0" "01.d-0" "+1.d-0" "001l-0" "+01l-0" "#e1l-0" "#i1l-0" "1.0l-0" "01.l-0" "+1.l-0" "001s-0" "+01s-0" "#e1s-0" "#i1s-0" "1.0s-0" "01.s-0" "+1.s-0" "001f-0" "+01f-0" "#e1f-0" "#i1f-0" "1.0f-0" "01.f-0" "+1.f-0" "0001e0" "+001e0" "#e01e0" "#i01e0" "#e+1e0" "#i+1e0" "1.00e0" "01.0e0" "+1.0e0" "001.e0" "+01.e0" "#e1.e0" "#i1.e0" "0001d0" "+001d0" "#e01d0" "#i01d0" "#e+1d0" "#i+1d0" "1.00d0" "01.0d0" "+1.0d0" "001.d0" "+01.d0" "#e1.d0" "#i1.d0" "0001l0" "+001l0" "#e01l0" "#i01l0" "#e+1l0" "#i+1l0" "1.00l0" "01.0l0" "+1.0l0" "001.l0" "+01.l0" "#e1.l0" "#i1.l0" "0001s0" "+001s0" "#e01s0" "#i01s0" "#e+1s0" "#i+1s0" "1.00s0" "01.0s0" "+1.0s0" "001.s0" "+01.s0" "#e1.s0" "#i1.s0" "0001f0" "+001f0" "#e01f0" "#i01f0" "#e+1f0" "#i+1f0" "1.00f0" "01.0f0" "+1.0f0" "001.f0" "+01.f0" "#e1.f0" "#i1.f0" "00001." "+0001." "#e001." "#i001." "#e+01." "#i+01." "#xe/0e" "#x0e/e" "#x+e/e" "1+0e1i" "1-0e1i" "1+0/1i" "1-0/1i" "1+0d1i" "1-0d1i" "1+0l1i" "1-0l1i" "1+0s1i" "1-0s1i" "1+0f1i" "1-0f1i" "1+000i" "1-000i" "1+.00i" "1-.00i" "01+00i" "+1+00i" "1.+00i" "01-00i" "+1-00i" "1.-00i" "1+0.0i" "1-0.0i" "01+.0i" "+1+.0i" "1.+.0i" "01-.0i" "+1-.0i" "1.-.0i" "001+0i" "+01+0i" "#e1+0i" "#i1+0i" "1/1+0i" "1.0+0i" "1e0+0i" "1d0+0i" "1l0+0i" "1s0+0i" "1f0+0i" "01.+0i" "+1.+0i" "001-0i" "+01-0i" "#e1-0i" "#i1-0i" "1/1-0i" "1.0-0i" "1e0-0i" "1d0-0i" "1l0-0i" "1s0-0i" "1f0-0i" "01.-0i" "+1.-0i" "1+0e0i" "1-0e0i" "1+0d0i" "1-0d0i" "1+0l0i" "1-0l0i" "1+0s0i" "1-0s0i" "1+0f0i" "1-0f0i" "1+00.i" "1-00.i" "01+0.i" "+1+0.i" "1.+0.i" "01-0.i" "+1-0.i" "1.-0.i" "#xb/0b" "#x0b/b" "#x+b/b" "#xd/0d" "#x0d/d" "#x+d/d" "#xf/0f" "#x0f/f" "#x+f/f")++;; remove "l" and "s" and others...++(list "111/111" "11/0011" "011/011" "+11/011" "0011/11" "+011/11" "#e11/11" "#i11/11" "#b11/11" "#x11/11" "#d11/11" "#o11/11" "101/101" "0000001" "+000001" "#e00001" "#i00001" "1/00001" "#b00001" "#x00001" "#d00001" "#o00001" "#e+0001" "#i+0001" "#b+0001" "#x+0001" "#d+0001" "#o+0001" ".1e0001" "01/0001" "+1/0001" ".1d0001" ".1f0001" ".1e+001" ".1d+001" ".1f+001" "10e-001" "10d-001" "10f-001" "0.1e001" "+.1e001" ".10e001" "#b#e001" "#x#e001" "#d#e001" "#o#e001" "#b#i001" "#x#i001" "#d#i001" "#o#i001" "001/001" "+01/001" "#e1/001" "#i1/001" "#b1/001" "#x1/001" "#d1/001" "#o1/001" "#e#b001" "#i#b001" "#e#x001" "#i#x001" "0.1d001" "+.1d001" ".10d001" "#e#d001" "#i#d001" "#e#o001" "#i#o001" "0.1f001" "+.1f001" ".10f001" "0.1e+01" "+.1e+01" ".10e+01" "#b#e+01" "#x#e+01" "#d#e+01" "#o#e+01" "#b#i+01" "#x#i+01" "#d#i+01" "#o#i+01" "#e#b+01" "#i#b+01" "#e#x+01" "#i#x+01" "0.1d+01" "+.1d+01" ".10d+01" "#e#d+01" "#i#d+01" "#e#o+01" "#i#o+01" "0.1f+01" "+.1f+01" ".10f+01" "010e-01" "+10e-01" "10.e-01" "010d-01" "+10d-01" "10.d-01" "010f-01" "+10f-01" "1.00000" "1e00000" "1d00000" "1f00000" "01.0000" "+1.0000" "1e+0000" "1d+0000" "1f+0000" "1e-0000" "1d-0000" "1f-0000" "01e0000" "+1e0000" "1.e0000" "01d0000" "+1d0000" "1.d0000" "01f0000" "+1f0000" "1.f0000" "001.000" "+01.000" "#e1.000" "#i1.000" "#d1.000" "01e+000" "+1e+000" "1.e+000" "01d+000" "+1d+000" "1.d+000" "01f+000" "+1f+000" "1.f+000" "01e-000" "+1e-000" "1.e-000" "01d-000" "+1d-000" "1.d-000" "01f-000" "+1f-000" "1.f-000" "001e000" "+01e000" "#e1e000" "#i1e000" "#d1e000" "1.0e000" "+1.e000" "001d000" "+01d000" "#e1d000" "#i1d000" "#d1d000" "1.0d000" "01.d000" "+1.d000" "001f000" "+01f000" "#e1f000" "#i1f000" "#d1f000" "1.0f000" "01.f000" "+1.f000" "0001.00" "+001.00" "#e01.00" "#i01.00" "#d01.00" "#e+1.00" "#i+1.00" "#d+1.00" "001e+00" "+01e+00" "#e1e+00" "#i1e+00" "#d1e+00" "1.0e+00" "01.e+00" "+1.e+00" "001d+00" "+01d+00" "#e1d+00" "#i1d+00" "#d1d+00" "1.0d+00" "01.d+00" "+1.d+00" "001f+00" "+01f+00" "#e1f+00" "#i1f+00" "#d1f+00" "1.0f+00" "01.f+00" "+1.f+00" "001e-00" "+01e-00" "#e1e-00" "#i1e-00" "#d1e-00" "1.0e-00" "01.e-00" "+1.e-00" "001d-00" "+01d-00" "#e1d-00" "#i1d-00" "#d1d-00" "1.0d-00" "01.d-00" "+1.d-00" "001f-00" "+01f-00" "#e1f-00" "#i1f-00" "#d1f-00" "1.0f-00" "0001.f0" "+001.f0" "#e01.f0" "#i01.f0" "#d01.f0" "#e+1.f0" "#i+1.f0" "#d+1.f0" "#xf0/f0" "000001." "+00001." "#e0001." "#i0001." "#d0001." "#e+001." "#i+001." "#d+001." "#d#e01." "#d#i01." "#e#d01." "#i#d01." "#d#e+1." "#d#i+1." "#e#d+1." "#i#d+1." "#x1e/1e" "#xe/00e" "#x0e/0e" "#x+e/0e" "#xee/ee" "#x00e/e" "#x+0e/e" "#x#ee/e" "#x#ie/e" "#e#xe/e" "#i#xe/e" "#xbe/be" "#xde/de" "#xfe/fe" "1+0e11i" "1-0e11i" "1+0/11i" "1-0/11i" "1+0d11i" "1-0d11i" "1+0f11i" "1-0f11i" "1+0e01i" "1-0e01i" "1+0/01i" "1-0/01i" "1+0d01i" "1-0d01i" "1+0f01i" "1-0f01i" "1+0e+1i" "1-0e+1i" "1+0d+1i" "1-0d+1i" "1+0f+1i" "1-0f+1i" "1+0e-1i" "1-0e-1i" "1+0d-1i" "1-0d-1i" "1+0f-1i" "1-0f-1i" "1+00e1i" "1-00e1i" "1+.0e1i" "1-.0e1i" "01+0e1i" "+1+0e1i" "1.+0e1i" "01-0e1i" "+1-0e1i" "1.-0e1i" "1+0.e1i" "1-0.e1i" "1+00/1i" "1-00/1i" "01+0/1i" "+1+0/1i" "1.+0/1i" "01-0/1i" "+1-0/1i" "1.-0/1i" "1+00d1i" "1-00d1i" "1+.0d1i" "1-.0d1i" "01+0d1i" "+1+0d1i" "1.+0d1i" "01-0d1i" "+1-0d1i" "1.-0d1i" "1+0.d1i" "1-0.d1i" "1+00f1i" "1-00f1i" "1+.0f1i" "1-.0f1i" "01+0f1i" "+1+0f1i" "1.+0f1i" "01-0f1i" "+1-0f1i" "1.-0f1i" "1+0.f1i" "1-0.f1i" "1+0e10i" "1-0e10i" "1+0/10i" "1-0/10i" "1+0d10i" "1-0d10i" "1+0f10i" "1-0f10i" "1+0000i" "1-0000i" "1+.000i" "1-.000i" "01+000i" "+1+000i" "1.+000i" "01-000i" "+1-000i" "1.-000i" "1+0.00i" "1-0.00i" "01+.00i" "+1+.00i" "1.+.00i" "01-.00i" "+1-.00i" "1.-.00i" "001+00i" "+01+00i" "#e1+00i" "#i1+00i" "1/1+00i" "#b1+00i" "#x1+00i" "#d1+00i" "#o1+00i" "1.0+00i" "1e0+00i" "1d0+00i" "1f0+00i" "01.+00i" "+1.+00i" "001-00i" "+01-00i" "#e1-00i" "#i1-00i" "1/1-00i" "#b1-00i" "#x1-00i" "#d1-00i" "#o1-00i" "1.0-00i" "1e0-00i" "1d0-00i" "1f0-00i" "01.-00i" "+1.-00i" "1+0e00i" "1-0e00i" "1+0d00i" "1-0d00i" "1+0f00i" "1-0f00i" "1+00.0i" "1-00.0i" "01+0.0i" "+1+0.0i" "1.+0.0i" "01-0.0i" "+1-0.0i" "1.-0.0i" "001+.0i" "+01+.0i" "#e1+.0i" "#i1+.0i" "1/1+.0i" "#d1+.0i" "1.0+.0i" "1e0+.0i" "1d0+.0i" "1f0+.0i" "01.+.0i" "+1.+.0i" "001-.0i" "+01-.0i" "#e1-.0i" "#i1-.0i" "1/1-.0i" "#d1-.0i" "1.0-.0i" "1e0-.0i" "1d0-.0i" "1f0-.0i" "01.-.0i" "+1.-.0i" "0001+0i" "+001+0i" "#e01+0i" "#i01+0i" "1/01+0i" "#b01+0i" "#x01+0i" "#d01+0i" "#o01+0i" "#e+1+0i" "#i+1+0i" "#b+1+0i" "#x+1+0i" "#d+1+0i" "#o+1+0i" ".1e1+0i" "01/1+0i" "+1/1+0i" ".1d1+0i" ".1f1+0i" "1.00+0i" "1e00+0i" "1d00+0i" "1f00+0i" "01.0+0i" "+1.0+0i" "1e+0+0i" "1d+0+0i" "1f+0+0i" "1e-0+0i" "1d-0+0i" "1f-0+0i" "01e0+0i" "+1e0+0i" "1.e0+0i" "01d0+0i" "+1d0+0i" "1.d0+0i" "01f0+0i" "+1f0+0i" "1.f0+0i" "001.+0i" "+01.+0i" "#e1.+0i" "#i1.+0i" "#d1.+0i" "1+0e+0i" "1-0e+0i" "1+0d+0i" "1-0d+0i" "1+0f+0i" "1-0f+0i" "0001-0i" "+001-0i" "#e01-0i" "#i01-0i" "1/01-0i" "#b01-0i" "#x01-0i" "#d01-0i" "#o01-0i" "#e+1-0i" "#i+1-0i" "#b+1-0i" "#x+1-0i" "#d+1-0i" "#o+1-0i" ".1e1-0i" "01/1-0i" "+1/1-0i" ".1d1-0i" ".1f1-0i" "1.00-0i" "1e00-0i" "1d00-0i" "1f00-0i" "01.0-0i" "+1.0-0i" "1e+0-0i" "1d+0-0i" "1f+0-0i" "1e-0-0i" "1d-0-0i" "1f-0-0i" "01e0-0i" "+1e0-0i" "1.e0-0i" "01d0-0i" "+1d0-0i" "1.d0-0i" "01f0-0i" "+1f0-0i" "1.f0-0i" "001.-0i" "+01.-0i" "#e1.-0i" "#i1.-0i" "#d1.-0i" "1+0e-0i" "1-0e-0i" "1+0d-0i" "1-0d-0i" "1+0f-0i" "1-0f-0i" "1+00e0i" "1-00e0i" "1+.0e0i" "1-.0e0i" "01+0e0i" "+1+0e0i" "1.+0e0i" "01-0e0i" "+1-0e0i" "1.-0e0i" "1+0.e0i" "1-0.e0i" "1+00d0i" "1-00d0i" "1+.0d0i" "1-.0d0i" "01+0d0i" "+1+0d0i" "1.+0d0i" "01-0d0i" "+1-0d0i" "1.-0d0i" "1+0.d0i" "1-0.d0i" "1+00f0i" "1-00f0i" "1+.0f0i" "1-.0f0i" "01+0f0i" "+1+0f0i" "1.+0f0i" "01-0f0i" "+1-0f0i" "1.-0f0i"+"1+000.i" "1-000.i" "01+00.i" "+1+00.i" "1.+00.i" "01-00.i" "+1-00.i" "1.-00.i" "001+0.i" "+01+0.i" "#e1+0.i" "#i1+0.i" "1/1+0.i" "#d1+0.i" "1.0+0.i" "1e0+0.i" "1d0+0.i" "1f0+0.i" "+1.+0.i" "001-0.i" "+01-0.i" "#e1-0.i" "#i1-0.i" "1/1-0.i" "#d1-0.i" "1.0-0.i" "1e0-0.i" "1d0-0.i" "1f0-0.i" "01.-0.i" "+1.-0.i" "#xb/00b" "#x0b/0b" "#x+b/0b" "#xeb/eb" "#x00b/b" "#x+0b/b" "#x#eb/b" "#x#ib/b" "#e#xb/b" "#i#xb/b" "#xbb/bb" "#xdb/db" "#xfb/fb" "#x1d/1d" "#xd/00d" "#x0d/0d" "#x+d/0d" "#xed/ed" )++;;; selected ones...++(list "#i+11/011" "#xf11/f11" "+101/0101" "#o#e11/11" "#d+11/011" "#e1/0001" "010d-001" "#e#b+001" ".10f+001" "+10f-001" ".10d0001" "#d10d-1" "#e10e-1"+      "#e.1d0001" "#d.01d002" "#i0.1f001" "#x#e1/001" "000000001" "#i+.1e+01" "#d+.1e+01" "00.10e+01" "+0.10e+01" "#e.10e+01" "#i.10e+01" "#d.10e+01"+      "#e.10e+01" "#i10.0e-01" "#d+.1d+01" "#d.10f+01" "#i0.1f+01" "+010.e-01" "#e10.e-01" "#e00.1e01" "#e#d.1e01" "#i#d1e0+0e0i"+      "#e#d10e-1+0e-2i" "#e#d1e0+0e-2i" "#d.1d+01+.0d01i" "#d0.001d+03+0.0d-10i" "#i#d+0.001d+03+0.0d-10i" "#i#d+1/1-0/1i"+)+))++(for-each+ (lambda (str)+   (let ((val (catch #t (lambda () (string->number str)) (lambda args 'error))))+     (if (or (not (number? val))+	     (= val 1))+	 (begin+	   (display "(string->number \"") (display str) (display "\") = ") (display val) (display "?") (newline)))))+ (list "#e1+i" "#e1-i" "#e01+i" "#e+1+i" "#e1.+i" "#e01-i" "#e+1-i" "#e1.-i" "#e1+1i" "#e1-1i" "011e0" "11e-00"+       "00.e01-i" "+10e10+i" "+1.110+i" "10011-0i" "-000.111" "0.100111" "-11.1111" "10.00011" "110e00+i"+       "1e-011+i" "101001+i" "+11e-0-0i" "11+00e+0i" "-11101.-i" "1110e-0-i"+       ))+++(for-each+ (lambda (str)+   (let ((val (catch #t (lambda () (string->number str)) (lambda args 'error))))+     (if (number? val)+	 (begin+	   (display "(string->number \"") (display str) (display "\") = ") (display val) (display "?") (newline)))))+ (list "#b#e#e1" "#x#e#e1" "#d#e#e1" "#o#e#e1" "#b#i#e1" "#x#i#e1" "#d#i#e1" "#o#i#e1" "#e#b#e1" "#i#b#e1" "#e#x#e1" "#i#x#e1"+       "#e#d#e1" "#i#d#e1" "#e#o#e1" "#i#o#e1" "#e#b#i1" "#e#x#i1" "#e#d#i1" "#e#o#i1" "#b#e#b1" "#x#e#b1" "#d#e#b1" "#o#e#b1"+       "#b#i#b1" "#x#i#b1" "#d#i#b1" "#o#i#b1" "#b#e#x1" "#x#e#x1" "#d#e#x1" "#o#e#x1" "#b#i#x1" "#x#i#x1" "#d#i#x1" "#o#i#x1"+       "#b#e#d1" "#x#e#d1" "#d#e#d1" "#o#e#d1" "#b#i#d1" "#x#i#d1" "#d#i#d1" "#o#i#d1" "#b#e#o1" "#x#e#o1" "#d#e#o1" "#o#e#o1"+       "#b#i#o1" "#x#i#o1" "#d#i#o1" "#o#i#o1"++       "+1ei" "-1ei" "+0ei" "-0ei" "+1di" "-1di" "+0di" "-0di" "+1fi" "-1fi" "+0fi" "-0fi" "0e-+i" "1d-+i"+       "0d-+i" "1f-+i" "0f-+i" "1e++i" "0e++i" "1d++i" ".10-10." "-1.e++i" "0e--01i" "1-00." "0-00." "#xf+b"+       "#x1+d" "0f++1i" "1+0d-i" ".0f--i" "1-0d-i" "#xe-ff" "0-" "0-e0"++))++(num-test (string->number "2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427") 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427)+++;;; every scheme disagrees about stuff like #b.1 or #b+i etc -- I'll just omit them++(for-each+ (lambda (p)+   (let ((sym (car p))+	 (num (cdr p)))+     (let ((tag (catch #t (lambda () (string->number sym)) (lambda args 'error))))+       (if (not (equal? num tag))+	   (begin (display "(string->number \"") (display sym) (display "\") = ")+		  (display tag) (display " [") (display num) (display "])") (newline))))))+ '(("#xe/d" . 14/13) ("#xb/d" . 11/13) ("#xf/d" . 15/13) ("#x1/f" . 1/15) ("#xd/f" . 13/15) ("#xe/f" . 14/15) ("#d.1" . .1) ("#d01" . 1)+   ("#d+1" . 1) ("#d+0" . 0) ("#d0+i" . 0+i) ("#xe+i" . 14.0+1.0i) ("#xf+i" . 15.0+1.0i) ("#d1-i" . 1.0-1.0i) ("#e1+i" . 1+i)+   ))++(test (equal? #e1.5 3/2) #t)+(test (equal? #e1.0 1) #t)+(test (equal? #e-.1 -1/10) #t)+(test (equal? #e1 1) #t)+(test (equal? #e3/2 3/2) #t)+(test (< (abs (- #i3/2 1.5)) 1e-12) #t)+(test (< (abs (- #i1 1.0)) 1e-12) #t)+(test (< (abs (- #i-1/10 -0.1)) 1e-12) #t)+(test (< (abs (- #i1.5 1.5)) 1e-12) #t)+(num-test (= 0e-1 0.0) #t)+;;; (/ (/ 0))??++;;; here's code to generate all (im)possible numbers (using just a few digits) of a given length [leaving aside @ and # and so on]+;(define file (open-output-file "ntest.scm"))+;(define chars (list #\1 #\0 #\9 #\@ #\# #\. #\+ #\- #\e #\i #\/ #\b #\x #\d #\o #\l #\s #\f))+;+;(define (all-syms f len with-file)+;  (let ((sym (make-string len))+;	(num-chars (length chars))+;	(ctrs (make-vector len 0)))+;    (do ((i 0 (+ i 1)))+;	((= i (expt num-chars len)))+;      (let ((carry #t))+;	(do ((k 0 (+ k 1)))+;	    ((or (= k len)+;		 (not carry)))+;	  (vector-set! ctrs k (+ 1 (vector-ref ctrs k)))+;	  (if (= (vector-ref ctrs k) num-chars)+;	      (vector-set! ctrs k 0)+;	      (set! carry #f)))+;	(do ((k 0 (+ k 1)))+;	    ((= k len))+;	  (string-set! sym k (list-ref chars (vector-ref ctrs k)))))+;+;      ;(display (format #f "~S " sym))+;+;      (let ((tag (catch #t (lambda () (string->number sym)) (lambda args (car args)))))+;	(if (not with-file)+;	    (if (and (number? tag)+;		     (= tag 1))+;		(display (format #f "~S " sym)))+;	    (begin+;	      (if (number? tag)+;		  (display (format file "(if (not (number? (string->number ~S))) (begin (display ~S) (display #\space)))"))+;		  (display (format file "(if (number? (string->number ~S)) (begin (display ~S) (display #\space)))")))+;	      (newline file)))))))+;+;(do ((len 1 (+ len 1)))+;    ((= len 12))+;  (all-syms file len #f)+;  (newline))+;+;(close-output-port file)++(for-each+ (lambda (n name)+    (if (number? n)+	(begin+	  (display "(number? ") (display name) (display ") returned #t?") (newline))))+(list+'a9 'aa 'aA 'a! 'a$ 'a% 'a& 'a* 'a+ 'a- 'a. 'a/ 'a: 'a< 'a= 'a> 'a? 'a@ 'a^ 'a_ 'a~ 'A9 'Aa 'AA 'A! 'A$ 'A% 'A& 'A* 'A+ 'A- 'A. 'A/ 'A: 'A< 'A= 'A> 'A? 'A@ 'A^ 'A_ 'A~ '!9 '!a '!A '!! '!$ '!% '!& '!* '!+ '!- '!. '!/ '!: '!< '!= '!> '!? '!@ '!^ '!_ '!~ '$9 '$a '$A '$! '$$ '$% '$& '$* '$+ '$- '$. '$/ '$: '$< '$= '$> '$? '$@ '$^ '$_ '$~ '%9 '%a '%A '%! '%$ '%% '%& '%* '%+ '%- '%. '%/ '%: '%< '%= '%> '%? '%@ '%^ '%_ '%~ '&9 '&a '&A '&! '&$ '&% '&& '&* '&+ '&- '&. '&/ '&: '&< '&= '&> '&? '&@ '&^ '&_ '&~ '*9 '*a '*A '*! '*$ '*% '*& '** '*+ '*- '*. '*/ '*: '*< '*= '*> '*? '*@ '*^ '*_ '*~ '/9 '/a '/A '/! '/$ '/% '/& '/* '/+ '/- '/. '// '/: '/< '/= '/> '/? '/@ '/^ '/_ '/~ ':9 ':a ':A ':! ':$ ':% ':& ':* ':+ ':- ':. ':/ ':: ':< ':= ':> ':? ':@ ':^ ':_ ':~ '<9 '<a '<A '<! '<$ '<% '<& '<* '<+ '<- '<. '</ '<: '<< '<= '<> '<? '<@ '<^ '<_ '<~ '=9 '=a '=A '=! '=$ '=% '=& '=* '=+ '=- '=. '=/ '=: '=< '== '=> '=? '=@ '=^ '=_ '=~ '>9 '>a '>A '>! '>$ '>% '>& '>* '>+ '>- '>. '>/ '>: '>< '>= '>> '>? '>@ '>^ '>_ '>~ '?9 '?a '?A '?! '?$ '?% '?& '?* '?+ '?- '?. '?/ '?: '?< '?= '?> '?? '?@ '?^ '?_ '?~ '^9 '^a '^A '^! '^$ '^% '^& '^* '^+ '^- '^. '^/ '^: '^< '^= '^> '^? '^@ '^^ '^_ '^~ '_9 '_a '_A '_! '_$ '_% '_& '_* '_+ '_- '_. '_/ '_: '_< '_= '_> '_? '_@ '_^ '__ '_~ '~9 '~a '~A '~! '~$ '~% '~& '~* '~+ '~- '~. '~/ '~: '~< '~= '~> '~? '~@ '~^ '~_ '~~)++(list+"'a9" "'aa" "'aA" "'a!" "'a$" "'a%" "'a&" "'a*" "'a+" "'a-" "'a." "'a/" "'a:" "'a<" "'a=" "'a>" "'a?" "'a@" "'a^" "'a_" "'a~" "'A9" "'Aa" "'AA" "'A!" "'A$" "'A%" "'A&" "'A*" "'A+" "'A-" "'A." "'A/" "'A:" "'A<" "'A=" "'A>" "'A?" "'A@" "'A^" "'A_" "'A~" "'!9" "'!a" "'!A" "'!!" "'!$" "'!%" "'!&" "'!*" "'!+" "'!-" "'!." "'!/" "'!:" "'!<" "'!=" "'!>" "'!?" "'!@" "'!^" "'!_" "'!~" "'$9" "'$a" "'$A" "'$!" "'$$" "'$%" "'$&" "'$*" "'$+" "'$-" "'$." "'$/" "'$:" "'$<" "'$=" "'$>" "'$?" "'$@" "'$^" "'$_" "'$~" "'%9" "'%a" "'%A" "'%!" "'%$" "'%%" "'%&" "'%*" "'%+" "'%-" "'%." "'%/" "'%:" "'%<" "'%=" "'%>" "'%?" "'%@" "'%^" "'%_" "'%~" "'&9" "'&a" "'&A" "'&!" "'&$" "'&%" "'&&" "'&*" "'&+" "'&-" "'&." "'&/" "'&:" "'&<" "'&=" "'&>" "'&?" "'&@" "'&^" "'&_" "'&~" "'*9" "'*a" "'*A" "'*!" "'*$" "'*%" "'*&" "'**" "'*+" "'*-" "'*." "'*/" "'*:" "'*<" "'*=" "'*>" "'*?" "'*@" "'*^" "'*_" "'*~" "'/9" "'/a" "'/A" "'/!" "'/$" "'/%" "'/&" "'/*" "'/+" "'/-" "'/." "'//" "'/:" "'/<" "'/=" "'/>" "'/?" "'/@" "'/^" "'/_" "'/~" "':9" "':a" "':A" "':!" "':$" "':%" "':&" "':*" "':+" "':-" "':." "':/" "'::" "':<" "':=" "':>" "':?" "':@" "':^" "':_" "':~" "'<9" "'<a" "'<A" "'<!" "'<$" "'<%" "'<&" "'<*" "'<+" "'<-" "'<." "'</" "'<:" "'<<" "'<=" "'<>" "'<?" "'<@" "'<^" "'<_" "'<~" "'=9" "'=a" "'=A" "'=!" "'=$" "'=%" "'=&" "'=*" "'=+" "'=-" "'=." "'=/" "'=:" "'=<" "'==" "'=>" "'=?" "'=@" "'=^" "'=_" "'=~" "'>9" "'>a" "'>A" "'>!" "'>$" "'>%" "'>&" "'>*" "'>+" "'>-" "'>." "'>/" "'>:" "'><" "'>=" "'>>" "'>?" "'>@" "'>^" "'>_" "'>~" "'?9" "'?a" "'?A" "'?!" "'?$" "'?%" "'?&" "'?*" "'?+" "'?-" "'?." "'?/" "'?:" "'?<" "'?=" "'?>" "'??" "'?@" "'?^" "'?_" "'?~" "'^9" "'^a" "'^A" "'^!" "'^$" "'^%" "'^&" "'^*" "'^+" "'^-" "'^." "'^/" "'^:" "'^<" "'^=" "'^>" "'^?" "'^@" "'^^" "'^_" "'^~" "'_9" "'_a" "'_A" "'_!" "'_$" "'_%" "'_&" "'_*" "'_+" "'_-" "'_." "'_/" "'_:" "'_<" "'_=" "'_>" "'_?" "'_@" "'_^" "'__" "'_~" "'~9" "'~a" "'~A" "'~!" "'~$" "'~%" "'~&" "'~*" "'~+" "'~-" "'~." "'~/" "'~:" "'~<" "'~=" "'~>" "'~?" "'~@" "'~^" "'~_" "'~~"))++;(let ((initial-chars "aA!$%&*/:<=>?^_~")+;      (subsequent-chars "9aA!$%&*+-./:<=>?@^_~"))+;  (do ((i 0 (+ i 1)))+;      ((= i (string-length initial-chars)))+;    (do ((k 0 (+ k 1)))+;	((= k (string-length subsequent-chars)))+;      (display (format #f "'~A " (string (string-ref initial-chars i) (string-ref subsequent-chars k)))))))+++(for-each+ (lambda (z)+   (if (not (zero? z))+       (begin (display z) (display " is not zero?") (newline)))+   (if (and (real? z) (positive? z))+       (begin (display z) (display " is positive?") (newline)))+   (if (and (real? z) (negative? z))+       (begin (display z) (display " is negative?") (newline))))+ '(0 -0 +0 0.0 -0.0 +0.0 0/1 -0/1 +0/24 0+0i 0-0i -0-0i +0-0i 0.0-0.0i -0.0+0i #b0 #o-0 #x000 #e0 #e0.0 #e#b0 #b#e0 #e0/1 #b+0))+++;;; these 2 are (mostly) from guile+(for-each+ (lambda (x)+   (if (string->number x)+       (begin+	 (display "(string->number ") (display x) (display ") returned ") (display (string->number x)) (newline))))+ '("" "q" "1q" "6+7iq" "8+9q" "10+11" "13+" "18@19q" "20@q" "23@"+   "+25iq" "26i" "-q" "-iq" "i" "5#.0" "8/" "10#11" ".#" "."+   "3.4q" "15.16e17q" "18.19e+q" ".q" ".17#18" "10q" "#b2" "#b12" "#b-12"+   "#b3" "#b4" "#b5" "#b6" "#b7" "#b8" "#b9" "#ba" "#bb" "#bc"+   "#bd" "#be" "#bf" "#q" "#b#b1" "#o#o1" "#d#d1" "#x#x1" "#e#e1" "#xag" "#x1x"+   "#o8" "#o9" "1/#e1" "#o#" "#e#i1" "#d--2" "#b#x1" "#i#x#b1" "#e#e#b1" "#e#b#b1"+   "-#b1" "+#b1" "#b1/#b2" "#b1+#b1i" "1+#bi" "1+#b1i" "1#be1" "#b" "#o" "#" "#ea" "#e1a" "1+ie1" "1+i1" "1e+1i"+   "#e#b" "#b#b" "#b#b1" "1e3e4" "1.0e-3e+4" "1e3s" "1e3s3" "#o#x1" "#i#i1" "1e-i" "#be1" "1/i" "1/e1" "1+e1"+   "1e+" "1e1+" "1e1e1" "1e-+1" "1e0x1" "1e-"+   "#i#i1" "12@12+0i"))++(for-each+ (lambda (couple)+   (apply+    (lambda (x y)+      (let ((xx (string->number x)))+	(if (or (eq? xx #f)+		(and (exact? y)+		     (not (eqv? xx y)))+		(> (abs (- xx y)) 1e-12))+	    (begin+	      (display "(string->number ") (display x) (display ") returned ") (display (string->number x)) (display " but expected ") (display y) (newline)))))+    couple))+ `(;; Radix:+   ("#b0" 0)  ("#b1" 1) ("#o0" 0) ("#b-1" -1) ("#b+1" 1)+   ("#o1" 1)  ("#o2" 2) ("#o3" 3) ("#o-1" -1)+   ("#o4" 4)  ("#o5" 5) ("#o6" 6)+   ("#o7" 7)  ("#d0" 0) ("#d1" 1)+   ("#d2" 2)  ("#d3" 3) ("#d4" 4)+   ("#d5" 5)  ("#d6" 6) ("#d7" 7) ("#d-123" -123) ("#d+123" 123)+   ("#d8" 8)  ("#d9" 9)+   ("#xa" 10) ("#xb" 11) ("#x-1" -1) ("#x-a" -10)+   ("#xc" 12) ("#xd" 13)+   ("#xe" 14) ("#xf" 15) ("#x-abc" -2748)+   ("#b1010" 10)+   ("#o12345670" 2739128)+   ("#d1234567890" 1234567890)+   ("#x1234567890abcdef" 1311768467294899695)+   ;; Exactness:+   ("#e1" 1) ("#e1.2" 12/10)+   ("#i1.1" 1.1) ("#i1" 1.0)+   ;; Integers:+   ("1" ,(+ 1 0)) ("23" ,(+ 9 9 5)) ("-1" ,(- 0 1))+   ("-45" ,(- 0 45)) ;("2#" 20.0) ("2##" 200.0) ("12##" 1200.0) ; this # = 0 is about the stupidest thing I've ever seen+   ("#b#i100" 4.0) ("#b#e100" 4) ("#i#b100" 4.0) ("#e#b100" 4)+   ("#b#i-100" -4.0) ("#b#e+100" 4) ("#i#b-100" -4.0) ("#e#b+100" 4)+   ("#o#i100" 64.0) ("#o#e100" 64) ("#i#o100" 64.0) ("#e#o100" 64)+   ("#d#i100" 100.0) ("#d#e100" 100) ("#i#d100" 100.0) ("#e#d100" 100)+   ("#x#i100" 256.0) ("#x#e100" 256) ("#i#x100" 256.0) ("#e#x100" 256)+   ("#e#xee" 238) ("#e#x1e1" 481)++   ;; Fractions:+   ("1/1" 1) ("1/2" 1/2) ("-1/2" -1/2) ;("1#/1" 10.0)+   ;("10/1#" 1.0) ("1#/1#" 1.0) ("#e9/10" 9/10) ("#e10/1#" 1)+   ;("#i6/8" 0.75) ("#i1/1" 1.0)+   ;; Decimal numbers:+   ;; * <uinteger 10> <suffix>+   ("1e2" 100.0) ("1s2" 100.0)+   ("1f2" 100.0) ("1d2" 100.0)+   ;("1l2" 100.0)+   ("1e+2" 100.0) ("1e-2" 0.01)+   ;; * . <digit 10>+ #* <suffix>+   (".1" .1) (".0123456789" 123456789e-10) ;(".16#" 0.16)+   (".0123456789e10" 123456789.0) ;(".16#e3" 160.0) ("#d.3" 0.3)+   ;; * <digit 10>+ . <digit 10>* #* <suffix>+   ("3." ,(exact->inexact 3)) ("3.e0" ,(exact->inexact 3))+   ("3.1" ,(exact->inexact 31/10)) ("3.1e0" 3.1) ;("3.1#" 3.1)+   ;("3.1#e0" 3.1)+   ;; * <digit 10>+ #+ . #* <suffix>+   ;("3#." 30.0) ("3#.e0" 30.0) ("3#.#" 30.0) ("3#.#e0" 30.0)+   ;; Complex:+   ;; ("1@0" 1.0) ("1@+0" 1.0) ("1@-0" 1.0)          ; whose dumb idea was this?+   ("2+3i" ,(+ 2 (* 3 0+i))) ("4-5i" ,(- 4 (* 5 0+i)))+   ("1+i" 1+1i) ("1-i" 1-1i)+   ;; ("+1i" 0+1i) ("-1i" 0-1i) ("+i" +1i) ("-i" -1i) ; I don't like these+   ("#e1e1" 10) ("#i1e1+i" 10.0+1.0i)+   ))++;;; --------------------------------------------------------------------------------++(if with-error-checks+    (begin++      (test (eq?) 'error)+      (test (eq? #t) 'error)+      (test (eqv?) 'error)+      (test (eqv? #t) 'error)+      (test (equal?) 'error)+      (test (equal? #t) 'error)+      (test (boolean?) 'error)+      (test (not) 'error)+      (test (symbol?) 'error)+      (test (procedure?) 'error)+      (test (char?) 'error)+					;(test (char? '#\xxx) 'error) ; or possibly #f??+      (test (char-upper-case? 1) 'error)+      (test (char-upper-case?) 'error)+      (test (char-upper-case? 1) 'error)+      (test (char-upper-case?) 'error)+      (test (char-upcase) 'error)+      (test (char-downcase) 'error)+      (test (char-numeric?) 'error)+      (test (char-whitespace?) 'error)+      (test (char-alphabetic?) 'error)++      (for-each+       (lambda (op)+	 (for-each+	  (lambda (arg)+	    (test (op arg) 'error))+	  (list "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #f #t (lambda (a) (+ a 1)))))+       (list char-upper-case? char-lower-case? char-upcase char-downcase char-numeric? char-whitespace? char-alphabetic?))++      (for-each+       (lambda (op)+	 (for-each+	  (lambda (arg)+	    (test (op #\a arg) 'error))+	  (list "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #f #t (lambda (a) (+ a 1)))))+       (list char=? char<? char<=? char>? char>? char-ci=? char-ci<? char-ci<=? char-ci>? char-ci>=?))++      (for-each+       (lambda (op)+	 (for-each+	  (lambda (arg)+	    (test (op arg #\a) 'error))+	  (list "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #f #t (lambda (a) (+ a 1)))))+       (list char=? char<? char<=? char>? char>? char-ci=? char-ci<? char-ci<=? char-ci>? char-ci>=?))++      (test (char=? #\a) 'error)+      (test (char=?) 'error)+      (test (char<?) 'error)+      (test (char<=?) 'error)+      (test (char>?) 'error)+      (test (char>=?) 'error)+      (test (char-ci=?) 'error)+      (test (char->integer 33) 'error)+      (test (char->integer) 'error)+      (test (integer->char) 'error)++      (for-each+       (lambda (arg)+	 (test (char->integer arg) 'error))+       (list -1 1 0 123456789 "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (integer->char arg) 'error))+       (list -1 123456789 -123456789 #\a "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))+++					;(test (string? "das ist die eine haelfte" "und das die andere") 'error)+      (test (string?) 'error)++      (for-each+       (lambda (arg)+	 (test (string=? "hi" arg) 'error))+       (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string<? "hi" arg) 'error))+       (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string>? "hi" arg) 'error))+       (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string<=? "hi" arg) 'error))+       (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string>=? "hi" arg) 'error))+       (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string-ci=? "hi" arg) 'error))+       (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))+++      (for-each+       (lambda (arg)+	 (test (string-ci<? "hi" arg) 'error))+       (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string-ci>? "hi" arg) 'error))+       (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string-ci<=? "hi" arg) 'error))+       (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string-ci>=? "hi" arg) 'error))+       (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string-length arg) 'error))+       (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string #\a arg) 'error))+       (list '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (test (make-string -1) 'error)++      (for-each+       (lambda (arg)+	 (test (make-string 3 arg) 'error))+       (list "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (make-string arg #\a) 'error))+       (list #\a "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (make-string arg) 'error))+       (list #\a "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (test (string-ref "abcdef-dg1ndh" 20) 'error)+      (test (string-ref "abcdef-dg1ndh") 'error)+      (test (string-ref "abcdef-dg1ndh" -3) 'error)+      (test (string-ref) 'error)+      (test (string-ref 2) 'error)+      (test (string-ref "\"\\\"" 3) 'error)+      (test (string-ref "" 0) 'error)  ; guile returns #\nul here?+      (test (string-ref "" 1) 'error)++      (for-each+       (lambda (arg)+	 (test (string-ref arg 0) 'error))+       (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string-ref "hiho" arg) 'error))+       (list #\a -1 123 4 "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (test (let ((hi (string-copy "hi"))) (string-set! hi 2 #\H) hi) 'error)+      (test (let ((hi (string-copy "hi"))) (string-set! hi -1 #\H) hi) 'error)+      (test (let ((g (lambda () "***"))) (string-set! (g) 0 #\?)) 'error) ; guile is happy here and below+      (test (string-set! "" 0 #\a) 'error)+      (test (string-set! "" 1 #\a) 'error)+      (test (string-set! (string) 0 #\a) 'error)+      (test (string-set! (symbol->string 'lambda) 0 #\a) 'error)++      (for-each+       (lambda (arg)+	 (test (string-set! arg 0 #\a) 'error))+       (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string-set! "hiho" arg #\a) 'error))+       (list #\a -1 123 4 "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string-set! "hiho" 0 arg) 'error))+       (list 1 "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))+++      (test (substring "ab" 0 3) 'error)+      (test (substring "ab" 3 3) 'error)+      (test (substring "ab" 2 3) 'error)+      (test (substring "" 0 1) 'error)+      (test (substring "" -1 0) 'error)+      (test (substring "abc" -1 0) 'error)++      (for-each+       (lambda (arg)+	 (test (substring "hiho" arg 0) 'error))+       (list "hi" #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (substring "hiho" 1 arg) 'error))+       (list "hi" #\a 0 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (substring arg 1 2) 'error))+       (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string-append "hiho" arg) 'error))+       (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (let ((hiho "hiho")) (string-fill! hiho arg) hiho) 'error))+       (list 1 "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string-fill! arg #\a) 'error))+       (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string-copy arg) 'error))+       (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string->list arg) 'error))+       (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (test (let ((x (cons #\a #\b))) (set-cdr! x x) (list->string x)) 'error)++      (for-each+       (lambda (arg)+	 (test (list->string arg) 'error))+       (list "hi" #\a 1 ''foo '(1 . 2) (cons #\a #\b) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (symbol->string arg) 'error))+       (list #\a 1 '() (list 1) '(1 . 2) #f (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (string->symbol arg) 'error))+       (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++++      (for-each+       (lambda (op)+	 (for-each+	  (lambda (arg)+	    (let ((result (catch #t (lambda () (op arg)) (lambda args 'error))))+	      (if (not (eq? result 'error))+		  (begin+		    (display "(") (display op) (display " ") (display arg) (display ") returned ") (display result) (display "?") (newline)))))+	  (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1)))))++       (list reverse cons car cdr set-car! set-cdr! caar cadr cdar cddr caaar caadr cadar cdaar caddr cdddr cdadr cddar+	     caaaar caaadr caadar cadaar caaddr cadddr cadadr caddar cdaaar cdaadr cdadar cddaar cdaddr cddddr cddadr cdddar+	     length assq assv assoc memq memv member list-ref list-tail))++      (test (cons 1 . 2) 'error)+      (test (car (list)) 'error)+      (test (car '()) 'error)+      (test (cdr (list)) 'error)+      (test (cdr '()) 'error)+      (test (caddar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) 'error)+      (test (cdddar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) 'error)+      (test (caar '(a b c d e f g)) 'error)+      (test (cdar '(a b c d e f g)) 'error)+      (test (caaar '(a b c d e f g)) 'error)+      (test (caadr '(a b c d e f g)) 'error)+      (test (cadar '(a b c d e f g)) 'error)+      (test (cdaar '(a b c d e f g)) 'error)+      (test (cdadr '(a b c d e f g)) 'error)+      (test (cddar '(a b c d e f g)) 'error)+      (test (caaaar '(a b c d e f g)) 'error)+      (test (caaadr '(a b c d e f g)) 'error)+      (test (caadar '(a b c d e f g)) 'error)+      (test (caaddr '(a b c d e f g)) 'error)+      (test (cadaar '(a b c d e f g)) 'error)+      (test (cadadr '(a b c d e f g)) 'error)+      (test (caddar '(a b c d e f g)) 'error)+      (test (cdaaar '(a b c d e f g)) 'error)+      (test (cdaadr '(a b c d e f g)) 'error)+      (test (cdadar '(a b c d e f g)) 'error)+      (test (cdaddr '(a b c d e f g)) 'error)+      (test (cddaar '(a b c d e f g)) 'error)+      (test (cddadr '(a b c d e f g)) 'error)+      (test (cdddar '(a b c d e f g)) 'error)+      (test (caar 'a) 'error)+      (test (caar '(a)) 'error)+      (test (cadr 'a) 'error)+      (test (cadr '(a . b)) 'error)+      (test (cdar 'a) 'error)+      (test (cdar '(a . b)) 'error)+      (test (cddr 'a) 'error)+      (test (cddr '(a . b)) 'error)+      (test (caaar 'a) 'error)+      (test (caaar '(a)) 'error)+      (test (caaar '((a))) 'error)+      (test (caadr 'a) 'error)+      (test (caadr '(a . b)) 'error)+      (test (caadr '(a b)) 'error)+      (test (cadar 'a) 'error)+      (test (cadar '(a . b)) 'error)+      (test (cadar '((a . c) . b)) 'error)+      (test (caddr 'a) 'error)+      (test (caddr '(a . b)) 'error)+      (test (caddr '(a c . b)) 'error)+      (test (cdaar 'a) 'error)+      (test (cdaar '(a)) 'error)+      (test (cdaar '((a . b))) 'error)+      (test (cdadr 'a) 'error)+      (test (cdadr '(a . b)) 'error)+      (test (cdadr '(a b . c)) 'error)+      (test (cddar 'a) 'error)+      (test (cddar '(a . b)) 'error)+      (test (cddar '((a . b) . b)) 'error)+      (test (cdddr 'a) 'error)+      (test (cdddr '(a . b)) 'error)+      (test (cdddr '(a c . b)) 'error)+      (test (caaaar 'a) 'error)+      (test (caaaar '(a)) 'error)+      (test (caaaar '((a))) 'error)+      (test (caaaar '(((a)))) 'error)+      (test (caaadr 'a) 'error)+      (test (caaadr '(a . b)) 'error)+      (test (caaadr '(a b)) 'error)+      (test (caaadr '(a (b))) 'error)+      (test (caadar 'a) 'error)+      (test (caadar '(a . b)) 'error)+      (test (caadar '((a . c) . b)) 'error)+      (test (caadar '((a c) . b)) 'error)+      (test (caaddr 'a) 'error)+      (test (caaddr '(a . b)) 'error)+      (test (caaddr '(a c . b)) 'error)+      (test (caaddr '(a c b)) 'error)+      (test (cadaar 'a) 'error)+      (test (cadaar '(a)) 'error)+      (test (cadaar '((a . b))) 'error)+      (test (cadaar '((a b))) 'error)+      (test (cadadr 'a) 'error)+      (test (cadadr '(a . b)) 'error)+      (test (cadadr '(a b . c)) 'error)+      (test (cadadr '(a (b . e) . c)) 'error)+      (test (caddar 'a) 'error)+      (test (caddar '(a . b)) 'error)+      (test (caddar '((a . b) . b)) 'error)+      (test (caddar '((a b . c) . b)) 'error)+      (test (cadddr 'a) 'error)+      (test (cadddr '(a . b)) 'error)+      (test (cadddr '(a c . b)) 'error)+      (test (cadddr '(a c e . b)) 'error)+      (test (cdaaar 'a) 'error)+      (test (cdaaar '(a)) 'error)+      (test (cdaaar '((a))) 'error)+      (test (cdaaar '(((a . b)))) 'error)+      (test (cdaadr 'a) 'error)+      (test (cdaadr '(a . b)) 'error)+      (test (cdaadr '(a b)) 'error)+      (test (cdaadr '(a (b . c))) 'error)+      (test (cdadar 'a) 'error)+      (test (cdadar '(a . b)) 'error)+      (test (cdadar '((a . c) . b)) 'error)+      (test (cdadar '((a c . d) . b)) 'error)+      (test (cdaddr 'a) 'error)+      (test (cdaddr '(a . b)) 'error)+      (test (cdaddr '(a c . b)) 'error)+      (test (cdaddr '(a c b . d)) 'error)+      (test (cddaar 'a) 'error)+      (test (cddaar '(a)) 'error)+      (test (cddaar '((a . b))) 'error)+      (test (cddaar '((a b))) 'error)+      (test (cddadr 'a) 'error)+      (test (cddadr '(a . b)) 'error)+      (test (cddadr '(a b . c)) 'error)+      (test (cddadr '(a (b . e) . c)) 'error)+      (test (cdddar 'a) 'error)+      (test (cdddar '(a . b)) 'error)+      (test (cdddar '((a . b) . b)) 'error)+      (test (cdddar '((a b . c) . b)) 'error)+      (test (cddddr 'a) 'error)+      (test (cddddr '(a . b)) 'error)+      (test (cddddr '(a c . b)) 'error)+      (test (cddddr '(a c e . b)) 'error)++      (test (length 'x) 'error)+      (test (length (cons 1 2)) 'error)+      (let ((x (list 1 2)))+	(set-cdr! x x)+	(test (length x) 'error))+      (test (length '(1 2 . 3)) 'error)++      (test (reverse (cons 1 2)) 'error)+      (test (reverse '(1 . 2)) 'error)+      (test (reverse '(1 2 . 3)) 'error)++      (test (set-car! '() 32) 'error)+      (test (set-car! 'x 32) 'error)+      (test (set-car! #f 32) 'error)+      (test (set-cdr! '() 32) 'error)+      (test (set-cdr! 'x 32) 'error)+      (test (set-cdr! #f 32) 'error)++      (test (list-ref '() 0) 'error)+      (test (list-ref (list 1 2) 2) 'error)+      (test (list-ref (list 1 2) -1) 'error)+      (test (list-ref (list 1 2) 1.3) 'error)+      (test (list-ref (list 1 2) 1/3) 'error)+      (test (list-ref (list 1 2) 1+2.0i) 'error)+      (test (list-ref (cons 1 2) 1) 'error)+      (test (list-ref (cons 1 2) 2) 'error)++      (for-each+       (lambda (arg)+	 (test (list-ref (list 1 2) arg) 'error))+       (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1))))++      (test (list-set! '() 0 1) 'error)+      (test (list-set! '(1) 1 2) 'error)+      (test (list-set! '(1 2 3) -1 2) 'error)+      (test (list-set! '(1) 1.5 2) 'error)+      (test (list-set! '(1) 3/2 2) 'error)+      (test (list-set! '(1) 1+3i 2) 'error)+      (test (let ((x (cons 1 2))) (list-set! x 1 3) x) 'error)++      (for-each+       (lambda (arg)+	 (test (list-set! (list 1 2) arg arg) 'error))+       (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1))))++      (test (list 1 2 . 3) 'error)+      (test (list 1 2 , 3) 'error)+      (test (list 1 2 ,@ 3) 'error)++      (test (list-tail (list 1 2) 3) 'error)+      (test (list-tail (list 1 2) -1) 'error)+      (test (list-tail (list 1 2) 1.3) 'error)+      (test (list-tail (list 1 2) 1/3) 'error)+      (test (list-tail (list 1 2) 1+2.0i) 'error)+      (test (list-tail (cons 1 2) 2) 'error)+      (test (list-tail '(1 2 . 3)) 'error)++      (for-each+       (lambda (arg)+	 (test (list-tail (list 1 2) arg) 'error))+       (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1))))+++      (test (assq #f '(#f 2 . 3)) 'error)+      (test (assq #f '((#f 2) . 3)) 'error) ; an a-list is a proper list sez kd+      (test (assv 1 '(1 2 . 3)) 'error)+      (test (assv 1 '((1 2) . 3)) 'error) ; an a-list is a proper list sez kd++      (test (assoc '() 1) 'error)+      (test (assoc (cons 1 2) 1) 'error)+      (test (assoc (let ((x (cons 1 2))) (set-cdr! x x)) 1) 'error)+      (test (assoc '((1 2) .3) 1) 'error)+      (test (assoc ''foo quote) 'error)+      (test (assoc 1 '(1 2 . 3)) 'error)+      (test (assoc 1 '((1 2) . 3)) 'error) ; an a-list is a proper list sez kd++      ;(test (let ((lst '((1 2)))) (assq #t (reverse! lst lst))) #f) ; this will hang Guile+++      (test (append 'a 'b) 'error)+      (test (append 'a '()) 'error)+      (test (append (cons 1 2) '()) 'error)+      (test (append '(1) 2 '(3)) 'error)+      (test (append '(1) 2 3) 'error)++					;(test (memq 'a (cons a b)) 'error)                  ; there is disagreement about this+      (test (memq 'a (list a b . c)) 'error)+					;(test (memv 1 (cons 1 2)) 'error)                   ; there is disagreement about this+      (test (memv 'a (list a b . c)) 'error)+					;(test (member 1 (cons 1 2)) 'error)                 ; there is disagreement about this+      (test (member 'a (list a b . c)) 'error)+      (test (member 1 '(1 2 . 3)) 'error)++      (test (make-vector) 'error)++      (for-each+       (lambda (arg)+	 (test (make-vector arg) 'error))+       (list #\a '() -1 #f "hi" 'a-symbol abs 3.14 3/4 1.0+1.0i #t (vector 1 2 3) (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (vector->list arg) 'error))+       (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol "hi" abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (test (let ((x (cons #\a #\b))) (set-cdr! x x) (list->vector x)) 'error)+      (test (list->vector (cons 1 2)) 'error)+      (test (list->vector '(1 2 . 3)) 'error)++      (for-each+       (lambda (arg)+	 (test (list->vector arg) 'error))+       (list "hi" #\a 1 '(1 . 2) (cons #\a #\b) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (for-each+       (lambda (arg)+	 (test (vector-length arg) 'error))+       (list "hi" #\a 1 '(1 . 2) (cons #\a #\b) #f 'a-symbol abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (test (let ((v (make-vector 1 0))) (vector-ref v 1)) 'error)+      (test (let ((v (make-vector 1 0))) (vector-ref v -1)) 'error)+      (test (let ((v (vector 1 (list 2) (make-vector 3 #\a)))) (vector-ref (vector-ref v 2) 3)) 'error)+      (test (let ((v (vector 1 (list 2) (make-vector 3 #\a)))) (vector-ref (vector-ref v 3) 0)) 'error)+      (test (vector-ref (vector) 0) 'error)+      (test (vector-ref '#() 0) 'error)+      (test (vector-ref '#() -1) 'error)+      (test (vector-ref '#() 1) 'error)++					;(test (vector-set! '#(0 1 2) 1 "doe") 'error)+      (test (let ((v (vector 1 2 3))) (vector-set! v -1 0)) 'error)+      (test (let ((v (vector 1 2 3))) (vector-set! v 3 0)) 'error)++      (let ((v (vector 1 2 3)))+	(for-each+	 (lambda (arg)+	   (test (vector-set! v arg 0) 'error))+	 (list "hi" #\a -1 '(1 . 2) (cons #\a #\b) #f 'a-symbol abs 3.14 3/4 1.0+1.0i #t (make-vector 3) (lambda (a) (+ a 1)))))++      (for-each+       (lambda (arg)+	 (test (vector-set! arg 0 0) 'error))+       (list "hi" #\a 1 '(1 . 2) (cons #\a #\b) #f 'a-symbol abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++      (let ((v (vector)))+	(test (vector-set! v 0 0) 'error)+	(test (vector-set! v 1 0) 'error)+	(test (vector-set! v -1 0) 'error))++      (for-each+       (lambda (arg)+	 (test (vector-fill! arg 0) 'error))+       (list "hi" #\a 1 '(1 . 2) (cons #\a #\b) #f 'a-symbol abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1))))++++      (for-each+       (lambda (arg)+	 (test (string->number arg) 'error))+       (list -1 #\a 1 '#(1 2 3) 3.14 3/4 1.0+1.0i '() 'hi abs '#(()) (list 1 2 3) '(1 . 2) (lambda () 1)))++      (for-each+       (lambda (arg)+	 (test (string->number "123" arg) 'error)+	 (test (string->number "1" arg) 'error))+       (list -1 0 1 #\a '#(1 2 3) 3.14 3/4 1.5+0.3i 1+i '() 'hi abs '#(()) (list 1 2 3) '(1 . 2) (lambda () 1)))++      ;; (string->number "0" 1) ?? why not?++      (for-each+       (lambda (arg)+	 (test (number->string arg) 'error))+       (list #\a '#(1 2 3) '() 'hi abs "hi" '#(()) (list 1 2 3) '(1 . 2) (lambda () 1)))++      (for-each+       (lambda (arg)+	 (test (number->string 123 arg) 'error))+       (list -1 0 1 512 #\a '#(1 2 3) 3.14 2/3 1.5+0.3i 1+i '() 'hi abs "hi" '#(()) (list 1 2 3) '(1 . 2) (lambda () 1)))++      (test (exact?) 'error)+      (test (exact? "hi") 'error)+      (test (exact? 1.0+23.0i 1.0+23.0i) 'error)+      (test (inexact?) 'error)+      (test (inexact? "hi") 'error)+      (test (inexact? 1.0+23.0i 1.0+23.0i) 'error)+      (test (/) 'error)+      (test (/ "hi") 'error)+      (test (zero?) 'error)+      (test (zero? "hi") 'error)+      (test (zero? 1.0+23.0i 1.0+23.0i) 'error)+      (test (positive?) 'error)+      (test (positive? 1.23+1.0i) 'error)+      (test (positive? 1.23 1.23) 'error)+      (test (negative?) 'error)+      (test (negative? 1.23+1.0i) 'error)+      (test (negative? 1.23 1.23) 'error)+      (test (even?) 'error)+      (test (even? 1.23) 'error)+      (test (even? 123 123) 'error)+      (test (odd?) 'error)+      (test (odd? 1.23) 'error)+      (test (odd? 123 123) 'error)+      (test (quotient) 'error)+      (test (quotient 123) 'error)+      (if (not with-generic-modulo)+	  (test (quotient 1.23 1.23) 'error))+      (test (quotient 123 123 123) 'error)+      (test (remainder) 'error)+      (test (remainder 123) 'error)+      (if (not with-generic-modulo)+	  (test (remainder 1.23 1.23) 'error))+      (test (remainder 123 123 123) 'error)+      (test (modulo) 'error)+      (test (modulo 123) 'error)+      (if (not with-generic-modulo)+	  (test (modulo 1.23 1.23) 'error))+      (test (modulo 123 123 123) 'error)+      (test (truncate) 'error)+      (test (truncate 1.23+1.0i) 'error)+      (if (not with-generic-modulo)+	  (test (truncate 1.23 1.23) 'error))+      (test (floor) 'error)+      (test (floor 1.23+1.0i) 'error)+      (test (floor 1.23 1.23) 'error)+      (test (ceiling) 'error)+      (test (ceiling 1.23+1.0i) 'error)+      (test (ceiling 1.23 1.23) 'error)+      (test (round) 'error)+      (test (round 1.23+1.0i) 'error)+      (test (round 1.23 1.23) 'error)+      (test (abs) 'error)+      (test (abs 1.23+1.0i) 'error)+      (test (abs 1.23 1.23) 'error)+      (test (max) 'error)+      (test (max 1.23+1.0i) 'error)+      (test (min) 'error)+      (test (min 1.23+1.0i) 'error)+      (test (expt) 'error)+      (test (expt 1.0+23.0i) 'error)+      (test (expt "hi" "hi") 'error)+      ;(test (expt 1.0+23.0i 1.0+23.0i 1.0+23.0i) 'error) ; this is ok in s7+      (test (exact->inexact) 'error)+      (test (exact->inexact "hi") 'error)+      (test (exact->inexact 1.0+23.0i 1.0+23.0i) 'error)+      (test (inexact->exact) 'error)+      (test (inexact->exact "hi") 'error)+      (test (inexact->exact 1.0+23.0i 1.0+23.0i) 'error)+      (if with-rationalize (begin+      (test (rationalize) 'error)+;      (test (rationalize 1.23) 'error)+      (test (rationalize 1.23+1.0i 1.23+1.0i) 'error)+      (test (rationalize 1.23 1.23 1.23) 'error)))+      (test (numerator) 'error)+      (test (numerator 1.23+1.0i) 'error)+      (test (numerator 1.23 1.23) 'error)+      (test (denominator) 'error)+      (test (denominator 1.23+1.0i) 'error)+      (test (denominator 1.23 1.23) 'error)+      (test (imag-part) 'error)+      (test (imag-part "hi") 'error)+      (test (imag-part 1.0+23.0i 1.0+23.0i) 'error)+      (test (real-part) 'error)+      (test (real-part "hi") 'error)+      (test (real-part 1.0+23.0i 1.0+23.0i) 'error)+      (test (magnitude) 'error)+      (test (magnitude "hi") 'error)+      (test (magnitude 1.0+23.0i 1.0+23.0i) 'error)+      (test (angle) 'error)+      (test (angle "hi") 'error)+      (test (angle 1.0+23.0i 1.0+23.0i) 'error)+      (test (make-polar) 'error)+      (test (make-polar 1.23) 'error)+      (test (make-polar 1.23+1.0i 1.23+1.0i) 'error)+      (test (make-polar 1.23 1.23 1.23) 'error)+      (test (make-rectangular) 'error)+      (test (make-rectangular 1.23) 'error)+      (test (make-rectangular 1.23+1.0i 1.23+1.0i) 'error)+      (test (make-rectangular 1.23 1.23 1.23) 'error)+      (test (sqrt) 'error)+      (test (sqrt "hi") 'error)+      (test (sqrt 1.0+23.0i 1.0+23.0i) 'error)+      (test (exp) 'error)+      (test (exp "hi") 'error)+      (test (exp 1.0+23.0i 1.0+23.0i) 'error)+      (test (log) 'error)+      (test (log "hi") 'error)+      (test (log 1.0+23.0i 1.0+23.0i 1.0+23.0i) 'error)+      (test (sin) 'error)+      (test (sin "hi") 'error)+      (test (sin 1.0+23.0i 1.0+23.0i) 'error)+      (test (cos) 'error)+      (test (cos "hi") 'error)+      (test (cos 1.0+23.0i 1.0+23.0i) 'error)+      (test (tan) 'error)+      (test (tan "hi") 'error)+      (test (tan 1.0+23.0i 1.0+23.0i) 'error)+      (test (asin) 'error)+      (test (asin "hi") 'error)+      (test (asin 1.0+23.0i 1.0+23.0i) 'error)+      (test (acos) 'error)+      (test (acos "hi") 'error)+      (test (acos 1.0+23.0i 1.0+23.0i) 'error)+      (test (atan) 'error)+      (test (atan "hi") 'error)+      (test (atan 1.0+23.0i 1.0+23.0i) 'error)++      (for-each+       (lambda (op)+	 (for-each+	  (lambda (arg)+	    (let ((val (catch #t (lambda () (op arg)) (lambda args 'error))))+	      (if (not (eq? val 'error))+		  (begin+		    (display "(") (display op) (display " ") (display arg) (display ") returned ")+		    (display val) (display " but expected 'error") (newline)))))+	  (list "hi" '() #\a (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs #t (lambda (a) (+ a 1)))))+       (list exact? inexact? zero? positive? negative? even? odd? quotient remainder modulo truncate floor ceiling round+	     abs max min gcd lcm expt exact->inexact inexact->exact rationalize numerator denominator imag-part real-part+	     magnitude angle make-polar make-rectangular sqrt exp log sin cos tan asin acos atan number->string))++      (test (string->number) 'error)+      (test (string->number 'symbol) 'error)+      (test (string->number "1.0" "1.0") 'error)+      (test (number->string) 'error)+      (test (number->string "hi") 'error)+      (test (number->string 1.0+23.0i 1.0+23.0i 1.0+23.0i) 'error)+      (test (+ 1 2 . 3) 'error)++++      (num-test (gcd 1.4 2.3) 'error)+      (num-test (lcm 1.4 2.3) 'error)+					;(num-test (gcd 2/3 1) 'error) ; these are ok in s7+					;(num-test (lcm 2/3 1) 'error)+      (num-test (gcd 2 1.0+0.5i) 'error)+      (num-test (lcm 2 1.0+0.5i) 'error)+      (test (gcd 1 "hi") 'error)+      (test (lcm 0 "hi") 'error)+      (num-test (numerator 2.3+0.5i) 'error)+      (num-test (denominator 2.3+0.5i) 'error)++      (if (not with-generic-modulo) (begin+				      (num-test (modulo 3 2.3) 'error)+				      (num-test (modulo 2.3 3) 'error)+				      (num-test (modulo 1/3 2.3) 'error)))+      (num-test (modulo 2.3 1.0+0.1i) 'error)+      (num-test (modulo 3.0+2.3i 3) 'error)+      (if (not with-generic-modulo) (begin+				      (num-test (remainder 3 2.3) 'error)+				      (num-test (remainder 2.3 3) 'error)+				      (num-test (remainder 1/3 2.3) 'error)))++      (num-test (mod 2 0) 'error)++      (num-test (remainder 2.3 1.0+0.1i) 'error)+      (num-test (remainder 3.0+2.3i 3) 'error)+      (num-test (abs 1.0+0.1i) 'error)+      (num-test (make-polar 1.0 1.0+0.1i) 'error)+      (num-test (make-polar 1.0+0.1i 0.0) 'error)+      (num-test (make-rectangular 1.0 1.0+0.1i) 'error)+      (num-test (make-rectangular 1.0+0.1i 1.0) 'error)+      (test (>=- 1 2) 'error)+      (test (>= - 1 2) 'error)++      (if with-relational-ops-that-require-at-least-2-args (begin+							     (num-test (< 0) 'error)+							     (num-test (<= 0) 'error)+							     (num-test (= 0) 'error)+							     (num-test (> 0) 'error)+							     (num-test (>= 0) 'error)+							     (num-test (< 2) 'error)+							     (num-test (<= 2) 'error)+							     (num-test (= 2) 'error)+							     (num-test (> 2) 'error)+							     (num-test (>= 2) 'error)+							     (num-test (< 0/1) 'error)+							     (num-test (<= 0/1) 'error)+							     (num-test (= 0/1) 'error)+							     (num-test (> 0/1) 'error)+							     (num-test (>= 0/1) 'error)+							     (num-test (< 10/3) 'error)+							     (num-test (<= 10/3) 'error)+							     (num-test (= 10/3) 'error)+							     (num-test (> 10/3) 'error)+							     (num-test (>= 10/3) 'error)+							     (num-test (< 0.0) 'error)+							     (num-test (<= 0.0) 'error)+							     (num-test (= 0.0) 'error)+							     (num-test (> 0.0) 'error)+							     (num-test (>= 0.0) 'error)+							     (num-test (< 1.0) 'error)+							     (num-test (<= 1.0) 'error)+							     (num-test (= 1.0) 'error)+							     (num-test (> 1.0) 'error)+							     (num-test (>= 1.0) 'error)+							     ))+++      (num-test (min 0.0+0.00000001i) 'error)+      (num-test (max 0.0+0.00000001i) 'error)+      (num-test (< 0.0+0.00000001i) 'error)+      (num-test (<= 0.0+0.00000001i) 'error)+      (num-test (= 0.0+0.00000001i) 'error)+      (num-test (> 0.0+0.00000001i) 'error)+      (num-test (>= 0.0+0.00000001i) 'error)+      (num-test (min -0.0+0.00000001i) 'error)+      (num-test (max -0.0+0.00000001i) 'error)+      (num-test (min 1.0+1.0i) 'error)+      (num-test (max 1.0+1.0i) 'error)+      (num-test (< 1.0+1.0i) 'error)+      (num-test (<= 1.0+1.0i) 'error)+      (num-test (= 1.0+1.0i) 'error)+      (num-test (> 1.0+1.0i) 'error)+      (num-test (>= 1.0+1.0i) 'error)+      (num-test (min -1.0+1.0i) 'error)+      (num-test (max -1.0+1.0i) 'error)+      (num-test (min 2.71828182845905+3.14159265358979i) 'error)+      (num-test (max 2.71828182845905+3.14159265358979i) 'error)+      (num-test (< 2.71828182845905+3.14159265358979i) 'error)+      (num-test (<= 2.71828182845905+3.14159265358979i) 'error)+      (num-test (= 2.71828182845905+3.14159265358979i) 'error)+      (num-test (> 2.71828182845905+3.14159265358979i) 'error)+      (num-test (>= 2.71828182845905+3.14159265358979i) 'error)+      (num-test (min -2.71828182845905+3.14159265358979i) 'error)+      (num-test (max -2.71828182845905+3.14159265358979i) 'error)+      (num-test (min 1234000000.0+2.71828182845905i) 'error)+      (num-test (max 1234000000.0+2.71828182845905i) 'error)+      (num-test (< 1234000000.0+2.71828182845905i) 'error)+      (num-test (<= 1234000000.0+2.71828182845905i) 'error)+      (num-test (= 1234000000.0+2.71828182845905i) 'error)+      (num-test (> 1234000000.0+2.71828182845905i) 'error)+      (num-test (>= 1234000000.0+2.71828182845905i) 'error)+      (num-test (min -1234000000.0+2.71828182845905i) 'error)+      (num-test (max -1234000000.0+2.71828182845905i) 'error)+      (num-test (< 2 1 1.0+1.0i) 'error)+      (num-test (<= 2 1 1.0+1.0i) 'error)+      (num-test (> 1 2 1.0+1.0i) 'error)+      (num-test (>= 1 2 1.0+1.0i) 'error)++      (num-test (< 2 1 #\a) 'error)+      (num-test (<= 2 1 #\a) 'error)+      (num-test (> 1 2 #\a) 'error)+      (num-test (>= 1 2 #\a) 'error)++      (num-test (= 0 1 "hi") 'error)+      (num-test (= 0.0 1.0 "hi") 'error)+      (num-test (* 0 1 "hi") 'error)+      (num-test (* 0.0 "hi") 'error)+      (num-test (* 0.0+0.0i "hi") 'error)+      (num-test (* 0/1 "hi") 'error)+      (num-test (/ 0 1 "hi") 'error)+      (num-test (gcd 0 "hi") 'error)+      (num-test (lcm 0 "hi") 'error)+      (num-test (* 1 0.0 #\a) 'error)++					;(num-test (< 3 3.0 3 3.0+1.0i) 'error)+					;(num-test (> 3 3.0 3 3.0+1.0i) 'error)+      (num-test (log 3 0) 'error)++      (for-each+       (lambda (arg)+	 (test (log 10.0 arg) 'error))+       (list "hi" #\a 0 '#(1 2 3) #t #f '() abs 'hi (list 1 2 3) '(1 . 2)))++      (test (quotient 3 0) 'error)+      (test (remainder 3 0) 'error)+      (test (+ 1 + 2) 'error)+      (test (+ 1 - 2) 'error)++      (test (+ 1 #t) 'error)+      (test (+ 1 #f) 'error)++      ;(test (/ 0) 'error)++      (for-each+       (lambda (arg)+	 (test (char-ready? arg) 'error))+       (list "hi" -1 #\a 1 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #f #t (lambda (a) (+ a 1))))++      (test (if #f) 'error)+      (test (if (< 2 3)) 'error)+      (test (if #f 1 2 3) 'error)+      (test (if 1 2 3 4) 'error)+      (test (if #f 1 else 2) 'error)+      (test (if) 'error)+      (test ('+ '1 '2) 'error)++      (test (for-each (lambda (x) (display "for-each should not have called this"))) 'error)+      (test (for-each (lambda () 1) '()) 'error)+      (test (let ((ctr 0)) (for-each (lambda (x y z) (set! ctr (+ ctr x y z))) '(1) '(3) '()) ctr) 'error)+      (test (let ((ctr 0)) (for-each (lambda (x y z) (set! ctr (+ ctr x y z))) '(0 1) '(2 3) '(4 5 6)) ctr) 'error)+      (test (for-each (lambda (a b) (+ a b)) (list 1)) 'error)+      (test (for-each (lambda (a b) (+ a b)) (list 1) (list)) 'error)+      (test (for-each (lambda (a b) (+ a b)) (list 1) (list 1 2)) 'error)+      (test (for-each (lambda (a b) (+ a b)) (list 1 2) (list 1)) 'error)+      (test (for-each (lambda (a b) (+ a b)) (list 1 2) (list 1 2 3)) 'error)+      (test (for-each (lambda (a b) (+ a b)) (list 1 2) (list 1)) 'error)+      (test (for-each (lambda (a b) (+ a b)) (list 1 2) (list 1 2) (list)) 'error)+      (test (for-each (lambda (a b) (+ a b)) (list 1 2) (list 1 2) (list 1 2)) 'error)+      (test (for-each (lambda (a b) (+ a b)) (list 1 2) (cons 1 2)) 'error)+      (test (for-each (lambda (a b) (+ a b)) (cons 1 2) (list 1 2)) 'error)+      (test (for-each (lambda (a) (+ a 1)) (list 1) (list 2)) 'error)+      (test (for-each (lambda (a) (+ a 1)) #\a) 'error)+      (test (for-each (lambda (a) (+ a 1)) (cons 1 2)) 'error)+      (test (let ((sum 0)) (for-each (lambda (a b . args) (set! sum (+ sum a b (apply + args)))) '(0 1 2)) sum) 'error)+      (test (for-each (lambda (a) a) '(1 2 . 3)) 'error)+      (for-each+       (lambda (arg)+	 (test (for-each arg (list 1)) 'error))+       (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2)))++      (for-each+       (lambda (arg)+	 (test (for-each (lambda (a) a) arg) 'error))+       (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t '(1 . 2)))+++      (test (map (lambda (x) (display "map should not have called this"))) 'error)+      (test (map (lambda () 1) '()) 'error)+      (test (let ((ctr 0)) (map (lambda (x y z) (set! ctr (+ ctr x y z)) ctr) '(1) '(3) '())) 'error)+      (test (let ((ctr 0)) (map (lambda (x y z) (set! ctr (+ ctr x y z)) ctr) '(0 1) '(2 3) '(4 5 6))) 'error)++      (test (map (lambda (a b) (+ a b)) (list 1)) 'error)+      (test (map (lambda (a b) (+ a b)) (list 1) (list)) 'error)+      (test (map (lambda (a b) (+ a b)) (list 1) (list 2)) (list 3))+      (test (map (lambda (a b) (+ a b)) (list 1) (list 1 2)) 'error)+      (test (map (lambda (a b) (+ a b)) (list 1 2) (list 1)) 'error)+      (test (map (lambda (a b) (+ a b)) (list 1 2) (list 1 2 3)) 'error)+      (test (map (lambda (a b) (+ a b)) (list 1 2) (list 1)) 'error)+      (test (map (lambda (a b) (+ a b)) (list 1 2) (list 1 2) (list)) 'error)+      (test (map (lambda (a b) (+ a b)) (list 1 2) (list 1 2) (list 1 2)) 'error)+      (test (map (lambda (a b) (+ a b)) (list 1 2) (cons 1 2)) 'error)++      (test (map (lambda (a) (+ a 1)) (list 1) (list 2)) 'error)+      (test (map (lambda (a) (+ a 1)) #\a) 'error)+      (test (map (lambda (a) (+ a 1)) (cons 1 2)) 'error)+      (test (map (lambda (a b . args) (+ a b (apply + args))) '(0 1 2)) 'error)+      (test (map (lambda (a) a) '(1 2 . 3)) 'error)+      (for-each+       (lambda (arg)+	 (test (map arg (list 1)) 'error))+       (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2)))++      (for-each+       (lambda (arg)+	 (test (map (lambda (a) a) arg) 'error))+       (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t '(1 . 2)))++					;(test (do '() ('() '())) 'error) ; ?? -- isn't this the same as before?+      (test (do '() (#t 1)) 'error)+      (test (do ((i i i)) (i i)) 'error)+      (test (do ((i 0 i (+ i 1))) (i i)) 'error)+					;(test (do ((i)) (#t i)) 'error) ; there's some disagreement about this?+      (test (do ((i 0 (+ i 1))) #t) 'error)+      (test (do 123 (#t 1)) 'error)+      (test (do ((i 1)) (#t . 1) 1) 'error)+      (test (do ((i 1) . 1) (#t 1) 1) 'error)+					;(test (do ((i 0 j) (i 0 j) (j 1 (+ j 1))) ((= j 3) i)) 'error) ; ??+      (test (do ((i 1) ()) (= i 1)) 'error)+++      (test (let ((a 1)) (set! a)) 'error)+      (test (let ((a 1)) (set! a 2 3)) 'error)+      (test (set! "hi" 1) 'error)+      (test (set! 'a 1) 'error)+      (test (set! 1 1) 'error)+      (test (set! (list 1 2) 1) 'error)+      (test (set! (let () 'a) 1) 'error)+      (test (set!) 'error)+      (test (set! #t #f) 'error)++      (test (let ((a (lambda (x) (set! a 3) x))) (list (a 1) a)) 'error)+      (test (let ((a (let ((b 1)) (set! a 3) b))) a) 'error)+      (test (let ((a (lambda () "hi"))) (set! (a) "ho")) 'error)+      (test (let ((a (let ((b 1)) (set! a 3) b))) a) 'error)++      (test (cond) 'error)+					;(test (cond ((= 1 2) 3) (else 4) (4 5)) 'error)+      (test (cond ((+ 1 2) => (lambda (a b) (+ a b)))) 'error)+					;(test (cond (else)) 'error)  ; value of else might be #t -- perhaps (equal? (cond (else)) else)+      (test (cond (#t => 'ok)) 'error)+      (test (cond (else =>)) 'error)+;      (test (cond ((values -1) => => abs)) 'error)+;      (test (cond ((values -1) =>)) 'error)+      (test (cond (cond (#t 1))) 'error)+      (test (cond 1) 'error)+      (test (cond (1 . 2) (else 3)) 'error)+      (test (cond (#f 2) (else . 4)) 'error)+;      (test (cond ((values 1 2) => (lambda (x y) #t))) 'error)+      (test (cond #t) 'error)+      (test (cond 1 2) 'error)+      (test (cond 1 2 3) 'error)+      (test (cond 1 2 3 4) 'error)+      (test (cond (1 => (lambda (x y) #t))) 'error)+++      (test (case 1) 'error)+      (test (case 1 . "hi") 'error)+      (test (case 1 ("hi")) 'error)+      (test (case 1 ("a" "b")) 'error)+      (test (case 1 (else #f) ((1) #t)) 'error)+      (test (case "hi" (("hi" "ho") 123) ("ha" 321)) 'error)+      (test (case) 'error)+      (test (case 1 (#t #f) ((1) #t)) 'error)+      (test (case 1 (#t #f)) 'error)+      (test (case -1 ((-1) => abs)) 'error)+      (test ((lambda () => abs)) 'error)+      (test ((lambda () => => 3)) 'error)+      ;; actually, both Guile and Gauche accept+      ;; ((lambda () + 3)) and (begin + 3)+      ;; but surely => is an undefined variable in this context?++      (test (lambda) 'error)+      (test (lambda (a) ) 'error)+      ;; should this be an error: (lambda (a) (define x 1)) ?+      (test (lambda . 1) 'error)+      (test (lambda 1) 'error)+      (test (lambda (x 1) x) 'error)+      (test (lambda "hi" 1) 'error)+					;(test (lambda (x x) x) 'error)+					;(test ((lambda (x x) x) 1 2) 'error)+      (test (lambda (x "a")) 'error)+      (test ((lambda (x y) (+ x y a)) 1 2) 'error)+					;(test ((lambda ())) 'error)+      (test (lambda (x (y)) x) 'error)+      (test ((lambda (x) x . 5) 2) 'error)+      (test (lambda (1) #f) 'error)+					;(test (lambda (x . y z) x) 'error)  ; this is apparently uncatchable in Guile+      (test ((lambda () 1) 1) 'error)+      (test ((lambda (()) 1) 1) 'error)+      (test ((lambda (x) x) 1 2) 'error)+      (test ((lambda (x) x)) 'error)+      (test ((lambda ("x") x)) 'error)+      (test ((lambda "x" x)) 'error)+      (test ((lambda (x . "hi") x)) 'error)++					;(test (begin . 1) 'error)+					;(test (let () (begin . 1)) 'error)++					;(test (let ((x 0)) (set! x (+ x 1)) (begin (define y 1)) (+ x y)) 'error) ; is this correct?+++      (test (apply + #f) 'error)+      (test (apply #f '(2 3)) 'error)+      (test (apply make-vector '(1 2 3)) 'error)+      (test (apply + 1) 'error)+      (test (apply) 'error)+      (test (apply 1) 'error)+      (test (apply . 1) 'error)+      (test (apply car ''foo) 'error)+      (test (apply + '(1 . 2)) 'error)++      (for-each+       (lambda (arg)+	 (test (apply arg '(1)) 'error))+       (list "hi" -1 #\a 1 'a-symbol 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++      (test (let ((x (list 1 2))) (set-cdr! x x) (apply + x)) 'error)+      (test (apply + '(1 2 . 3)) 'error)+      (test (apply + '(1 2) (list 3 4)) 'error)++      (test (define) 'error)+      (test (define x) 'error)+      (test (define . x) 'error)+      (test (define x 1 2) 'error)+      (test (define (x 1)) 'error)+      (test (define 1 2) 'error)+      (test (define "hi" 2) 'error)+					;(test (define 'hi 1) 'error) ; this redefines quote, which maybe isn't an error+      (test (let () (define . 1) 1) 'error)+      (test (let ((hi (lambda (a 0.0) (b 0.0) (+ a b)))) (hi)) 'error)+++;      (test (call-with-values (lambda (x) (+ x 1)) (lambda (y) y)) 'error)+;      (test (+ (values . 1)) 'error)+;      (for-each+;       (lambda (arg)+;	 (test (call-with-values arg arg) 'error))+;       (list "hi" -1 #\a 1 'a-symbol 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))+++      (test (let 1) 'error)+      (test (let . 1) 'error)+      (test (let* (x)) 'error)+      (test (let (x) 1) 'error)+      (test (let ((x)) 3) 'error)+      (test (let ((x 1) y) x) 'error)+      (test (let* x ()) 'error)+      (test (let* ((1 2)) 3) 'error)+      (test (let () ) 'error)+      (test (let '() 3) 'error)+      (test (let* ((x 1))) 'error)+      (test (let ((x 1)) (letrec ((x 32) (y x)) (+ 1 y))) 'error) ; #<unspecified> seems reasonable if not the 1++      (test (let ((x 1)) (letrec ((y x) (x 32)) (+ 1 y))) 'error)+					;(test (let ((x 1)) (letrec ((y x) (x 32)) 1)) 'error)       ; Guile is perverse... s7 returns 1 here+      (test (let ((x 1)) (letrec ((y (let () (+ x 1))) (x 32)) (+ 1 y))) 'error)+      (test (let ((x 1)) (letrec ((y (let ((xx (+ x 1))) xx)) (x 32)) (+ 1 y))) 'error)+					;(test (let ((x 32)) (letrec ((y (apply list `(* ,x 2))) (x 1)) y)) 'error)+      (test (letrec) 'error)+      (test (let ((x . 1)) x) 'error)+					;(test (let ((x 1) (x 2)) x) 'error)+      (test (let (((x 1)) 2) 3) 'error)+      (test (let ((#f 1)) #f) 'error)+      (test (let (()) #f) 'error)+      (test (let (lambda () ) #f) 'error)+++;      (test (call/cc (lambda () 0)) 'error)+;      (test (call/cc (lambda (a) 0) 123) 'error)+;      (test (call/cc) 'error)+;      (test (call/cc abs) 'error)+;      (for-each+;       (lambda (arg)+;	 (test (call/cc arg) 'error))+;       (list "hi" -1 #\a 1 'a-symbol 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2)))++;      (test (call/cc . 1) 'error)+++      (test (dynamic-wind) 'error)+      (test (dynamic-wind (lambda () #f)) 'error)+      (test (dynamic-wind (lambda () #f) (lambda () #f)) 'error)+      (test (dynamic-wind (lambda (a) #f) (lambda () #f) (lambda () #f)) 'error)+      (test (dynamic-wind (lambda () #f) (lambda (a b) #f) (lambda () #f)) 'error)+      (test (dynamic-wind (lambda () #f) (lambda () #f) (lambda (a) #f)) 'error)+      (test (dynamic-wind (lambda () 1) #f (lambda () 2)) 'error)+      (test (dynamic-wind . 1) 'error)+++      (if with-delay+	  (begin+	    (test (force) 'error)+	    (test (delay) 'error)+	    (test (delay 1 2) 'error)+	    ))++      (let ((d 3.14)+	    (i 32)+	    (r 2/3)+	    (c 1.5+0.3i))+	(let ((check-vals (lambda (name)+			    (if (or (not (= d 3.14))+				    (not (= i 32))+				    (not (= r 2/3))+				    (not (= c 1.5+0.3i)))+				(begin+				  (display name) (display " changed ")+				  (if (not (= i 32))+				      (begin (display "stored integer to: ") (display i))+				      (if (not (= r 2/3))+					  (begin (display "stored ratio to: ") (display r))+					  (if (not (= d 3.14))+					      (begin (display "stored real to: ") (display d))+					      (begin (display "stored complex to: ") (display c)))))+				  (display "?") (newline))))))+	  (for-each+	   (lambda (op)+	     (let ((x (catch #t (lambda () (op i)) (lambda args 'error))))+	       (check-vals op))+	     (let ((x (catch #t (lambda () (op r)) (lambda args 'error))))+	       (check-vals op))+	     (let ((x (catch #t (lambda () (op d)) (lambda args 'error))))+	       (check-vals op))+	     (let ((x (catch #t (lambda () (op c)) (lambda args 'error))))+	       (check-vals op))+	     (let ((x (catch #t (lambda () (op i d)) (lambda args 'error))))+	       (check-vals op))+	     (let ((x (catch #t (lambda () (op r d)) (lambda args 'error))))+	       (check-vals op))+	     (let ((x (catch #t (lambda () (op d d)) (lambda args 'error))))+	       (check-vals op))+	     (let ((x (catch #t (lambda () (op c d)) (lambda args 'error))))+	       (check-vals op)))+	   (list+	    number->string string->number make-rectangular magnitude abs exp make-polar angle+	    ;sin cos tan sinh cosh tanh atan sqrt log asinh acosh atanh acos asin+	    sin cos tan atan sqrt log acos asin+	    number? integer? real? complex? rational? even? odd? zero? positive? negative? real-part imag-part+	    numerator denominator rationalize exact? inexact? exact->inexact inexact->exact floor ceiling truncate round+	    + - * / quotient remainder+	    expt = max min modulo < > <= >= lcm gcd+	    ))))++      ))+++;;; ----------------+;;; Guile's reader can't handle these++(test (char? '1e311) #f)+(for-each+ (lambda (n)+   (let ((nb (catch #t (lambda () (number? n)) (lambda args 'error))))+     (if (not nb) (begin (display "(number? ") (display n) (display ") returned #f?") (newline)))))+ (list '1e311 '1e-311 '0e311 '2.1e40000))+;;; also (string->number "#e+i") throws an error in Guile, also "1e1111."++++;;; ----------------+;;; these might be "reader errors", so put them all here for convenience+;;;    ideally they'd report the bad input, but allow us to continue, signalling+;;;    a catchable error only if the bad stuff is accessed by the evaluator.+;;;    The ones s7 can't handle gracefully are currently commented out with "";#;"++;;; (catch #t (lambda () (car '( . 1))) (lambda arg 'error))++;;; Guile treats dot as a quasiquote subsidiary, I guess:+;;;    guile> (. 1)+;;;    1+;;;    guile> '(. 1)+;;;    1+;;;    guile> ( . 1)+;;;    1+;;;    guile> .+;;;    ERROR: Unbound variable: #{.}#+;;;    ABORT: (unbound-variable)+;;;    guile> (symbol? '.)+;;;    #t+;;;    guile> '(. (cons 1 2))+;;;    2+;;;    guile> '(. (list 1 2 3))+;;;    2+;;;+;;;    gosh> (. 1)+;;;    *** READ-ERROR: Read error at "(stdin)":line 2: bad dot syntax+++;(test (list #b) 'error)++;;; what # stuff is supported seems completely random:+;;;    guile> #++;;;    ERROR: In procedure scm_lreadr:+;;;    ERROR: standard input:1:3: Unknown # object: #\++;;;    ABORT: (read-error)+;;;    guile> #*+;;;    #*+;;;+;;;    gosh> #*+;;;    *** READ-ERROR: Read error at "(stdin)":line 2: unsupported #*-syntax: #*+++;      (test (char? #\spaces) 'error)+;      (test (car '( . 1)) 'error)+;      (test (car '(. )) 'error)+;      (test (car '( . )) 'error)+;      (test (car '(. . . )) 'error)+;      (test '#( . 1) 'error)+;      (test '(1 2 . ) 'error)+;      (test '#(1 2 . ) 'error)+;      (test (+ 1 . . ) 'error)+;      (test (car '(1 . )) 'error)+;      (test (car '(1 . . 2)) 'error)+;      (test '#( . ) 'error)+;      (test '#(1 . ) 'error)+;      (test '#(. . . ) 'error)+;      (test '#(1 . . 2) 'error)+;      (test '(. 1) 'error)+;      (test '#(. 1) 'error)+;      (test '(. ) 'error)+;      (test '#(. ) 'error)+;      (test (list 1 . 2) 'error)+;      (test (+ 1 . 2) 'error)+;      (test (car '@#`') 'error)+;      (test (list . ) 'error)+;      (test '#( .) 'error)+;      (test (car '( .)) 'error)+;      (test '#(1 . 2) 'error)+++;;; ----------------++;;; due primarily to stupidities on my part, the "expected" values are sometimes not more+;;;   accurate than say 1e-7 or so++(if (and (not (null? error-data))+	 with-error-data)+    (begin+      (for-each+       (lambda (op)+	     (begin+	       (display op) (newline)))+       error-data)++      (let ((data '((3.0 0.14159265358979323846 0.1411200080598672)+		    (31.0 0.41592653589793238462 0.404037645323065)+		    (314.0 0.15926535897932384626 0.1585929060285728)+		    (3141.0 0.59265358979323846264 0.5585640372121817)+		    (31415.0 0.92653589793238462643 0.7995441773754675)+		    (314159.0 0.26535897932384626433 0.262255699519879)+		    (3141592.0 0.65358979323846264338 0.6080402764374114)+		    (31415926.0 0.53589793238462643383 0.5106132968486387)+		    (314159265.0 0.35897932384626433832 0.3513188023745885)+		    (3141592653.0 0.58979323846264338327 0.5561892044494355)+		    (31415926535.0 0.89793238462643383279 0.7820399858427447)+		    (314159265358.0 0.97932384626433832795 0.8301205477998297)+		    (3141592653589.0 0.79323846264338327950 0.7126289202333107)+		    (31415926535897.0 0.93238462643383279502 0.8030432710678118)+		    (314159265358979.0 0.32384626433832795028 0.3182152351447919)+		    (3141592653589793.0 0.23846264338327950288 0.2362090532517409)+		    (31415926535897932.0 0.38462643383279502884 0.3752128900123344)+		    (314159265358979323.0 0.84626433832795028841 0.7488096950162713)+		    (3141592653589793238.0 0.46264338327950288419 0.4463151633593201)+		    (31415926535897932384.0 0.62643383279502884197 0.5862594566145847)+		    (314159265358979323846.0 0.26433832795028841971 0.2612706361296674)+		    (3141592653589793238462.0 0.64338327950288419716 0.5999057324027754)+		    (31415926535897932384626.0 0.43383279502884197169 0.4203516113275538)+		    (314159265358979323846264.0 0.33832795028841971693 0.3319102940355321)+		    (3141592653589793238462643.0 0.38327950288419716939 .3739640276557301)))+	    (vals '())+	    (mx-sin-err 0.0))++	(for-each+	 (lambda (p)+	   (let ((arg1 (car p))+		 (arg2 (cadr p))+		 (mxerr 0.0))+	     (do ((i 0 (+ i 1))+		  (x 0.0 (+ x .1)))+		 ((= i 10))+	       (let ((err (abs (- (abs (sin (- arg1 x))) (abs (sin (+ arg2 x)))))))+		 (if (> err mxerr)+		     (set! mxerr err))))+	     (set! vals (cons mxerr vals))+	     (set! mx-sin-err (max mx-sin-err (abs (- (sin arg2) (caddr p)))))))+	 data)++	(if (> mx-sin-err 1e-8)+	    (begin+	      (display "base sine seems inaccurate!  error: ")+	      (display mx-sin-err)+	      (newline)))++	(set! vals (reverse vals))++	(let ((stop #f))+	  (do ((i 0 (+ i 1)))+	      ((or (number? stop)+		   (= i (length vals))))+	    (if (> (list-ref vals i) 1e-6)+		(set! stop i)))+	  (if (number? stop)+	      (begin+		(display "sin error > 1e-6 after 2^")+		(display (/ (log (car (list-ref data stop))) (log 2.0)))+		(display " or thereabouts")+		(newline)))))++      (let ((data (list+		   2.71828182845904523536028747135266249775724709369995957+		   27.1828182845904523536028747135266249775724709369995957+		   271.828182845904523536028747135266249775724709369995957+		   2718.28182845904523536028747135266249775724709369995957+		   27182.8182845904523536028747135266249775724709369995957+		   271828.182845904523536028747135266249775724709369995957+		   2718281.82845904523536028747135266249775724709369995957+		   27182818.2845904523536028747135266249775724709369995957+		   271828182.845904523536028747135266249775724709369995957+		   2718281828.45904523536028747135266249775724709369995957+		   27182818284.5904523536028747135266249775724709369995957+		   271828182845.904523536028747135266249775724709369995957+		   2718281828459.04523536028747135266249775724709369995957+		   27182818284590.4523536028747135266249775724709369995957+		   271828182845904.523536028747135266249775724709369995957+		   2718281828459045.23536028747135266249775724709369995957+		   27182818284590452.3536028747135266249775724709369995957+		   271828182845904523.536028747135266249775724709369995957+		   2718281828459045235.36028747135266249775724709369995957+		   27182818284590452353.6028747135266249775724709369995957+		   271828182845904523536.028747135266249775724709369995957+		   2718281828459045235360.28747135266249775724709369995957+		   27182818284590452353602.8747135266249775724709369995957+		   271828182845904523536028.747135266249775724709369995957+		   2718281828459045235360287.47135266249775724709369995957+		   27182818284590452353602874.7135266249775724709369995957+		   271828182845904523536028747.135266249775724709369995957+		   2718281828459045235360287471.35266249775724709369995957+		   27182818284590452353602874713.5266249775724709369995957)))+	(let ((happy #t))+	  (do ((i 0 (+ i 1))+	       (dec 1.0 (* dec 10.0)))+	      ((or (not happy)+		   (= i (length data))))+	    (let ((val (exp (+ 1.0 (log dec)))))+	      (let ((err (abs (- (list-ref data i) val))))+		(if (> err 1e-6)+		    (begin+		      (set! happy #f)+		      (display "exp+log error > 1e-6 around 2^") (display (/ (log val) (log 2))) (newline))))))))++      (let ((data (list ; table[Tan[10^k], {k, 0, 30}]+		   1.55740772465490223050697480745836017308725077238152003838394660569886+		   0.64836082745908667125912493300980867681687434298372497563362796739585+		   -0.58721391515692907667780963564458789425876598687291954412663968360989+		   1.47032415570271844598020880490391856915748389146711182025455665358979+		   0.32097113462381472460896162480876337966088525010731594977977206336933+		   -0.03577166295289877341133054456893096203777589491986804979647879769616+		   -0.37362445398759902917349708857538141978530379801059302641978134928241+		   -0.46353082785018908581469758918080168755473695345937070670149218665289+		   -2.56377890672837725789840319603083470729708859667680805828679070820622+		   0.65145220214514128858645272422054798185112543058289784681820964602226+		   -0.55834963781124184656189340731863681858164809933060716499623295934358+		   2.50424481449822111118237373761381771825510968075886393173926375110559+		   -0.77230596813187614161063494471423746038444882506077057787558499031077+		   -0.30175082856983471199636858701688775346296430492149675721730025846251+		   0.21415652428250396225222102422385566728114779011753338339645623774420+		   -1.67241478212758304295552142696079055033040910554091189243737002950172+		   -1.24517343571840642168009129451609763781317676741030141327973693611564+		   0.52456243090255001593041672482494038697466467439258592602675334853162+		   -8.38854968059368800013526842602194492647448392917034135131083409265520+		   2.47279376584652736033818679563656602249667799226358809957010483326311+		   -0.84460246301988425418409323400055358116535547279258431245425813826798+		   -0.89552329255426546888442598272446987755918451773757800611680045521648+		   -1.62877822560689887854937593693954851354515116817021717086346127966844+		   -0.98333523138083649717001389546802280189805226009031609173028377317771+		   -11.87362630545544227571094967408372098364257316309876130680769667747893+		   1.11612596981774655887307362253927728556627435787456734029790793087502+		   -1.63758698713112186463163321344320618241852069893975176926240178134592+		   -1.03173363516910726343237554775898936974208941138122693037794681869065+		   6.35083773135836351463817396716338533781524290151157250457191403689220+		   -110.81342510911236031336859049236316125148742351166700266651506403034426+		   0.09048506806330217256622313805004127372738954023205417991033965089185)))+	(let ((happy #t))+	  (do ((i 0 (+ i 1))+	       (dec 1.0 (* dec 10.0)))+	      ((or (not happy)+		   (= i (length data))))+	    (let ((val (tan dec)))+	      (let ((err (abs (- (list-ref data i) val)))+		    (err1 (- (tan (+ 0.1 (* our-pi dec))) (tan 0.1)))+		    (err2 (- (tan (+ 1.0 (* our-pi dec))) (tan 1.0))))+		(if (or (> err 1e-6)+			(> err1 1e-6)+			(> err2 1e-6))+		    (begin+		      (set! happy #f)+		      (display "tan error > 1e-6 around 2^") (display (/ (log dec) (log 2))) (newline))))))))++      ;; table[(1/10^k)/(((1/10^k)^(1/10^k)) - 1), {k, 1, 30}]+      ;;   the test came from calc_errors.txt from the web by "dave"+      (let ((expts (list+		    -0.48621160938616180680870317336747983548142173621715706851490974881717+		    -0.22218561601345857583044966876729715619642038672598556073380084629504+		    -0.14526540294689938889864991134840220307566223888497162784858064408875+		    -0.10862362815109649171007844591526444220973735508130191198062253212652+		    -0.08686389647659141105044978528770239308857034812798554177686261943193+		    -0.07238291365169326382168151357331039782973682143307349669152489742891+		    -0.06204211884333512141082278643490234288550259196615819050849846987015+		    -0.05428681523790663196206398113420109019962541643547760927657854324749+		    -0.04825494293369464924373092184737925979664303236414611590980578553450+		    -0.04342944824032518278430110099994422226122739720915846151097610557365+		    -0.03948131654165925705940460838351885560840418164027583205682137097699+		    -0.03619120682577098563759637916147675090355043511246085981138602579761+		    -0.03340726783876167905008686486133377017608955166698061593202699553920+		    -0.03102103442166584483222349447696386196557178259759899539894506586562+		    -0.02895296546021728851007526126398523685253569082526692705926181546848+		    -0.02714340511895328922819555743231851877797306680518273360154914602559+		    -0.02554673422960305368536052464215356633451937057629542604571806752914+		    -0.02412747121684732425839605105092250802578858425793889081112350331353+		    -0.02285760431069746466321731152192658331511007129540571803806313398860+		    -0.02171472409516259138755644594583025411510361447234900258639235440074+		    -0.02068068961444056322198232947221928963307055360980162368063530687389+		    -0.01974065826832962852964676904166386737701808793240851850210059107980+		    -0.01888236877840225337614103995289587314323465286757518193028428290776+		    -0.01809560341263549281879753828819187842893320857975794377409033233328+		    -0.01737177927613007310604520675666420329177588023219463316734886061171+		    -0.01670363391935583952504342495833096470363065406937228989783888395986+		    -0.01608498081123154917226403453394833638127396317791358170357400676126+		    -0.01551051721083042241611174715416446722479989306441666312924319204483+		    -0.01497567178976730440176306617453810628601368985529884710795141610434+		    -0.01447648273010839425503763063105350274314656686012221887048754923492)))+	(let ((happy #t))+	  (do ((i 1 (+ i 1)))+	      ((or (= i (length expts))+		   (not happy)))+	    (catch #t+		   (lambda ()+		     (let ((val (/ (expt .1 i)+				   (- (expt (expt .1 i) (expt .1 i)) 1))))+		       (if (> (abs (- val (list-ref expts (- i 1)))) 1e-6)+			   (begin+			     (set! happy #f)+			     (display "expt error > 1e-6 around 2^") (display (/ (log (expt .1 i)) (log 2))) (newline)))))+		   (lambda args+		     (display "expt no accurate below around 2^") (display (/ (log (expt .1 i)) (log 2))) (newline))))))++      (let ((sin-err 0.0)+	    (cos-err 0.0)+	    (log-err 0.0)+	    (asin-err 0.0)+	    (atan-err 0.0)+	    (sqrt-err 0.0))+	;; data generated by mathtool in the arprec package++	;; another baddy: (tan 314159265358979323) should be -1.129792652308908544253650171110++	(let ((sins (list+		     0.00000000000000000000000000000000000000000000000000000000000000000000+		     0.09983341664682815230681419841062202698991538801798225999276686156165+		     0.19866933079506121545941262711838975037020672954020540398639599139797+		     0.29552020666133957510532074568502737367783211174261844850153103617326+		     0.38941834230865049166631175679570526459306018344395889511584896585734+		     0.47942553860420300027328793521557138808180336794060067518861661312553+		     0.56464247339503535720094544565865790710988808499415177102426589426735+		     0.64421768723769105367261435139872018306581384457368964474396308809382+		     0.71735609089952276162717461058138536619278523779142282098968252068287+		     0.78332690962748338846138231571354862314014792572030960356048515256195+		     0.84147098480789650665250232163029899962256306079837106567275170999191+		     0.89120736006143533995180257787170353831890931945282652766035329176720+		     0.93203908596722634967013443549482599541507058820873073536659789445024+		     0.96355818541719296470134863003955481534204849131773911795564922309212+		     0.98544972998846018065947457880609751735626167234736563194021894560084+		     0.99749498660405443094172337114148732270665142592211582194997482405934+		     0.99957360304150516434211382554623417197949791475491995534260751586102+		     0.99166481045246861534613339864787565240681957116712372532710249102330+		     0.97384763087819518653237317884335760670293947136523395566725825917196+		     0.94630008768741448848970961163495776211399866559491176443047155279581+		     0.90929742682568169539601986591174484270225497144789026837897301153096+		     0.86320936664887377068075931326902458492047242489508107697183045949721+		     0.80849640381959018430403691041611906515855960597557707903336060873485+		     0.74570521217672017738540621164349953894264877802047425750762828050000+		     0.67546318055115092656577152534128337425336495789352584226890212866520+		     0.59847214410395649405185470218616227170359717157722357330262703263874+		     0.51550137182146423525772693520936824389387858775426312126259173008382+		     0.42737988023382993455605308585788064749647642266670256499017776070511+		     0.33498815015590491954385375271242210603030652888358671068410107309479+		     0.23924932921398232818425691873957537221555293029961877411621026588071+		     0.14112000805986722210074480280811027984693326425226558415188264123242+		     0.04158066243329057919469827159667310055461342296380675064800900076588+		     -0.05837414342757990913721741461909518512512509908292656970935025422273)))+	  (let ((mxerr 0.0))+	    (do ((i 0 (+ i 1))+		 (x 0.0 (+ x 0.1)))+		((= i 32))+	      (let ((err (abs (- (sin x) (list-ref sins i)))))+		(if (> err mxerr)+		    (set! mxerr err))))+	    (set! sin-err mxerr)))++	(let ((coss (list+		     1.00000000000000000000000000000000000000000000000000000000000000000000+		     0.99500416527802576609556198780387029483857622541508403595935274468526+		     0.98006657784124163112419651674816887739352436080656799405254829012618+		     0.95533648912560601964231022756804989824421408263203767451761361222758+		     0.92106099400288508279852673205180161402585956931985044561508926713514+		     0.87758256189037271611628158260382965199164519710974405299761086831595+		     0.82533561490967829724095249895537603887809103918847038136974977367156+		     0.76484218728448842625585999019186490926821055037370335607293245825206+		     0.69670670934716542092074998164232492610178601370806078363714489414924+		     0.62160996827066445648471615140713350872176136659123900757638348453897+		     0.54030230586813971740093660744297660373231042061792222767009725538110+		     0.45359612142557738777137005178471612212146729566259504745593805541880+		     0.36235775447667357763837335562307602033994778557664862648774972093613+		     0.26749882862458740699798410929287135927592992167912966191725336742182+		     0.16996714290024093861674803520364980292818392102853430898236521149464+		     0.07073720166770291008818985143426870908509102756334686942264541719092+		     -0.02919952230128872620577046294649852444486472109384694500313007908245+		     -0.12884449429552468408764285733487351410164007964520297633178213994289+		     -0.22720209469308705531667430653058073247695158653826107158496911100681+		     -0.32328956686350342227883369508031017459419076544223959990115436505106+		     -0.41614683654714238699756822950076218976600077107554489075514997378196+		     -0.50484610459985745162093852371916747040702337674136205964819622353659+		     -0.58850111725534570852414261265492841629376036669872798974753517400616+		     -0.66627602127982419331788057116601723016327537100376988865266957182167+		     -0.73739371554124549960882222733478290843301289199228479878436568873073+		     -0.80114361554693371483350279046735166442856784876782013507459799166202+		     -0.85688875336894723379770215164520111235392263823324404910501242714241+		     -0.90407214201706114798252728194333012633184973516362471104126694868604+		     -0.94222234066865815258678811736615401246341423446824662018098201995710+		     -0.97095816514959052178110666934553217911761475942423954213867099245327+		     -0.98999249660044545727157279473126130239367909661558832881408593292832+		     -0.99913515027327946449237605454146626283664166994794274354471598254947+		     -0.99829477579475308466166072228358269144701258595166016759508002045139)))+	  (let ((mxerr 0.0))+	    (do ((i 0 (+ i 1))+		 (x 0.0 (+ x 0.1)))+		((= i 32))+	      (let ((err (abs (- (cos x) (list-ref coss i)))))+		(if (> err mxerr)+		    (set! mxerr err))))+	    (set! cos-err mxerr)))++	(let ((logs-1 (list+		       -4.60517018598809136803598290936872841520220297725754595206665580193514+		       -3.91202300542814605861875078791055184712670284289729069794597579244175+		       -3.50655789731998167664073767244620271055471241943479650033196146829765+		       -3.21887582486820074920151866645237527905120270853703544382529578294835+		       -2.99573227355399099343522357614254077567660162298902823015400791046096+		       -2.81341071676003636722350555098802614247921228507454124621128145880425+		       -2.65926003693277806293063016592554868556511824767568476360726565199756+		       -2.52572864430825543978428654499419871097570257417678018970461577345496+		       -2.40794560865187198524549243552367700590722186161204704859726713466015+		       -2.30258509299404568401799145468436420760110148862877297603332790096757+		       -2.20727491318972082397403933140359911538049612332012877684808809280457+		       -2.12026353620009105780627342952984957440371215071428599209060144931086+		       -2.04022082852655463198249546780340981039693503249733883564761029127168+		       -1.96611285637283275351339804446737211748961811331542950948658564250417+		       -1.89711998488588130203997833922001507102911106516627877841931357682347+		       -1.83258146374831013036705442353602214290020243981652493558393576396157+		       -1.77195684193187528778644829149560187961399996467180116476941806405285+		       -1.71479842809192667582826031406550043783172172725179179447658712516676+		       -1.66073120682165090802695547748087487796482371595841713352869556552585+		       -1.60943791243410037460075933322618763952560135426851772191264789147417))+	      (logs-2 (list+		       2.30258509299404568401799145468436420760110148862877297603332790096757+		       2.99573227355399099343522357614254077567660162298902823015400791046096+		       3.40119738166215537541323669160688991224859204645152242776802223460506+		       3.68887945411393630285245569760071734375210175734928348427468791995435+		       3.91202300542814605861875078791055184712670284289729069794597579244175+		       4.09434456222210068483046881306506648032409218081177768188870224409846+		       4.24849524204935898912334419812754393723818621821063416449271805090515+		       4.38202663467388161226968781905889391182760189170953873839536792944775+		       4.49980967033026506680848192852941561689608260427427187950271656824256+		       4.60517018598809136803598290936872841520220297725754595206665580193514+		       4.70048036579241622807993503264949350742280834256619015125189561009814+		       4.78749174278204599424770093452324304839959231517203293600938225359185+		       4.86753445045558242007147889624968281240636943338898009245237341163103+		       4.94164242260930429854057631958572050531368635257088941861339806039854+		       5.01063529409625575001399602483307755177419340072004014968067012607924+		       5.07517381523382692168691994051707047990310202606979399251604793894114+		       5.13579843705026176426752607255749074318930450121451776333056563884986+		       5.19295685089021037622571404998759218497158273863452713362339657773595+		       5.24702407216048614402701888657221774483848074992790179457128813737686+		       5.29831736654803667745321503082690498327770311161780120618733581142853)))+	  (let ((mxerr 0.0))+	    (do ((i 0 (+ i 1))+		 (x 0.01 (+ x 0.01))+		 (y 10.0 (+ y 10.0)))+		((= i 20))+	      (let ((err (max (abs (- (log x) (list-ref logs-1 i)))+			      (abs (- (log y) (list-ref logs-2 i))))))+		(if (> err mxerr)+		    (set! mxerr err))))+	    (set! log-err mxerr)))++	(let ((asins (list+		      0.00000000000000000000000000000000000000000000000000000000000000000000+		      0.02500260489936113599406838915349107150195748368840710160729904233944+		      0.05002085680577001466274438682046411497780608049468789272874398055703+		      0.07507049107671654265775143572317089898194705496817785120910161299955+		      0.10016742116155979634552317945269331856867597222962954139102385503640+		      0.12532783116806539687456698635708471804814772683867237523396403098649+		      0.15056827277668602642326030146739539047425784470580485344319902595849+		      0.17590576816371628737774199743846051972730948209298253171964068749984+		      0.20135792079033079145512555221762341024003808140222838625725124345560+		      0.22694303617851994909359260763689579636930963064761339672521677581090+		      0.25268025514207865348565743699371097225219373309683819363392377874057+		      0.27858970239165058217050815183568882129133935843106227203280647300877+		      0.30469265401539750797200296122752916695456003170677638739297794874647+		      0.33101172808929452771961639961139035858195303667932389628972377319123+		      0.35757110364551028671483849232064256784674132498948776325141270863037+		      0.38439677449563908303819487296704697375277948430656504155058375479079+		      0.41151684606748801938473789761733560485570113512702585178394678070009+		      0.43896188560976067483321619602147236009843505358239561712817387552271+		      0.46676533904729636185033976030413712126156503909241369925276357159851+		      0.49496403171689461363027991615293072605447706550005723007748628111125+		      0.52359877559829887307710723054658381403286156656251763682915743205130+		      0.55271511309678317285035596261806027710654731438452549350875265730232+		      0.58236423786874344183204729090997636797897358751436418853659347126034+		      0.61260414804862246566851988030718610964520075565860642564808142300476+		      0.64350110879328438680280922871732263804151059111531238286560611871351+		      0.67513153293703164720905626529438801420418535124967921737841984904557+		      0.70758443672535557545286474430459468476197717933193633785448106190261+		      0.74096470220302000164595109317351452207440076171206748884906746063949+		      0.77539749661075306374035335271498711355578873864116199359771996373272+		      0.81103439428758154765966499519016990220446846078107874166646027112837+		      0.84806207898148100805294433899841808007336621326311264286071816357020+		      0.88671509499956738294114522105877020358977872696702934222169938478807+		      0.92729521800161223242851246292242880405707410857224052762186617744039+		      0.97020219992884564627294507144637975649395034794671876838355202607208+		      1.01598529381482513116231792163105149400316379682053508778250056579494+		      1.06543581651073931226000681765232949759419723349387652321962473867275+		      1.11976951499863418668667705584539961589516218640330288237568186391443+		      1.18103559399742179696187441797151603545275866323114802494551011137296+		      1.25323589750337525873710391866600599574114067342736145636046515573871+		      1.34672104149307735953151290762049740983950868154764854526693662237423+		      1.57079632679489661923132169163975144209858469968755291048747229615390)))+	  (let ((mxerr 0.0))+	    (do ((i 0 (+ i 1))+		 (x 0.0 (+ x (/ 1.0 40.0))))+		((= i 40))+	      (let ((err (abs (- (asin x) (list-ref asins i)))))+		(if (> err mxerr)+		    (set! mxerr err))))+	    (set! asin-err mxerr)))++	(let ((atans (list+		      0.00000000000000000000000000000000000000000000000000000000000000000000+		      0.04995839572194276141000628703484488149127708042350717441085345482998+		      0.09966865249116202737844611987802059024327832250431464801550877681002+		      0.14888994760949725058653039165586728099052584656913639751654183508627+		      0.19739555984988075837004976519479029344758510378785210151768894024103+		      0.24497866312686415417208248121127581091414409838118406712737591466735+		      0.29145679447786709199560462143289119350316759901206541927220608308729+		      0.33667481938672718139669863134176645842796861176681965716976593102220+		      0.38050637711236488630358791681043310449740571365810083757630562232420+		      0.42285392613294071296648279098114197360332058559089653470801277782477+		      0.46364760900080611621425623146121440202853705428612026381093308872019+		      0.50284321092786082733088202924527755577645581499776483101147435179592+		      0.54041950027058415544357836460859991013514825146259238811636023340959+		      0.57637522059118368022757047839377004593402018294846332167674413471879+		      0.61072596438920861654375887649023609381850306612882761584286773000023+		      0.64350110879328438680280922871732263804151059111531238286560611871351+		      0.67474094222355266305652097360981361507400625484071242312092170496930+		      0.70449406424221771665748034078199625698360683805607748632242138272858+		      0.73281510178650659164079207273428025198575567935825608631050693192821+		      0.75976275487577082892296119539998182400552294838843900175686400378812+		      0.78539816339744830961566084581987572104929234984377645524373614807695+		      0.80978357257016684662414585801888523310377327237135123533486105150550+		      0.83298126667443170541769356183636123851585134443710842085342312250327+		      0.85505273712601651097815432807058769283799489703232752323972864020297+		      0.87605805059819342311404752112834133907534524616033200346065614838499+		      0.89605538457134395617480071802993782702457844484684048736655059118459+		      0.91510070055336041656680197245527296654755880944161873770852665151657+		      0.93324752865620386989366255071265925262560793377140310475404520234906+		      0.95054684081207514789478913546381917504767901030880427426177057808809+		      0.96704699339746024466331914650201513140746494542545306371969751473184+		      0.98279372324732906798571061101466601449687745363162855676142508831798+		      0.99783018390619045494496187944270463542510496590550026609871776901127+		      1.01219701145133418325981347523809017175213711715353810435383625801215+		      1.02593241134335292660599590143869494280346122674543977431139573494988+		      1.03907225953609102762125033790727884531233378855364699989530509706554+		      1.05165021254837366745986731208629982963024430034204461753698029655611+		      1.06369782240255966094389111605254547856256296541932752568273985366635+		      1.07524465330906808242086208732184320752064516718532174460312177009311+		      1.08631839775787341806397958192567762897580047046812780208748680606431+		      1.09694499030013626798639002132512259906130967805041989207206852796014+		      1.10714871779409050301706546017853704007004764540143264667653920743371)))+	  (let ((mxerr 0.0))+	    (do ((i 0 (+ i 1))+		 (x 0.0 (+ x 0.05)))+		((= i 40))+	      (let ((err (abs (- (atan x) (list-ref atans i)))))+		(if (> err mxerr)+		    (set! mxerr err))))+	    (set! atan-err mxerr)))++	(let ((sqrts (list+		      1.00000000000000000000000000000000000000000000000000000000000000000000+		      1.41421356237309504880168872420969807856967187537694807317667973799073+		      1.73205080756887729352744634150587236694280525381038062805580697945193+		      2.00000000000000000000000000000000000000000000000000000000000000000000+		      2.23606797749978969640917366873127623544061835961152572427089724541052+		      2.44948974278317809819728407470589139196594748065667012843269256725096+		      2.64575131106459059050161575363926042571025918308245018036833445920106+		      2.82842712474619009760337744841939615713934375075389614635335947598146+		      3.00000000000000000000000000000000000000000000000000000000000000000000+		      3.16227766016837933199889354443271853371955513932521682685750485279259+		      3.31662479035539984911493273667068668392708854558935359705868214611648+		      3.46410161513775458705489268301174473388561050762076125611161395890386+		      3.60555127546398929311922126747049594625129657384524621271045305622716+		      3.74165738677394138558374873231654930175601980777872694630374546732003+		      3.87298334620741688517926539978239961083292170529159082658757376611348+		      4.00000000000000000000000000000000000000000000000000000000000000000000+		      4.12310562561766054982140985597407702514719922537362043439863357309495+		      4.24264068711928514640506617262909423570901562613084421953003921397219+		      4.35889894354067355223698198385961565913700392523244493689034413815955+		      4.47213595499957939281834733746255247088123671922305144854179449082104+		      4.58257569495584000658804719372800848898445657676797190260724212390686+		      4.69041575982342955456563011354446628058822835341173715360570189101702+		      4.79583152331271954159743806416269391999670704190412934648530911444825+		      4.89897948556635619639456814941178278393189496131334025686538513450192+		      5.00000000000000000000000000000000000000000000000000000000000000000000+		      5.09901951359278483002822410902278198956377094609959640758497080442593+		      5.19615242270663188058233902451761710082841576143114188416742093835579+		      5.29150262212918118100323150727852085142051836616490036073666891840213+		      5.38516480713450403125071049154032955629512016164478883768038867001664+		      5.47722557505166113456969782800802133952744694997983254226894449732493+		      5.56776436283002192211947129891854952047639337757041430396843258560358+		      5.65685424949238019520675489683879231427868750150779229270671895196292+		      5.74456264653802865985061146821892931822026445798279236769987747056590+		      5.83095189484530047087415287754558307652139833488597195445000674486781+		      5.91607978309961604256732829156161704841550123079434032287971966914282+		      6.00000000000000000000000000000000000000000000000000000000000000000000+		      6.08276253029821968899968424520206706208497009478641118641915304648633+		      6.16441400296897645025019238145424422523562402344457454487457207245839+		      6.24499799839839820584689312093979446107295997799165630845297193060961+		      6.32455532033675866399778708886543706743911027865043365371500970558518)))+	  (let ((mxerr 0.0))+	    (do ((i 1 (+ i 1)))+		((> i 40))+	      (let ((err (abs (- (sqrt i) (list-ref sqrts (- i 1))))))+		(if (> err mxerr)+		    (set! mxerr err))))+	    (set! sqrt-err mxerr)))++	(if (> sin-err 1e-12) (begin (display "sin err: ") (display sin-err) (newline)))+	(if (> cos-err 1e-12) (begin (display "cos err: ") (display cos-err) (newline)))+	(if (> log-err 1e-12) (begin (display "log err: ") (display log-err) (newline)))+	(if (> asin-err 1e-12) (begin (display "asin err: ") (display asin-err) (newline)))+	(if (> atan-err 1e-12) (begin (display "atan err: ") (display atan-err) (newline)))+	(if (> sqrt-err 1e-12) (begin (display "sqrt err: ") (display sqrt-err) (newline)))+	)++      ))++;'(+;;;; this is the current s7 output from loading this file:+;+;  " "+;  (let ((funcs (make-vector 3 #f))) (do ((i 0 (+ i 1))) ((= i 3)) (vector-set! funcs i (lambda () (+ i 1)))) (+ ((vector-ref funcs 0)) ((vector-ref funcs 1)) ((vector-ref funcs 2)))) got 12 but expected 6+;+;(let* ((x (quote (1 2 3))) (y (apply list x))) (not (eq? x y))) got #f but expected #t+;+;(let () (define q (let ((count 5)) (define (get-count) count) (define p (make-promise (if (<= count 0) count (begin (set! count (- count 1)) (force p) (set! count (+ count 2)) count)))) (list get-count p))) (let* ((get-count (car q)) (p (cadr q)) (a (get-count)) (b (force p)) (c (get-count))) (list a b c))) got (5 10 10) but expected (5 0 10)+;+;format #t 1 output-port: 2! (this is testing output ports)+;+;op              error                      test                            result                                 expected+;bes-i0:         4.728274528735e-07      (bes-i0 100.0)                1.0737511994318e+42                     1.0737517071311e+42+;*:              1.4453905801655e-16     (* 1234/11 1234/11 1+1i)      12584.760330579+12584.760330579i        12584.760330579+12584.760330579i+;+:              1.2356560980092e-17     (+ 1.234+1.234i -1+1i)        0.234+2.234i                            0.234+2.234i+;-:              7.065416064077e-15      (- 1234/11 1234/11 -1+1i)     1-1i                                    1-1i+;/:              6.7706212385519e-12     (/ 1+1i 123.4 123.4)          6.5670402874788e-05+6.5670402874788e-05i 6.567040287e-05+6.567040287e-05i+;magnitude:      4.3762690498963e-15     (magnitude 1e-08+1e-08i)      1.4142135623731e-08                     1.414214e-08+;angle:          5.2180482157382e-15     (angle 3.1415926535898+1i)    0.30816907111599                        0.30816907111598+;make-polar:     5.1075947370453e-12     (make-polar 1e-08 1234.0)     -7.9855062358758e-09+6.019276547625e-09i -7.98551e-09+6.01928e-09i+;remainder:      1.1102230246252e-16     (remainder -3.1 2.5)          -0.6                                    -0.6+;modulo:         1.1102230246252e-16     (modulo -3.1 2.0)             0.9                                     0.9+;expt:           5.3037918931232e-12     (expt -1234-2.718281828459i -1-1e-08i) -0.00081036881365486+1.7851555921329e-06i -0.00081036881365+1.78515559e-06i+;log:            1.9801079834368e-14     (log 8.0 1+1i)                0.97790391649038-2.2161063668189i       0.97790391649038-2.2161063668189i+;exp:            6.2082941131998e-11     (exp 2.718281828459+1234000000i) 2.4081506430049-14.961700256459i     2.4081506420759-14.961700256608i+;sqrt:           4.9628289840723e-12     (sqrt 1e-08+1e-08i)           0.00010986841134678+4.5508986056223e-05i 0.00010986841135+4.550898606e-05i+;atanh:          3.3019134302818e-14     (atanh 1e-08+1e-08i)          9.9999999669809e-09+1e-08i              1e-08+1e-08i+;acosh:          3.0063814632876e-11     (acosh 0-1234i)               7.8111635492012-1.5707963267949i        7.8111635489617-1.5707963267949i+;asinh:          1.8798350372034e-07     (asinh -181440)               -12.801827480089                        -12.801829886622+;tanh:           3.9570983863574e-10     (tanh 1e-08+1234000000i)      3.9600648213873e-07-6.2129419934418i    3.9600648244422e-07-6.2129419959003i+;cosh:           3.8571780349279e-10     (cosh 1e-08+1234000000i)      0.15890913095152-9.8729321283003e-09i   0.15890913089022-9.8729321283989e-09i+;sinh:           6.1863103554352e-11     (sinh 3.1415926535898+1234000000i) 1.8352001348474-11.444656792365i   1.8352001341396-11.44465679248i+;atan:           1.6781042865365e-14     (atan 0+1e-08i)               0+1.0000000016781e-08i                  0+1e-08i+;acos:           1.8259451651704e-08     (acos 181440)                 -0+12.801827480074i                     0+12.80182724632i+;asin:           6.2060307610322e-09     (asin 1e-08+1234000000i)      8.1037277147488e-18+21.62667394299i     8.1037250521496e-18+21.626673808774i+;tan:            4.2096697956986e-07     (tan 1234000000/3)            -18.780955178921                        -18.780947272762+;cos:            2.2319583216357e-08     (cos 1234000000/3)            -0.053170110875237                      -0.05317013319482+;sin:            1.1884160322495e-09     (sin 1234000000/3)            0.99858546920607                        0.99858546801766+;string->number: 3.514766724748e-14      (string->number "1234567890123456789012345678901234567890.123456789e-30") 1234567890.1235 1234567890.1235+;sin error > 1e-6 after 2^38.192705173229 or thereabouts+;exp+log error > 1e-6 around 2^31.340047894875+;tan error > 1e-6 around 2^46.506993328423+;expt error > 1e-6 around 2^-46.506993328423+;)+++(newline) (display ";all done!") (newline)