PROGRAM ::= main { INSTRSEQ }
PROGRAM ::= VARSEQ main { INSTRSEQ }
PROGRAM ::= PROCSEQ main { INSTRSEQ }
PROGRAM ::= VARSEQ PROCSEQ main { INSTRSEQ }

	First(PROGRAM) = {main, var, epsilon, sub}
	Follow(PROGRAM) = {eof}

VARSEQ ::= VARDECL ; VARSEQ | epsilon

	First(VARSEQ) = {var, epsilon}
	Follow(VARSEQ) = {main, sub, epsilon}

VARDECL ::= var IDLIST : TYPEIDENT

	First(VARDECL) = {var}
	Follow(VARDECL) = {;}

TYPEIDENT ::= integer | float | boolean | string | ATYPE

	First(TYPEIDENT) = {integer, float, boolean, string, arrayof}
	Follow(TYPEIDENT) = {;}

ATYPE ::= arrayof TYPEIDENT

	First(ATYPE) = {arrayof}
	Follow(ATYPE) = {;}

IDLIST ::= ident IDLIST2

	First(IDLIST) = {ident}
	Follow(IDLIST) = {:}

IDLIST2 ::= , IDLIST | epsilon

	First(IDLIST2) = {, , epsilon}
	Follow(IDLIST2) = {:}

PROCSEQ ::= PROCDECL | epsilon

	First(PROCSEQ) = {sub, epsilon}
	Follow(PROCSEQ) = {main}

PROCDECL ::= sub ident ( FPARAMS ) : TYPEIDENT ; { VARSEQ INSTRSEQ }
PROCDECL ::= sub ident ( FPARAMS ) : TYPEIDENT ; { INSTRSEQ }
PROCDECL ::= sub ident ( FPARAMS ) ; { VARSEQ INSTRSEQ }
PROCDECL ::= sub ident ( FPARAMS ) ; { INSTRSEQ }
PROCDECL ::= sub ident : TYPEIDENT ; { VARSEQ INSTRSEQ }
PROCDECL ::= sub ident : TYPEIDENT ; { INSTRSEQ }
PROCDECL ::= sub ident ; { VARSEQ INSTRSEQ }
PROCDECL ::= sub ident ; { INSTRSEQ }

	First(PROCDECL) = {sub}
	Follow(PROCDECL) = {}

FPARAMS ::= ident : TYPEIDENT
FPARAMS ::= ident : TYPEIDENT FPARAMS2

	First(FPARAMS) = {ident}
	Follow(FPARAMS) = {)}

FPRARMS2 ::= , FPARAMS | epsilon

	First(FPARAMS2) = {, , epsilon}
	Follow(FPARAMS2) = {)}

EXPR ::= SIMPEXPR EXPR2
EXPR ::= + SIMPEXPR EXPR2
EXPR ::= - SIMPEXPR EXPR2

	First(EXPR) = {ident, lstring, lint, lbool, lreal, call, +, -}
	Follow(EXPR) = {alloc, )}

EXPR2 ::= RELOP SIMPEXPR EXPR2 | epsilon

	First(EXPR2) = {==, <, >, !=, >=, <=}
	Follow(EXPR2) = {alloc, )}

SIMPEXPR ::= TERM SIMPEXPR2

	First(SIMPEXPR) = {ident, lstring, lint, lbool, lreal, call)
	Follow(SIMPEXPR) = {==, <, >, !=, >=, <=, epsilon}

SIMPEXPR2 ::= ADDOP TERM SIMPEXPR2 | epsilon

	First(SIMPEXPR2) = {+, -, or, epsilon)
	Follow(SIMPEXPR2) = {+, -, or, epsilon}

TERM ::= FACTOR TERM2

	First(TERM) = {ident, lstring, lint, lbool, lreal, call}
	Follow(TERM) = {+, -, or, epsilon}

TERM2 ::= MULTOP FACTOR TERM2 | epsilon

	First(TERM2) = {*, /, and}
	Follow(TERM2) = {+, -, or, epsilon}

FACTOR ::= ident ( lint ) | lstring | lint | lbool | lreal | SCALL
FACTOR ::= ident ( ident ) | lstring | lint | lbool | lreal | SCALL

	First(FACTOR) = {ident, lstring, lint, lbool, lreal, call}
	Follow(FACTOR) = {*, /, and, epsilon}

RELOP ::= == | < | > | != | >= | <=

	First(RELOP) = {==, <, >, !=, >=, <=}
	Follow(RELOP) = {ident, lstring, lint, lbool, lreal, call}

ADDOP ::= + | - | or

	First(ADDOP) = {+, -, or}
	Follow(ADDOP) = {ident, lstring, lint, lbool, lreal, call}

MULTOP ::= * | / | and

	First(MULTOP) = {*, /, and}
	Follow(MULTOP) = {ident, lstring, lint, lbool, lreal, call}

INSTRSEQ ::= INSTR ; INSTRSEQ | epsilon

	First(INSTRSEQ) = {ident, if, do, read, print, block, call, alloc
	Follow(INSTRSEQ) = {}}

INSTR ::= ASSIGN | COND | LOOP | IN | OUT | BLOCK | SCALL | ARRALLOC

	First(INSTR) = {ident, if, do, read, print, block, call, alloc}
	Follow(INSTR) = {;}

ASSIGN ::= ident [ ( lint | ident ) ] = EXPR

	First(ASSING) = {ident}
	Follow(ASSIGN) = {;}

OUT ::= print ( EXPR )

	First(OUT) = {print}
	Follow(OUT) = {;}

IN ::= read ( IDENT )

	First(IN) = {read}
	Follow(IN) = {;}

COND ::= if ( EXPR ) { INSTRSEQ }

	First(COND) = {if}
	Follow(COND) = {;}

LOOP ::= do ( EXPR ) { INSTRSEQ }

	First(LOOP) = {do}
	Follow(LOOP) = {;}

BLOCK ::= block { [ VARSEQ ] INSTRSEQ }

	First(BLOCK) = {block}
	Follow(BLOCK) = {;}

SCALL ::= call ident( APARAMS )
SCALL ::= call ident

	First(SCALL) = {call}
	Follow(SCALL) = {;}

APARAMS ::= EXPR APARAMS2

	First(APARAMS) = {ident, lstring, lint, lbool, lreal, call, +, -}
	Follow(APARAMS) = {)}

APARAMS2 ::= , APARAMS | epsilon

	First(APARAMS2) = {, , epsilon}
    Follow(APARAMS2) = {)}

ARRALLOC ::= alloc ( IDENT , LINT )

	First(ARRALLOC) = {alloc}
	Follow(ARRALLOC) = {;}