let rec token lexbuf =
  lexbuf.Lexing.lex_mem <- Array.create 2 (-1) ;   __ocaml_lex_token_rec lexbuf 0
and __ocaml_lex_token_rec lexbuf __ocaml_lex_state =
  match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with
      | 0 ->
let
# 83 "scanner.mll"
               s
# 2509 "scanner.ml"
Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
# 83 "scanner.mll"
                                 ( SPACE(spacecount s) )
# 2513 "scanner.ml"

  | 1 ->
let
# 84 "scanner.mll"
                            v
# 2519 "scanner.ml"
Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_curr_pos in
# 84 "scanner.mll"
                                 ( count_lines v; COLON )
# 2523 "scanner.ml"

  | 2 ->
let
# 85 "scanner.mll"
               v
# 2529 "scanner.ml"
Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
# 85 "scanner.mll"
                                 ( count_lines v; NEWLINE )
# 2533 "scanner.ml"

  | 3 ->
# 88 "scanner.mll"
                               ( comment 0 lexbuf )
# 2538 "scanner.ml"

  | 4 ->
# 91 "scanner.mll"
                               ( REFINABLE )
# 2543 "scanner.ml"

  | 5 ->
# 92 "scanner.mll"
                               ( AND )
# 2548 "scanner.ml"

  | 6 ->
# 93 "scanner.mll"
                               ( OR )
# 2553 "scanner.ml"

  | 7 ->
# 94 "scanner.mll"
                               ( XOR )
# 2558 "scanner.ml"

  | 8 ->
# 95 "scanner.mll"
                               ( NAND )
# 2563 "scanner.ml"

  | 9 ->
# 96 "scanner.mll"
                               ( NOR )
# 2568 "scanner.ml"

  | 10 ->
# 97 "scanner.mll"
                               ( NOT )
# 2573 "scanner.ml"

  | 11 ->
# 98 "scanner.mll"
                               ( BLIT(true) )
# 2578 "scanner.ml"

  | 12 ->
# 99 "scanner.mll"
                               ( BLIT(false) )
# 2583 "scanner.ml"

  | 13 ->
# 100 "scanner.mll"
                               ( EQ )
# 2588 "scanner.ml"

  | 14 ->
# 101 "scanner.mll"
                               ( NEQ )
# 2593 "scanner.ml"

  | 15 ->
# 102 "scanner.mll"
                               ( NEQ )
# 2598 "scanner.ml"

  | 16 ->
# 103 "scanner.mll"
                               ( LT )
# 2603 "scanner.ml"

  | 17 ->
# 104 "scanner.mll"
                               ( LEQ )
# 2608 "scanner.ml"

  | 18 ->
# 105 "scanner.mll"
                               ( GT )
# 2613 "scanner.ml"

  | 19 ->
# 106 "scanner.mll"
                               ( GEQ )
# 2618 "scanner.ml"

  | 20 ->
# 109 "scanner.mll"
                               ( ARRAY )
# 2623 "scanner.ml"

  | 21 ->
# 110 "scanner.mll"
                               ( LBRACKET )
# 2628 "scanner.ml"

  | 22 ->
# 111 "scanner.mll"
                               ( RBRACKET )
# 2633 "scanner.ml"

  | 23 ->
# 112 "scanner.mll"
                               ( LPAREN )
# 2638 "scanner.ml"

  | 24 ->
# 113 "scanner.mll"
                               ( RPAREN )
# 2643 "scanner.ml"

  | 25 ->
# 114 "scanner.mll"
                               ( LBRACE )
# 2648 "scanner.ml"

  | 26 ->
# 115 "scanner.mll"
                               ( RBRACE )
# 2653 "scanner.ml"

  | 27 ->
# 118 "scanner.mll"
                               ( SEMI )
# 2658 "scanner.ml"

  | 28 ->
# 119 "scanner.mll"
                               ( COMMA )
# 2663 "scanner.ml"

  | 29 ->
# 122 "scanner.mll"
                               ( PLUS )
# 2668 "scanner.ml"

  | 30 ->
# 123 "scanner.mll"
                               ( MINUS )
# 2673 "scanner.ml"

  | 31 ->
# 124 "scanner.mll"
                               ( TIMES )
# 2678 "scanner.ml"

  | 32 ->
# 125 "scanner.mll"
                               ( DIVIDE )
# 2683 "scanner.ml"

  | 33 ->
# 126 "scanner.mll"
                               ( MOD )
# 2688 "scanner.ml"

  | 34 ->
# 127 "scanner.mll"
                               ( POWER )
# 2693 "scanner.ml"

  | 35 ->
# 130 "scanner.mll"
                               ( PLUSA )
# 2698 "scanner.ml"

  | 36 ->
# 131 "scanner.mll"
                               ( MINUSA )
# 2703 "scanner.ml"

  | 37 ->
# 132 "scanner.mll"
                               ( TIMESA )
# 2708 "scanner.ml"

  | 38 ->
# 133 "scanner.mll"
                               ( DIVIDEA )
# 2713 "scanner.ml"

  | 39 ->
# 134 "scanner.mll"
                               ( MODA )
# 2718 "scanner.ml"

  | 40 ->
# 135 "scanner.mll"
                               ( POWERA )
# 2723 "scanner.ml"

  | 41 ->
# 138 "scanner.mll"
                               ( IF )
# 2728 "scanner.ml"

  | 42 ->
# 139 "scanner.mll"
                               ( ELSE )
# 2733 "scanner.ml"

  | 43 ->
# 140 "scanner.mll"
                               ( ELSIF )
# 2738 "scanner.ml"

  | 44 ->
# 141 "scanner.mll"
                               ( WHILE )
# 2743 "scanner.ml"

  | 45 ->
# 142 "scanner.mll"
                               ( RETURN )
# 2748 "scanner.ml"

  | 46 ->
# 145 "scanner.mll"
                               ( CLASS )
# 2753 "scanner.ml"

  | 47 ->
# 146 "scanner.mll"
                               ( EXTEND )
# 2758 "scanner.ml"

  | 48 ->
# 147 "scanner.mll"
                               ( SUPER )
# 2763 "scanner.ml"

  | 49 ->
# 148 "scanner.mll"
                               ( INIT )
# 2768 "scanner.ml"

  | 50 ->
# 151 "scanner.mll"
                               ( NULL )
# 2773 "scanner.ml"

  | 51 ->
# 152 "scanner.mll"
                               ( VOID )
# 2778 "scanner.ml"

  | 52 ->
# 153 "scanner.mll"
                               ( THIS )
# 2783 "scanner.ml"

  | 53 ->
# 156 "scanner.mll"
                               ( REFINE )
# 2788 "scanner.ml"

  | 54 ->
# 157 "scanner.mll"
                               ( REFINES )
# 2793 "scanner.ml"

  | 55 ->
# 158 "scanner.mll"
                               ( TO )
# 2798 "scanner.ml"

  | 56 ->
# 161 "scanner.mll"
                               ( PRIVATE )
# 2803 "scanner.ml"

  | 57 ->
# 162 "scanner.mll"
                               ( PUBLIC )
# 2808 "scanner.ml"

  | 58 ->
# 163 "scanner.mll"
                               ( PROTECTED )
# 2813 "scanner.ml"

  | 59 ->
# 166 "scanner.mll"
                               ( DOT )
# 2818 "scanner.ml"

  | 60 ->
# 167 "scanner.mll"
                               ( MAIN )
# 2823 "scanner.ml"

  | 61 ->
# 168 "scanner.mll"
                               ( NEW )
# 2828 "scanner.ml"

  | 62 ->
# 169 "scanner.mll"
                               ( ASSIGN )
# 2833 "scanner.ml"

  | 63 ->
let
# 172 "scanner.mll"
                             vid
# 2839 "scanner.ml"
Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
# 172 "scanner.mll"
                                    ( ID(vid) )
# 2843 "scanner.ml"

  | 64 ->
let
# 173 "scanner.mll"
                        tid
# 2849 "scanner.ml"
Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
# 173 "scanner.mll"
                                    ( TYPE(tid) )
# 2853 "scanner.ml"

  | 65 ->
let
# 176 "scanner.mll"
              inum
# 2859 "scanner.ml"
Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
# 176 "scanner.mll"
                               ( ILIT(int_of_string inum) )
# 2863 "scanner.ml"

  | 66 ->
let
# 177 "scanner.mll"
                         fnum
# 2869 "scanner.ml"
Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
# 177 "scanner.mll"
                               ( FLIT(float_of_string fnum) )
# 2873 "scanner.ml"

  | 67 ->
# 178 "scanner.mll"
                               ( stringlit [] lexbuf )
# 2878 "scanner.ml"

  | 68 ->
# 181 "scanner.mll"
                               ( EOF )
# 2883 "scanner.ml"

  | 69 ->
let
# 182 "scanner.mll"
         char
# 2889 "scanner.ml"
Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in
# 182 "scanner.mll"
              ( lexfail("Illegal character " ^ Char.escaped char) )
# 2893 "scanner.ml"

  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_token_rec lexbuf __ocaml_lex_state

and comment level lexbuf =
    __ocaml_lex_comment_rec level lexbuf 157
and __ocaml_lex_comment_rec level lexbuf __ocaml_lex_state =
  match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with
      | 0 ->
# 186 "scanner.mll"
                  ( comment (level+1) lexbuf )
# 2904 "scanner.ml"

  | 1 ->
# 187 "scanner.mll"
                  ( if level = 0 then token lexbuf else comment (level-1) lexbuf )
# 2909 "scanner.ml"

  | 2 ->
# 188 "scanner.mll"
                  ( lexfail("File ended inside comment.") )
# 2914 "scanner.ml"

  | 3 ->
let
# 189 "scanner.mll"
               v
# 2920 "scanner.ml"
Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
# 189 "scanner.mll"
                  ( count_lines v; comment level lexbuf )
# 2924 "scanner.ml"

  | 4 ->
# 190 "scanner.mll"
                  ( comment level lexbuf )
# 2929 "scanner.ml"

  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_comment_rec level lexbuf __ocaml_lex_state

and stringlit chars lexbuf =
    __ocaml_lex_stringlit_rec chars lexbuf 165
and __ocaml_lex_stringlit_rec chars lexbuf __ocaml_lex_state =
  match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with
      | 0 ->
# 194 "scanner.mll"
                   ( escapechar chars lexbuf )
# 2940 "scanner.ml"

  | 1 ->
# 195 "scanner.mll"
                   ( lexfail("File ended inside string literal") )
# 2945 "scanner.ml"

  | 2 ->
let
# 196 "scanner.mll"
              char
# 2951 "scanner.ml"
Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in
# 196 "scanner.mll"
                   ( lexfail("Line ended inside string literal (" ^ Char.escaped char ^ " used): " ^ implode(List.rev chars)) )
# 2955 "scanner.ml"

  | 3 ->
# 197 "scanner.mll"
                   ( SLIT(implode(List.rev chars)) )
# 2960 "scanner.ml"

  | 4 ->
let
# 198 "scanner.mll"
         char
# 2966 "scanner.ml"
Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in
# 198 "scanner.mll"
                   ( stringlit (char::chars) lexbuf )
# 2970 "scanner.ml"

  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_stringlit_rec chars lexbuf __ocaml_lex_state

and escapechar chars lexbuf =
    __ocaml_lex_escapechar_rec chars lexbuf 171
and __ocaml_lex_escapechar_rec chars lexbuf __ocaml_lex_state =
  match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with
      | 0 ->
let
# 202 "scanner.mll"
                                                  char
# 2982 "scanner.ml"
Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in
# 202 "scanner.mll"
                                                       (
      stringlit (char :: '\\' :: chars) lexbuf
    )
# 2988 "scanner.ml"

  | 1 ->
# 205 "scanner.mll"
              ( lexfail("File ended while seeking escape character") )
# 2993 "scanner.ml"

  | 2 ->
let
# 206 "scanner.mll"
         char
# 2999 "scanner.ml"
Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in
# 206 "scanner.mll"
              ( lexfail("Illegal escape character:  \\" ^ Char.escaped(char)) )
# 3003 "scanner.ml"

  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_escapechar_rec chars lexbuf __ocaml_lex_state