diff --git a/Grammar.y b/Grammar.y
index daa49695df0e16f3e387bae76adfc36463915918..bfe9165b1e5b2b7b73c89420835593fa1f26f342 100644
--- a/Grammar.y
+++ b/Grammar.y
@@ -9,14 +9,148 @@ import Tokens
 
 %token
 
-
+    int         { TokenDigit _ $$ }
+    var         { TokenVar _ $$ }
+    true        { TokenBTrue _ }
+    false       { TokenBFalse _ }
+    '-'         {TokenMinus _}
+    '*'         {TokenMult _}
+    '/'         {TokenDiv _}
+    '.'         {TokenDot _}
+    ','         {TokenComma _}
+    for         {TokenFor _}
+    empty       {TokenEmpty _}
+    create      {TokenCreate _}
+    blank       {TokenBlank _}
+    flipx       {TokenFlipX _}
+    flipy       {TokenFlipY _}
+    rotate      {TokenRotate _}
+    subtile     {TokenSubtile _}
+    conj        { TokenConj _}
+    neg         { TokenNeg _}
+    supersize   {}
+    '+'         { TokenAdd _ }
+    '<'         { TokenLessThan _ }
+    if          { TokenIf _ }
+    then        { TokenThen _ }
+    else        { TokenElse _ }
+    '='         { TokenEqual _ }
+    '('         { TokenOpBracket _ }
+    ')'         { TokenClBracket _ }
+    '['         { TokenOSBracket _ }
+    ']'         { TokenClSBracket _ }
+    '{'         { TokenOCurBracket _ }
+    '}'         { TokenClCurBracket _ }
+    Bool        { TokenBool _ }
+    Int         { TokenInt _ }
+     
+    
+%right else
+%nonassoc '<'
+%left '+'
 
 %%
 
+Ent : var '=' Func                     {Assign $1 $3}
+    | '[' var ']' '=' '[' List ']'     {TGroup $2 $6}
+    | var '[' int ']'                  {Accessor $1 $3}
+    | Func 
+
+Func : for  '(' Math ')' '{' Func '}'                       {For $3 $6}
+     | if '(' Operations ')' then '{' Func '}' IfStatement  {If $3 $7 $9}
+     | tile '[' Row ']'                                     {Tile $3}
+     | empty '(' int ',' int ')'                            {Empty $3 $5}
+     | blank '(' int ',' int ')'                            {Blank $3 $5}
+     | numCol '(' Func ')'                                  {NumCol $3}
+     | numRow '(' Func ')'                                  {NumRow $3}
+     | print '(' Func ')'                                   {Print $3}
+     | flipy Func                                           {FlipY $2}
+     | flipx Func                                           {FlipX $2}
+     | join '[' List ']'                                    {Join $3}
+     | stack '[' List ']'                                   {Stack $3}
+     | rotate '(' Func ')'                                  {Rotate $3}
+     | supersize '(' Func ',' int ')'                       {Super $3 $5}
+     | BoolTiles
+
+BoolTiles : conj '(' Func ',' Func ')'                      {Conjunction $3 $5}
+          | neg '(' Func ')'                                {Negation $3}
+          | Math                                            {$1}
+
+IfStatement : else if '(' Boolean ')' then '{' Func '}' IfStatement     {ElseIf $4 $8 $10}
+            | else '{' Func '}'                                         {Else $3}
+
+List : var                          {$1}
+     | var ',' List                 {List $1 $3}
+
+Row : '[' Block ']'                 {Block $2}
+    | '[' Block ']' ',' Row         {Blocks $2 $5}
+
+Block : '0'                         {Z}
+      | '1'                         {O}
+      | '0' ',' Block               {Z $3}
+      | '1' ',' Block               {O $3}
+
+Operations : Boolean '&' '&' Boolean        {And $1 $4}
+           | Boolean '|' '|' Boolean        {Or $1 $4}
+           | not Operations                 {Not $2} 
+           | Boolean                        {$1}
+
+Boolean : Math '<' Math       {Less $1 $3}
+        | Math '=' '=' Math   {Equality $1 $4}
+        | true                {BTrue}
+        | false               {BFalse} 
+
+Math : Math '+' Math          {Add $1 $3}
+     | Math '-' Math          {Subtract $1 $3}
+     | Math '*' Math          {Multiply $1 $3}
+     | Math '/' Math          {Divide $1 $3}
+     | '(' Math ')'           {$2} 
+     | Prim                   {$1}
+
+Prim : int                    {Int $1} 
+     | Type var               {Var $1 $2} 
+     
+Type : Tile                   {TileType}
+     | TileGroup              {TGType}
+     | Int                    {IntType}
+     | Bool                   {BoolType}
 
 { 
 parseError :: [Token] -> a
-parseError _ = error "Parse error" 
+parseError [] = error "Parse error" 
+parseError (t:ts) = error "parse error at line:column" ++ (tokenPosn t)
+
+data Funcs = If Funcs Funcs ElseOptions
+           | For Funcs Funcs
+           | Tile Funcs
+           | Empty Int Int
+           | Blank Int Int 
+           | NumCol Funcs
+           | NumRow Funcs
+           | Print Funcs
+           | Flipy Funcs
+           | Flipx Funcs
+           | Join ????
+           | Stack ????
+           | Rotate Funcs
+           | Supersize Funcs Int
+           | BTrue
+           | BFalse
+           | Int Int
+           | Var String
+           deriving (Show,Eq,Read)
+
+data ElseOptions = ElseIf Funcs Funcs ElseOptions
+                 | Else Funcs 
+
+data TileBuilder = ????
+
+data TGBuilder = ????
 
+data Types = TileType
+           | TGType
+           | IntType
+           | BoolType
+           deriving (Show,Eq,Read)
 
 } 
\ No newline at end of file
diff --git a/Tokens.hs b/Tokens.hs
index 59fe0afa7a6bb7c16b152147c82aebe53d04d358..ff6878eb84febce9e090f21482ac6be2a1b81670 100644
--- a/Tokens.hs
+++ b/Tokens.hs
@@ -19639,7 +19639,7 @@ tok f p s = f p s
 
 -- The token type:
 data TokenType =
-    TokenDigit AlexPosn Int            |
+    TokenDigit AlexPosn Int          |
     TokenMinus AlexPosn              |
     TokenMult AlexPosn               |
     TokenDiv  AlexPosn               |
@@ -19680,7 +19680,7 @@ data TokenType =
     TokenBool AlexPosn               |
     TokenBTrue AlexPosn              |
     TokenBFalse AlexPosn             |
-    TokenGroup AlexPosn              |
+    TokenGroup AlexPosn String       |
     TokenVar AlexPosn String
 
     deriving (Eq,Show)
@@ -19725,50 +19725,50 @@ token_posn (TokenTileG (AlexPn a l c) ) = show(l) ++ ":" ++ show(c)
 token_posn (TokenBool (AlexPn a l c) ) = show(l) ++ ":" ++ show(c)
 token_posn (TokenBTrue (AlexPn a l c) ) = show(l) ++ ":" ++ show(c)
 token_posn (TokenBFalse (AlexPn a l c) ) = show(l) ++ ":" ++ show(c)
-token_posn (TokenGroup (AlexPn a l c) ) = show(l) ++ ":" ++ show(c)
+token_posn (TokenGroup (AlexPn a l c) _) = show(l) ++ ":" ++ show(c)
 token_posn (TokenVar (AlexPn a l c) _) = show(l) ++ ":" ++ show(c)
 alex_action_2 = tok (\p s -> TokenDigit p (read s) )
-alex_action_3 = tok (\p s -> TokenMinus p        )
-alex_action_4 = tok (\p s -> TokenMult p         )
-alex_action_5 = tok (\p s -> TokenDiv p          )
-alex_action_6 = tok (\p s -> TokenOpBracket p    )
-alex_action_7 = tok (\p s -> TokenClBracket p    )
-alex_action_8 = tok (\p s -> TokenEq p           )
-alex_action_9 = tok (\p s -> TokenPlus p         )
-alex_action_10 = tok (\p s -> TokenDot p          )
-alex_action_11 = tok (\p s -> TokenLess p         )
-alex_action_12 = tok (\p s -> TokenComma p        )
-alex_action_13 = tok (\p s -> TokenOSBracket p    )
-alex_action_14 = tok (\p s -> TokenClSBracket p   )
-alex_action_15 = tok (\p s -> TokenOCurBracket p  )
-alex_action_16 = tok (\p s -> TokenClCurBracket p )
-alex_action_17 = tok (\p s -> TokenIf p           )
-alex_action_18 = tok (\p s -> TokenThen p         )
-alex_action_19 = tok (\p s -> TokenElse p         )
-alex_action_20 = tok (\p s -> TokenFor p          )
-alex_action_21 = tok (\p s -> TokenEmpty p        )
-alex_action_22 = tok (\p s -> TokenCreate p       )
-alex_action_23 = tok (\p s -> TokenBlank p        )
-alex_action_24 = tok (\p s -> TokenFlipX p        )
-alex_action_25 = tok (\p s -> TokenFlipY p        )
-alex_action_26 = tok (\p s -> TokenRotate p       )
-alex_action_27 = tok (\p s -> TokenSubtile p      )
-alex_action_28 = tok (\p s -> TokenConj p         )
-alex_action_29 = tok (\p s -> TokenNeg p          )
-alex_action_30 = tok (\p s -> TokenSupersize p    )
-alex_action_31 = tok (\p s -> TokenStack p        )
-alex_action_32 = tok (\p s -> TokenJoin p         )
-alex_action_33 = tok (\p s -> TokenShape p        )
-alex_action_34 = tok (\p s -> TokenAND p          )
-alex_action_35 = tok (\p s -> TokenOR p           )
-alex_action_36 = tok (\p s -> TokenNOT p          )
-alex_action_37 = tok (\p s -> TokenInt p          )
-alex_action_38 = tok (\p s -> TokenTile p         )
-alex_action_39 = tok (\p s -> TokenTileG p        )
-alex_action_40 = tok (\p s -> TokenBool p         )
-alex_action_41 = tok (\p s -> TokenBTrue p        )
-alex_action_42 = tok (\p s -> TokenBFalse p       )
-alex_action_43 = tok (\p s -> TokenGroup p )
+alex_action_3 = tok (\p s -> TokenMinus p          )
+alex_action_4 = tok (\p s -> TokenMult p           )
+alex_action_5 = tok (\p s -> TokenDiv p            )
+alex_action_6 = tok (\p s -> TokenOpBracket p      )
+alex_action_7 = tok (\p s -> TokenClBracket p      )
+alex_action_8 = tok (\p s -> TokenEq p             )
+alex_action_9 = tok (\p s -> TokenPlus p           )
+alex_action_10 = tok (\p s -> TokenDot p            )
+alex_action_11 = tok (\p s -> TokenLess p           )
+alex_action_12 = tok (\p s -> TokenComma p          )
+alex_action_13 = tok (\p s -> TokenOSBracket p      )
+alex_action_14 = tok (\p s -> TokenClSBracket p     )
+alex_action_15 = tok (\p s -> TokenOCurBracket p    )
+alex_action_16 = tok (\p s -> TokenClCurBracket p   )
+alex_action_17 = tok (\p s -> TokenIf p             )
+alex_action_18 = tok (\p s -> TokenThen p           )
+alex_action_19 = tok (\p s -> TokenElse p           )
+alex_action_20 = tok (\p s -> TokenFor p            )
+alex_action_21 = tok (\p s -> TokenEmpty p          )
+alex_action_22 = tok (\p s -> TokenCreate p         )
+alex_action_23 = tok (\p s -> TokenBlank p          )
+alex_action_24 = tok (\p s -> TokenFlipX p          )
+alex_action_25 = tok (\p s -> TokenFlipY p          )
+alex_action_26 = tok (\p s -> TokenRotate p         )
+alex_action_27 = tok (\p s -> TokenSubtile p        )
+alex_action_28 = tok (\p s -> TokenConj p           )
+alex_action_29 = tok (\p s -> TokenNeg p            )
+alex_action_30 = tok (\p s -> TokenSupersize p      )
+alex_action_31 = tok (\p s -> TokenStack p          )
+alex_action_32 = tok (\p s -> TokenJoin p           )
+alex_action_33 = tok (\p s -> TokenShape p          )
+alex_action_34 = tok (\p s -> TokenAND p            )
+alex_action_35 = tok (\p s -> TokenOR p             )
+alex_action_36 = tok (\p s -> TokenNOT p            )
+alex_action_37 = tok (\p s -> TokenInt p            )
+alex_action_38 = tok (\p s -> TokenTile p           )
+alex_action_39 = tok (\p s -> TokenTileG p          )
+alex_action_40 = tok (\p s -> TokenBool p           )
+alex_action_41 = tok (\p s -> TokenBTrue p          )
+alex_action_42 = tok (\p s -> TokenBFalse p         )
+alex_action_43 = tok (\p s -> TokenGroup p s)
 alex_action_44 = tok (\p s -> TokenVar p s)
 
 #define ALEX_NOPRED 1
diff --git a/Tokens.x b/Tokens.x
index 6dbdc39ad610f800b462ad008469a93a34bcf95f..e2a9b7bc291fb168bf95f49880f60fb7c99bc1e0 100644
--- a/Tokens.x
+++ b/Tokens.x
@@ -12,47 +12,47 @@ tokens :-
   $white+                ;
   "--".*                 ;
   $digit+                { tok (\p s -> TokenDigit p (read s) )}
-  \-                     { tok (\p s -> TokenMinus p        )}
-  \*                     { tok (\p s -> TokenMult p         )}
-  \/                     { tok (\p s -> TokenDiv p          )}
-  \(                     { tok (\p s -> TokenOpBracket p    )}
-  \)                     { tok (\p s -> TokenClBracket p    )}
-  \=                     { tok (\p s -> TokenEq p           )}
-  \+                     { tok (\p s -> TokenPlus p         )}
-  \.                     { tok (\p s -> TokenDot p          )}
-  \<                     { tok (\p s -> TokenLess p         )}
-  \,                     { tok (\p s -> TokenComma p        )}
-  \[                     { tok (\p s -> TokenOSBracket p    )}
-  \]                     { tok (\p s -> TokenClSBracket p   )}
-  \{                     { tok (\p s -> TokenOCurBracket p  )}
-  \}                     { tok (\p s -> TokenClCurBracket p )}
-  if                     { tok (\p s -> TokenIf p           )}
-  then                   { tok (\p s -> TokenThen p         )}
-  else                   { tok (\p s -> TokenElse p         )}
-  for                    { tok (\p s -> TokenFor p          )}
-  empty                  { tok (\p s -> TokenEmpty p        )}
-  create                 { tok (\p s -> TokenCreate p       )}
-  blank                  { tok (\p s -> TokenBlank p        )}
-  flipx                  { tok (\p s -> TokenFlipX p        )}
-  flipy                  { tok (\p s -> TokenFlipY p        )}
-  rotate                 { tok (\p s -> TokenRotate p       )}
-  subtile                { tok (\p s -> TokenSubtile p      )}
-  conj                   { tok (\p s -> TokenConj p         )}
-  neg                    { tok (\p s -> TokenNeg p          )}
-  supersize              { tok (\p s -> TokenSupersize p    )}
-  stack                  { tok (\p s -> TokenStack p        )}
-  join                   { tok (\p s -> TokenJoin p         )}
-  shape                  { tok (\p s -> TokenShape p        )}
-  \&\&                   { tok (\p s -> TokenAND p          )}
-  \|\|                   { tok (\p s -> TokenOR p           )}
-  not                    { tok (\p s -> TokenNOT p          )}
-  Int                    { tok (\p s -> TokenInt p          )}
-  Tile                   { tok (\p s -> TokenTile p         )}
-  TileGroup              { tok (\p s -> TokenTileG p        )}
-  Bool                   { tok (\p s -> TokenBool p         )}
-  true                   { tok (\p s -> TokenBTrue p        )}
-  false                  { tok (\p s -> TokenBFalse p       )}
-  \[ $alpha [$alpha $digit \_ \']*  \] {tok (\p s -> TokenGroup p )}
+  \-                     { tok (\p s -> TokenMinus p          )}
+  \*                     { tok (\p s -> TokenMult p           )}
+  \/                     { tok (\p s -> TokenDiv p            )}
+  \(                     { tok (\p s -> TokenOpBracket p      )}
+  \)                     { tok (\p s -> TokenClBracket p      )}
+  \=                     { tok (\p s -> TokenEq p             )}
+  \+                     { tok (\p s -> TokenPlus p           )}
+  \.                     { tok (\p s -> TokenDot p            )}
+  \<                     { tok (\p s -> TokenLess p           )}
+  \,                     { tok (\p s -> TokenComma p          )}
+  \[                     { tok (\p s -> TokenOSBracket p      )}
+  \]                     { tok (\p s -> TokenClSBracket p     )}
+  \{                     { tok (\p s -> TokenOCurBracket p    )}
+  \}                     { tok (\p s -> TokenClCurBracket p   )}
+  if                     { tok (\p s -> TokenIf p             )}
+  then                   { tok (\p s -> TokenThen p           )}
+  else                   { tok (\p s -> TokenElse p           )}
+  for                    { tok (\p s -> TokenFor p            )}
+  empty                  { tok (\p s -> TokenEmpty p          )}
+  create                 { tok (\p s -> TokenCreate p         )}
+  blank                  { tok (\p s -> TokenBlank p          )}
+  flipx                  { tok (\p s -> TokenFlipX p          )}
+  flipy                  { tok (\p s -> TokenFlipY p          )}
+  rotate                 { tok (\p s -> TokenRotate p         )}
+  subtile                { tok (\p s -> TokenSubtile p        )}
+  conj                   { tok (\p s -> TokenConj p           )}
+  neg                    { tok (\p s -> TokenNeg p            )}
+  supersize              { tok (\p s -> TokenSupersize p      )}
+  stack                  { tok (\p s -> TokenStack p          )}
+  join                   { tok (\p s -> TokenJoin p           )}
+  shape                  { tok (\p s -> TokenShape p          )}
+  \&\&                   { tok (\p s -> TokenAND p            )}
+  \|\|                   { tok (\p s -> TokenOR p             )}
+  not                    { tok (\p s -> TokenNOT p            )}
+  Int                    { tok (\p s -> TokenInt p            )}
+  Tile                   { tok (\p s -> TokenTile p           )}
+  TileGroup              { tok (\p s -> TokenTileG p          )}
+  Bool                   { tok (\p s -> TokenBool p           )}
+  true                   { tok (\p s -> TokenBTrue p          )}
+  false                  { tok (\p s -> TokenBFalse p         )}
+  \[ $alpha [$alpha $digit \_ \']*  \] {tok (\p s -> TokenGroup p s)}
   $alpha [$alpha $digit \_ \']*  { tok (\p s -> TokenVar p s)}
 
 {
@@ -62,7 +62,7 @@ tok f p s = f p s
 
 -- The token type:
 data TokenType =
-    TokenDigit AlexPosn Int            |
+    TokenDigit AlexPosn Int          |
     TokenMinus AlexPosn              |
     TokenMult AlexPosn               |
     TokenDiv  AlexPosn               |
@@ -103,9 +103,8 @@ data TokenType =
     TokenBool AlexPosn               |
     TokenBTrue AlexPosn              |
     TokenBFalse AlexPosn             |
-    TokenGroup AlexPosn              |
+    TokenGroup AlexPosn String       |
     TokenVar AlexPosn String
-
     deriving (Eq,Show)
 
 token_posn (TokenDigit (AlexPn a l c)_)  = show(l) ++ ":" ++ show(c)
@@ -148,10 +147,7 @@ token_posn (TokenTileG (AlexPn a l c) ) = show(l) ++ ":" ++ show(c)
 token_posn (TokenBool (AlexPn a l c) ) = show(l) ++ ":" ++ show(c)
 token_posn (TokenBTrue (AlexPn a l c) ) = show(l) ++ ":" ++ show(c)
 token_posn (TokenBFalse (AlexPn a l c) ) = show(l) ++ ":" ++ show(c)
-token_posn (TokenGroup (AlexPn a l c) ) = show(l) ++ ":" ++ show(c)
+token_posn (TokenGroup (AlexPn a l c) _) = show(l) ++ ":" ++ show(c)
 token_posn (TokenVar (AlexPn a l c) _) = show(l) ++ ":" ++ show(c)
 
-
-
-
 }
\ No newline at end of file