fun theFunction x i = 
    let fun g x accum =
            case x
                of x::xs => h xs (accum + x)
                 | nil => accum
        and h x accum =
             case x
                of y::nil => g x accum
                 | x::xs => h xs (accum + x)
                 | nil => accum
    in  g x 0 end

val _ = print("Result = " ^ Int.toString (theFunction (List.tabulate(100, fn _ => 1)) 1000 ) ^ "\n")

(* adapted from the Larceny benchmark

;;; DERIV -- Symbolic derivation.

;;; Returns the wrong answer for quotients.
;;; Fortunately these aren't used in the benchmark.
*)


datatype expr
  = Add of expr list
  | Sub of expr list
  | Mul of expr list
  | Div of expr list
  | Num of int
  | X

structure Benchmark = struct

val hd = List.hd
val tl = List.tl
val map = List.map
val app = List.app
val foldl = List.foldl

fun prnt p = (case p
  of X => print "x"
   | Num a => print (Int.toString a)
   | Add xs => prntLst "+" xs
   | Sub xs => prntLst "-" xs
   | Mul xs => prntLst "*" xs
   | Div xs => prntLst "/" xs
  (* end case *))
and prntLst symb xs = (print "("; print symb;
                       app prnt xs; print ")\n")

fun equal p = (case p
  of (X, X) => true
   | (Num a, Num b) => a = b
   | (Add xs, Add ys) => chkLists (xs, ys)
   | (Sub xs, Sub ys) => chkLists (xs, ys)
   | (Mul xs, Mul ys) => chkLists (xs, ys)
   | (Div xs, Div ys) => chkLists (xs, ys)
   | _ => false
  (* end case *))
and chkLists p = ListPair.foldlEq chk true p
and chk (a, b, acc) = acc andalso equal (a, b)

fun deriv a = (case a
  of X => Num 1
   | Num _ => Num 0
   | Add es => Add (map deriv es)
   | Sub es  => Sub (map deriv es)
   | Mul es  => Mul [
            a,
            Add (map (fn x => Div [deriv x, x]) es)
            ]

   | Div (x :: y :: nil) => Sub [
        Div [deriv x, y],
        Div [x, Mul [y, y, deriv y]]
      ]
   | _ => raise Fail "No derivation method available"
  (* end case *))


fun go (ans, exp) = let
  val computed = deriv exp
  in
    if equal (ans, computed)
    then ()
    else (prnt computed ; raise Fail "wrong answer!")
  end

end


structure Main =
  struct

  	val iterations = 2000000

    fun main _ = let

      fun mkExp a b =
        Add [
          Mul [Num 3, X, X],
          Mul [a, X, X],
          Mul [b, X],
          Num 5
        ]

      fun mkAns a b =
        Add [
          Mul [
            Mul [Num 3, X, X],
            Add [
              Div [Num 0, Num 3],
              Div [Num 1, X],
              Div [Num 1, X]
            ]
          ],
          Mul [
            Mul [a, X, X],
            Add [
              Div [Num 0, a],
              Div [Num 1, X],
              Div [Num 1, X]
            ]
          ],
          Mul [
            Mul [b, X],
            Add [
              Div [Num 0, b],
              Div [Num 1, X]
            ]
          ],
          Num 0
        ]

      val a = Num 5
      val b = Num 7
      val exp = mkExp a b
      val ans = mkAns a b

      fun doit () = Benchmark.go (ans, exp)

      fun lp 0 = ()
      	| lp n = (doit(); lp (n-1))

      fun start () = lp iterations

  	in
      	start ()
  	end

end

val _ = Main.main (CommandLine.name (), CommandLine.arguments ())

datatype fib_result
  = Zero
  | One
  | Val of int

fun add a b = (case (a, b)
  of (Zero, b) => b
   | (a, Zero) => a
   | (One, One) => Val 2
   | (One, Val b) => Val (b+1)
   | (Val a, One) => Val (a+1)
   | (Val a, Val b) => Val (a+b)
  (* end case *))

fun show a = (case a
  of Zero => "0"
   | One => "1"
   | Val a => Int.toString a
  (* end case *))

fun fib n = (case n
  of 0 => Zero
   | 1 => One
   | _ => let
        val left = fib (n-1)
        val right = fib (n-2)
      in
        add left right
      end
  (* end case *))

val i2s = Int.toString

val n = 30  (* https://oeis.org/A000045/list *)
val ans = fib n

val _ = print ("fib(" ^ i2s n ^ ") = " ^ show ans ^ "\n")

(* from the Larceny benchmark suite

;;; MAZEFUN -- Constructs a maze in a purely functional way,
;;; written by Marc Feeley.
;;; ported to SML by Kavon Farvardin

*)

datatype maze_elm
  = Pt of int * int
  | Empty

structure Benchmark = struct

  val hd = List.hd
  val tl = List.tl
  val concat = List.concat
  val length = List.length
  val null = List.null
  val foldr = List.foldr

  fun tup1 (x, _) = x
  fun tup2 (_, x) = x

  (* operations on maze elms *)
  fun fst e = (case e
    of Pt (x, _) => x
     | _ => raise Fail "not a point"
     (* end case *))

  fun snd e = (case e
    of Pt (_, x) => x
     | _ => raise Fail "not a point"
     (* end case *))

  fun mazeElmEqual p = (case p
    of (Pt (x, y), Pt (a, b)) => x = a andalso y = b
     | (Empty, Empty) => true
     | _ => false
     (* end case *))

  fun mazeElmToString p = (case p
    of Pt _ => " _"
     | Empty => " *"
    (* end case *))

  fun printStringMat mat =
    app (fn lst => (app print lst; print "\n")) mat
(***********)

  (* the args to f are flipped,
     i.e. acc is on the left in Scheme *)
  fun foldl f id xs = let
    fun lp (xs, acc) = (case xs
      of nil => acc
       | x :: xs => lp(xs, f (acc, x))
      (* end case *))
    in
      lp (xs, id)
    end

  fun for lo hi f = let
      fun lp lo =
        if lo < hi
          then f lo :: lp (lo + 1)
          else nil
    in
      lp lo
    end

  fun listRead lst i =
    if i = 0
      then hd lst
      else listRead (tl lst) (i-1)

  fun listWrite lst i new =
    if i = 0
      then new :: tl lst
      else hd lst :: listWrite (tl lst) (i-1) new

  fun listRemovePos lst i =
    if i = 0
      then tl lst
      else hd lst :: listRemovePos (tl lst) (i-1)

  fun member x = List.exists (fn y => mazeElmEqual (x, y))

  fun hasDuplicates lst = (case lst
    of nil => false
     | x :: xs => member x xs orelse hasDuplicates xs
    (* end case *))

  fun makeMatrix n m init =
    for 0 n (fn i =>
      for 0 m (fn j =>
        init i j
      )
    )

  fun matrixRead mat i j = listRead (listRead mat i) j

  fun matrixWrite mat i j new =
    listWrite mat i (listWrite (listRead mat i) j new)

  fun matrixSize mat = (length mat, length (hd mat))

  fun matrixMap f mat = map (fn lst => map f lst) mat

  fun nextRandom cur =
    ((cur * 3581) + 12751) mod 131072

  fun shuffle lst = let
    fun shuf lst rand =
      if null lst
        then nil
        else let
          val newRand = nextRandom rand
          val i = newRand mod (length lst)
        in
          listRead lst i
            :: shuf (listRemovePos lst i) newRand
        end
  in
    shuf lst 0 (* <- the seed *)
  end

  fun odd n = n mod 2 = 1
  fun even n = n mod 2 = 0

  fun caveToMaze cave = matrixMap mazeElmToString cave

  fun pierce pos cave = matrixWrite cave (fst pos) (snd pos) pos

  fun neighboringCavities pos cave = let
      val size = matrixSize cave
      val n = tup1 size
      val m = tup2 size
      val i = fst pos
      val j = snd pos

      fun notEmpty (i, j) = (case matrixRead cave i j
        of Empty => false
         | _ => true
         (* end case *))
    in
      concat [
        if i > 0 andalso notEmpty (i-1, j)
          then [Pt (i-1, j)]
          else nil,
        if i < n-1 andalso notEmpty (i+1, j)
          then [Pt (i+1, j)]
          else nil,
        if j > 0 andalso notEmpty (i, j-1)
          then [Pt (i, j-1)]
          else nil,
        if j < m-1 andalso notEmpty (i, j+1)
          then [Pt (i, j+1)]
          else nil
      ]
    end

  and changeCavity cave pos newID = let
      fun change cave pos newID oldID = let
        val i = fst pos
        val j = snd pos
        val cavityID = matrixRead cave i j
      in
        if mazeElmEqual (cavityID, oldID)
          then foldl (fn (c, nc) =>
                        change c nc newID oldID)
                     (matrixWrite cave i j newID)
                     (neighboringCavities pos cave)
          else cave
      end
    in
      change cave pos newID (matrixRead cave (fst pos) (snd pos))
    end

  and tryToPierce pos cave = let
    val ncs = neighboringCavities pos cave
  in
    if hasDuplicates
        (map (fn nc => matrixRead cave (fst nc) (snd nc)) ncs)
      then cave
      else pierce
              pos
              (foldl (fn (c, nc) => changeCavity c nc pos)
                     cave
                     ncs)
  end

  and pierceRandomly possibleHoles cave = (case possibleHoles
    of nil => cave
     | hole :: rest => pierceRandomly rest (tryToPierce hole cave)
    (* end case *))

  fun makeMaze n m = if not (odd n andalso odd m)
    then raise Fail "n and m must be odd"
    else let
      fun init i j = if even i andalso even j
                      then Pt (i, j)
                      else Empty

      val cave = makeMatrix n m init

      val possibleHoles = concat (
            for 0 n (fn i => concat (
              for 0 m (fn j =>
                if even i andalso even j
                  then nil
                  else [Pt (i, j)]
              ))
            ))

    in
      caveToMaze (pierceRandomly (shuffle possibleHoles) cave)
    end


  fun go (n, m) =
    printStringMat (makeMaze n m)

end


structure Main =
  struct

    val iterations = 1

    val n = 11
    val m = 11

    fun main _ = let

      fun doit () = Benchmark.go (n, m)

      fun lp 0 = ()
      	| lp n = (doit(); lp (n-1))

      fun start () = lp iterations

  	in
      	start ()
  	end

end

val _ = Main.main (CommandLine.name (), CommandLine.arguments ())

fun contFib_uncurried<C6EA>#4.4 (unboxP<C6F5>#9:int,param<C6F6>#4.4:cont(any) / retK<C6F7>#0:cont(int),_exh<C6F8>#4:cont(any)) =
(* ... *)
  cont currentContinuation<C717>#1 (ccArg<C718>#1:any) =
      let c<C712>#1:[int] = ([int])ccArg<C718>#1
      let _t<C713>#1:int = #0(c<C70B>#1)
      let _t<C714>#1:int = #0(c<C712>#1)
      let _t<C715>#1:int = I32Add(_t<C713>#1,_t<C714>#1)
      let res<C716>#1:[int] = alloc (_t<C715>#1)
      throw param<C6F6>#4.4 res<C716>#1
  (**** End currentContinuation<C717>#1 ****)
  apply contFib_uncurried<C6EA>#4.4 (_t<C70D>#1,currentContinuation<C717>#1 / letJoinK<C85D>#1,_exh<C6F8>#4)

fun manipK2<C93C>#1 (currentContinuation<C939>#1:cont(any) / landingPadK<C93A>#1.1:cont(int,any),deadExnK<C93B>#0:cont(any)) =
    cont invokeRetk<C93D>#0 (param<C93E>#1:any) =
        let t<C93F>#1:int = 1:int
        throw landingPadK<C93A>#1.1 (t<C93F>#1,param<C93E>#1)
    (* ... *)
    
cont setjmpLandingPad<C933>#1 (regularRet<C934>#1:int,arg<C935>#2:any) =
    let t<C938>#1:int = 0:int
    if I32NEq(regularRet<C934>#1,t<C938>#1) then
      let arg<C936>#1:int = (int)arg<C935>#2  (* invalid cast! *)
      throw retK<C6F7>#2.2 arg<C936>#1        (* this return never will happen *)
    else
      let arg<C937>#1:any = (any)arg<C935>#2
      throw currentContinuation<C717>#1.1 arg<C937>#1

callec (manipK2<C93C>#1 / setjmpLandingPad<C933>#1,deadExh<C941>#1)

callec (manipK2<C93C>#1 / currentContinuation<C717>#1,deadExh<C941>#1)

fun f n = if n <= 0 then 0 else 1 + f (n - 1)
val xs = [ 1, 2, 3 ]
val _ = map f xs

(* f same as before *)
val xs = PArray.fromRope (Rope.tabulateSequential (fn x => x) (1, 3))
val _ = PArray.map (fn x => f x) xs

val _ = PArray.map f xs

fun f n = if n <= 0 then 0 else 1
val xs = PArray.fromRope (Rope.tabulateSequential (fn x => x) (1, 3))
val _ = PArray.map f xs

val _ = print "mlrisc's string literal bug"

fun copy a b e d j =
    if e < b then ()
    else let val v = Array.sub (Array.sub (a, 0), b)
         in Array.update (Array.sub (d, 0), j, v);
            copy a (b+1) e d (j+1)
         end

fun sort a b e =
    if e <= b then () else
    let val q = Int.quot (b + e, 2)
    in sort a b q;
       sort a (q+1) e;
       copy a b e a b
    end

val a = Array.array (1, Array.array (1024, 0))
val _ = sort a 0 1023

    (* MLRISC is incorrectly naming some of the 8-bit registers, so as a simple
     * workaround, we are just going to find/replace them in the output text file
     *)
    fun replace8BitRegisters asmFile = let
	  val cmd = "sed -i \"s/%ah/%spl/g; s/%ch/%bpl/g; s/%dh/%sil/g; s/%bh/%dil/g\" " ^ asmFile
	  in
	    ignore (OS.Process.system cmd)
	  end