content: 
  module Main where
  
  import Arithmetic
  import Trit
  import Converter
  import System.IO.Unsafe
  import Data.Ratio
  import Utilities
  import Thread
  
  main = startM1						  
  
  startM1 :: IO()
  startM1 = do
  	  c <- unsafeInterleaveIO (mult (rationalToGray (1%3)) (rationalToGray (0%1)))
  	  putStrLn (show  (take 100 (drop 1 c)))
  
  
  
  
  mult :: Gray -> Gray -> IO Gray
  mult xs ys = do
  		     			c <- threadTesting1 xs ys
  		     			case c of
  
  					   101 -> do
  						   --putStrLn ("In case 101")
  						   let tx = drop 2 xs
  						   let ty = drop 2 ys
  						   t1 <- unsafeInterleaveIO (addition tx ty)
  						   t2 <- unsafeInterleaveIO (addition (fl t1) (1:t1))
  						   t3 <- unsafeInterleaveIO (mult tx ty)
  						   c' <- unsafeInterleaveIO (addition t2 (1:0:0:(fl t3)))
  						   return c'
  
  					   102 -> do
  						   --putStrLn ("In case 102")
  						   let tx = drop 2 xs
  						   let ty = drop 2 ys
  						   t1 <- unsafeInterleaveIO (addition (fl tx) ty)
  					           t2 <- unsafeInterleaveIO (addition tx ty)
  						   t0 <- unsafeInterleaveIO (addition t1 (1:fl t2))
  						   t3 <- unsafeInterleaveIO (mult tx ty)
  						   c' <- unsafeInterleaveIO (addition t0 (1:1:0:fl t3))
  						   return c'
  
  					   103 -> do
  						   --putStrLn ("In case 103")
  						   let tx = drop 2 xs
  						   let ty = drop 2 ys
  						   t <- unsafeInterleaveIO (mult (0:0:tx) (0:0:ty))
  						   return (fl t)
  
  					   104 -> do
  						   --putStrLn ("In case 104")
  						   let tx = drop 2 xs
  						   let ty = drop 2 ys
  						   t <- unsafeInterleaveIO (mult (0:0:tx) (0:1:ty))
  						   return (fl t)
  
  					   201 -> do
  						   c' <- unsafeInterleaveIO (mult ys xs)
  						   return c'
  						   
  					   202 -> do
  						   --putStrLn ("In case 202")
  						   let tx = drop 2 xs
  						   let ty = drop 2 ys
  						   t1 <- unsafeInterleaveIO (addition tx ty)
  						   t2 <- unsafeInterleaveIO (addition t1 (0:fl t1))
  						   t3 <- unsafeInterleaveIO (mult tx ty)
  						   c' <- unsafeInterleaveIO (addition t2 (1:1:1:fl t3))
  						   return c'
  						   
  					   203 -> do
  						   --putStrLn ("In case 203")
  						   let tx = drop 2 xs
  						   let ty = drop 2 ys
  						   t <- unsafeInterleaveIO (mult (0:1:tx) (0:0:ty))
  						   return (fl t)
  
  					   204 -> do
  						   --putStrLn ("In case 204")
  						   let tx = drop 2 xs
  						   let ty = drop 2 ys
  						   t <- unsafeInterleaveIO (mult (0:1:tx) (0:1:ty))
  						   return (fl t)
  
  					   30 ->  do
  						   --putStrLn ("In case 30")
  						   let y1 = ys !! 0
  						   let tx = drop 2 xs
  						   let ty = drop 3 ys
  					           t1 <- unsafeInterleaveIO (addition ((f0' y1):1:ty) ((f0' y1):1:0:ty))
  						   t0 <- unsafeInterleaveIO (mult tx (y1: fl ty))
  						   let c4 = head t0
  						   let d4 = fl (tail t0)
  						   c' <- unsafeInterleaveIO (addition t1 (c4:1:0:0:d4))
  						   return c'
  						   
  					   31 -> do
  					   	  --putStrLn ("In case 31")
  					   	  let tx = drop 2 xs
  						  c' <- unsafeInterleaveIO (mult (0:0:tx) ys)
  						  return (fl c')
  						  
  					   40 ->  do
  					   	   --putStrLn ("In case 40")
  						   let tx = drop 2 xs
  						   let y2 = ys !! 1
  						   let ty = drop 3 ys
  						   t1 <- unsafeInterleaveIO (addition (y2:fl ty) tx)
  						   t2 <- unsafeInterleaveIO (addition (fl t1) (1:y2:1:ty))
  						   t0 <- unsafeInterleaveIO (mult tx (y2:fl ty))
  						   let c2 = f0' (head t0)
  						   let d2 = fl (tail t0)
  						   c' <- unsafeInterleaveIO (addition t2 (1:c2:1:0:d2))
  						   return c'
  						   				   
  					   41 ->  do
  					   	   --putStrLn ("In case 41")
  					   	   let tx = drop 2 xs
  						   let y2 = ys !! 1
  						   let ty = drop 3 ys
  						   c' <- unsafeInterleaveIO (mult (0:0:tx) (0:y2:1:ty))
  						   return (fl c')
  						   
  					   50 ->  do
  					           --putStrLn ("In case 50")
  					   	   let tx = drop 2 xs
  						   let y2 = ys !! 1
  						   let ty = drop 3 ys
  						   t1 <- unsafeInterleaveIO (addition tx (fl (y2:fl ty)))
  						   t2 <- unsafeInterleaveIO (addition t1 (0:y2:1:ty))
  						   t0 <- unsafeInterleaveIO (mult (fl tx) (y2:fl ty))
  						   let c1 = f0' (head t0)
  						   let d1 = fl (tail t0)
  						   c' <- unsafeInterleaveIO (addition t2 (1:c1:1:0:d1))
  						   return c'
  						   
  					   51 ->  do
  					           --putStrLn ("In case 51")
  					   	   let tx = drop 2 xs
  						   let y2 = ys !! 1
  						   let ty = drop 3 ys
  						   c' <- unsafeInterleaveIO (mult (0:1:tx) (0:y2:1:ty))
  						   return (fl c')
  						   
  						   
  					   60 ->  do
  					           --putStrLn ("In case 60")
  					   	   let tx = drop 2 xs
  						   let y1 = ys !! 0
  						   let ty = drop 3 ys
  						   t1 <- unsafeInterleaveIO (addition ((f0' y1):1:ty) (y1:1:0:ty))
  						   t0 <- unsafeInterleaveIO (mult (fl tx) (y1:fl ty))
  						   let c1 = head t0
  						   let d1 = fl (tail t0)
  						   c' <- unsafeInterleaveIO (addition t1 (c1:1:0:0:d1))
  						   return c'
  						   
  					   61 ->  do
  					           --putStrLn ("In case 61")
  					   	   let tx = drop 2 xs
  						   let y1 = ys !! 0
  						   let ty = drop 3 ys
  						   c' <- unsafeInterleaveIO (mult (0:1:tx) (y1:1:0:ty))
  						   return (fl c')
  						   
  						   
  					   70 ->  do
  					           --putStrLn ("In case 70")
  					   	   c' <- unsafeInterleaveIO (mult ys xs)
  						   return c'
  						   
  					   80 ->  do
  					           --putStrLn ("In case 80")
  						   let x2 = xs !! 1
  						   let y2 = ys !! 1
  						   let tx = drop 3 xs
  						   let ty = drop 3 ys
  						   t1 <- unsafeInterleaveIO (addition (x2:fl tx) (y2:fl ty))
  						   t0 <- unsafeInterleaveIO (mult (x2:fl tx) (y2:fl ty))
  						   let c1 = head (fl t1)
  						   let d1 = tail (fl t1)
  						   let c2 = f0' (head t0)
  						   let d2 = fl (tail t0)
  						   c' <- unsafeInterleaveIO (addition (c1:1:(fl d1)) (1:c2:1:0:d2))
  						   return c'
  						   
  					   81 ->  do
  					           --putStrLn ("In case 81")
  					   	   let x2 = xs !! 1
  						   let y2 = ys !! 1
  						   let tx = drop 3 xs
  						   let ty = drop 3 ys
  						   c' <- unsafeInterleaveIO (mult (0:x2:1:tx) (0:y2:1:ty))
  						   return (fl c')
  						   
  					   90 ->  do
  					   	   --putStrLn ("In case 90")
  						   let x2 = xs!!1
  						   let y1 = ys!!0
  						   let tx = drop 3 xs
  						   let ty = drop 3 ys
  						   t0 <- unsafeInterleaveIO (mult (x2:fl tx) (y1:fl ty))
  						   let c1 = head t0
  						   let d1 = fl (tail t0)
  						   c' <- unsafeInterleaveIO (addition ((f0' y1):1:0:ty) (c1:1:0:0:d1))
  						   return c'
  						   
  					   91 ->  do
  					   	   --putStrLn ("In case 91")
  					   	   let x2 = xs!!1
  						   let y1 = ys!!0
  						   let tx = drop 3 xs
  						   let ty = drop 3 ys
  						   c' <- unsafeInterleaveIO (mult (0:x2:1:tx) (y1:1:0:ty))
  						   return (fl c')
  						   
  					   100 -> do
  					   	  --putStrLn ("In case 100")
  					          let x1 = head xs
  						  let y1 = head ys
  						  let tx = drop 3 xs
  						  let ty = drop 3 ys
  						  t0 <- unsafeInterleaveIO (mult (x1:fl tx) (y1:fl ty))
  						  let c4 = head t0
  						  let d4 = fl (tail t0)
  						  return (c4:1:0:0:0:d4)
  						  
  						   
  				
  f0' 0 = 1
  f0' 1 = 0						   
  						   
  