{-# LANGUAGE MagicHash #-}

module Main where

import qualified Prelude as P
import Prelude (undefined, seq, print, ($), (+))
import GHC.Prim
import GHC.Types
import Data.List (foldl')

data IntList = Nil | Cons Int# !IntList

fromList = foldl' (\xs (I# x) -> Cons x xs) Nil

foldl _ a Nil = a
foldl f a (Cons x xs) = let a' = f a x in seq a' $ foldl f a' xs

length = foldl (\r _ -> r+1) 0
last   = foldl (\_ x -> I# x) undefined

xs :: IntList
xs = fromList [1..10000000]

main = do
    print $ length xs
    print $ last   xs

module Lists

import StdInt, StdEnum, MersenneTwister
   
xs :: [Int]
xs = take 100000000 (genRandInt 12345)

take :: !Int [a] -> [a]
take 0 _      = []
take _ []     = []
take n [x:xs] = [x : take (n-1) xs]

length2 :: [a] -> Int
length2 xs = len xs 0
  where
    len :: [a] !Int -> Int
    len []     n = n
    len [_:ys] n = len ys (n+1)

last :: [a] -> a
last [x]    = x
last [x:xs] = last xs

Start::(Int, Int)
Start = (length2 xs, last xs)

fib :: Int -> Int
fib 1 = 1
fib 2 = 1
fib n = fib (n-1) + fib (n-2)

s2
   eqI_b 1 0
   jmp_true case.1
   eqI_b 2 0
   jmp_true case.2
   jmp case.3
case.1
   pop_b 1
   pushI 1
.d 0 1 i
   rtn
case.2
   pop_b 1
   pushI 1
.d 0 1 i
   rtn
case.3
   pushI 2
   push_b 1
   subI
.d 0 1 i
   jsr s2
.o 0 1 i
   pushI 1
   push_b 2
   subI
.d 0 1 i
   jsr s2
.o 0 1 i
   update_b 1 2
   updatepop_b 0 1
   addI
.d 0 1 i
   rtn

lst = [1..]
main = print $ length lst

a = b :: Int
b = a

main = do
    print a