let rec token lexbuf =
    __ocaml_lex_token_rec lexbuf 0
and __ocaml_lex_token_rec lexbuf __ocaml_lex_state =
  match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with
      | 0 ->
# 175 "cfLexer.mll"
                  ( buildInteger (CfParserUtil.next_lex lexbuf) )
# 2247 "cfLexer.ml"

  | 1 ->
# 176 "cfLexer.mll"
                  ( buildChar    (CfParserUtil.next_lex lexbuf) )
# 2252 "cfLexer.ml"

  | 2 ->
# 177 "cfLexer.mll"
                  ( buildFloat   (CfParserUtil.next_lex lexbuf) )
# 2257 "cfLexer.ml"

  | 3 ->
# 178 "cfLexer.mll"
                  ( CfParser.STRING                   (CfParserUtil.next_lex lexbuf) )
# 2262 "cfLexer.ml"

  | 4 ->
# 179 "cfLexer.mll"
                  ( buildVector  (CfParserUtil.next_lex lexbuf) )
# 2267 "cfLexer.ml"

  | 5 ->
# 180 "cfLexer.mll"
                  ( buildBoolean (CfParserUtil.next_lex lexbuf) )
# 2272 "cfLexer.ml"

  | 6 ->
# 181 "cfLexer.mll"
                  ( buildBoolean (CfParserUtil.next_lex lexbuf) )
# 2277 "cfLexer.ml"

  | 7 ->
# 182 "cfLexer.mll"
                  ( CfParser.FREE                     (CfParserUtil.next_lex lexbuf) )
# 2282 "cfLexer.ml"

  | 8 ->
# 183 "cfLexer.mll"
                  ( CfParser.END                      (CfParserUtil.next_lex lexbuf) )
# 2287 "cfLexer.ml"

  | 9 ->
# 184 "cfLexer.mll"
                  ( CfParser.COMPONENT                (CfParserUtil.next_lex lexbuf) )
# 2292 "cfLexer.ml"

  | 10 ->
# 185 "cfLexer.mll"
                  ( CfParser.COMP                     (CfParserUtil.next_lex lexbuf) )
# 2297 "cfLexer.ml"

  | 11 ->
# 186 "cfLexer.mll"
                  ( CfParser.PRIM                     (CfParserUtil.next_lex lexbuf) )
# 2302 "cfLexer.ml"

  | 12 ->
# 187 "cfLexer.mll"
                  ( CfParser.IF                       (CfParserUtil.next_lex lexbuf) )
# 2307 "cfLexer.ml"

  | 13 ->
# 188 "cfLexer.mll"
                  ( CfParser.EF                       (CfParserUtil.next_lex lexbuf) )
# 2312 "cfLexer.ml"

  | 14 ->
# 189 "cfLexer.mll"
                  ( CfParser.ELSE                     (CfParserUtil.next_lex lexbuf) )
# 2317 "cfLexer.ml"

  | 15 ->
# 190 "cfLexer.mll"
                  ( CfParser.WITH                     (CfParserUtil.next_lex lexbuf) )
# 2322 "cfLexer.ml"

  | 16 ->
# 191 "cfLexer.mll"
                  ( CfParser.IS                       (CfParserUtil.next_lex lexbuf) )
# 2327 "cfLexer.ml"

  | 17 ->
# 192 "cfLexer.mll"
                  ( CfParser.LOCAL                    (CfParserUtil.next_lex lexbuf) )
# 2332 "cfLexer.ml"

  | 18 ->
# 193 "cfLexer.mll"
                  ( CfParser.IMPORT                   (CfParserUtil.next_lex lexbuf) )
# 2337 "cfLexer.ml"

  | 19 ->
# 194 "cfLexer.mll"
                  ( CfParser.ENVIRONMENT              (CfParserUtil.next_lex lexbuf) )
# 2342 "cfLexer.ml"

  | 20 ->
# 195 "cfLexer.mll"
                      ( CfParser.ROOTENVIRONMENT      (CfParserUtil.next_lex lexbuf) )
# 2347 "cfLexer.ml"

  | 21 ->
# 196 "cfLexer.mll"
                  ( let (l, _) = CfParserUtil.next_lex lexbuf in CfParser.STRING (l, "\"" ^ Loc.toString l ^ "\"") )
# 2352 "cfLexer.ml"

  | 22 ->
# 197 "cfLexer.mll"
                  ( CfParser.BRACE_LEFT               (CfParserUtil.next_lex lexbuf) )
# 2357 "cfLexer.ml"

  | 23 ->
# 198 "cfLexer.mll"
                  ( CfParser.BRACE_RIGHT              (CfParserUtil.next_lex lexbuf) )
# 2362 "cfLexer.ml"

  | 24 ->
# 199 "cfLexer.mll"
                  ( CfParser.PAREN_LEFT               (CfParserUtil.next_lex lexbuf) )
# 2367 "cfLexer.ml"

  | 25 ->
# 200 "cfLexer.mll"
                  ( CfParser.PAREN_RIGHT              (CfParserUtil.next_lex lexbuf) )
# 2372 "cfLexer.ml"

  | 26 ->
# 201 "cfLexer.mll"
                  ( CfParser.BRACKET_LEFT             (CfParserUtil.next_lex lexbuf) )
# 2377 "cfLexer.ml"

  | 27 ->
# 202 "cfLexer.mll"
                  ( CfParser.BRACKET_RIGHT            (CfParserUtil.next_lex lexbuf) )
# 2382 "cfLexer.ml"

  | 28 ->
# 203 "cfLexer.mll"
                  ( CfParser.DOLLAR                   (CfParserUtil.next_lex lexbuf) )
# 2387 "cfLexer.ml"

  | 29 ->
# 204 "cfLexer.mll"
                  ( CfParser.COLON                    (CfParserUtil.next_lex lexbuf) )
# 2392 "cfLexer.ml"

  | 30 ->
# 205 "cfLexer.mll"
                  ( CfParser.EOF                      (CfParserUtil.next_lex lexbuf) )
# 2397 "cfLexer.ml"

  | 31 ->
# 206 "cfLexer.mll"
                  ( let _ = CfParserUtil.next_lex lexbuf in incr commentDepth; comment lexbuf; token lexbuf )
# 2402 "cfLexer.ml"

  | 32 ->
# 207 "cfLexer.mll"
                  ( let _ = CfParserUtil.next_lex lexbuf in token lexbuf )
# 2407 "cfLexer.ml"

  | 33 ->
# 209 "cfLexer.mll"
              ( CfParser.OP_DOT                       (CfParserUtil.next_lex lexbuf) )
# 2412 "cfLexer.ml"

  | 34 ->
# 210 "cfLexer.mll"
              ( CfParser.OP_VEC_SELECT                (CfParserUtil.next_lex lexbuf) )
# 2417 "cfLexer.ml"

  | 35 ->
# 211 "cfLexer.mll"
              ( CfParser.OP_NOT                       (CfParserUtil.next_lex lexbuf) )
# 2422 "cfLexer.ml"

  | 36 ->
# 212 "cfLexer.mll"
              ( CfParser.OP_BW_NOT                    (CfParserUtil.next_lex lexbuf) )
# 2427 "cfLexer.ml"

  | 37 ->
# 213 "cfLexer.mll"
              ( CfParser.OP_HEAD                      (CfParserUtil.next_lex lexbuf) )
# 2432 "cfLexer.ml"

  | 38 ->
# 214 "cfLexer.mll"
              ( CfParser.OP_TAIL                      (CfParserUtil.next_lex lexbuf) )
# 2437 "cfLexer.ml"

  | 39 ->
# 215 "cfLexer.mll"
              ( CfParser.OP_LENGTH                    (CfParserUtil.next_lex lexbuf) )
# 2442 "cfLexer.ml"

  | 40 ->
# 216 "cfLexer.mll"
              ( CfParser.OP_WIDTH                     (CfParserUtil.next_lex lexbuf) )
# 2447 "cfLexer.ml"

  | 41 ->
# 217 "cfLexer.mll"
              ( CfParser.OP_VEC_NOT                   (CfParserUtil.next_lex lexbuf) )
# 2452 "cfLexer.ml"

  | 42 ->
# 218 "cfLexer.mll"
              ( CfParser.OP_VEC_MSB                   (CfParserUtil.next_lex lexbuf) )
# 2457 "cfLexer.ml"

  | 43 ->
# 219 "cfLexer.mll"
              ( CfParser.OP_VEC_MSBS                  (CfParserUtil.next_lex lexbuf) )
# 2462 "cfLexer.ml"

  | 44 ->
# 220 "cfLexer.mll"
              ( CfParser.OP_VEC_LSB                   (CfParserUtil.next_lex lexbuf) )
# 2467 "cfLexer.ml"

  | 45 ->
# 221 "cfLexer.mll"
              ( CfParser.OP_VEC_LSBS                  (CfParserUtil.next_lex lexbuf) )
# 2472 "cfLexer.ml"

  | 46 ->
# 222 "cfLexer.mll"
              ( CfParser.OP_PROP_NOT                  (CfParserUtil.next_lex lexbuf) )
# 2477 "cfLexer.ml"

  | 47 ->
# 223 "cfLexer.mll"
              ( CfParser.OP_PROP_X                    (CfParserUtil.next_lex lexbuf) )
# 2482 "cfLexer.ml"

  | 48 ->
# 224 "cfLexer.mll"
              ( CfParser.OP_POW                       (CfParserUtil.next_lex lexbuf) )
# 2487 "cfLexer.ml"

  | 49 ->
# 225 "cfLexer.mll"
              ( CfParser.OP_VEC_POW                   (CfParserUtil.next_lex lexbuf) )
# 2492 "cfLexer.ml"

  | 50 ->
# 226 "cfLexer.mll"
              ( CfParser.OP_MUL                       (CfParserUtil.next_lex lexbuf) )
# 2497 "cfLexer.ml"

  | 51 ->
# 227 "cfLexer.mll"
              ( CfParser.OP_DIV                       (CfParserUtil.next_lex lexbuf) )
# 2502 "cfLexer.ml"

  | 52 ->
# 228 "cfLexer.mll"
              ( CfParser.OP_MOD                       (CfParserUtil.next_lex lexbuf) )
# 2507 "cfLexer.ml"

  | 53 ->
# 229 "cfLexer.mll"
              ( CfParser.OP_VEC_MUL                   (CfParserUtil.next_lex lexbuf) )
# 2512 "cfLexer.ml"

  | 54 ->
# 230 "cfLexer.mll"
              ( CfParser.OP_VEC_DIV                   (CfParserUtil.next_lex lexbuf) )
# 2517 "cfLexer.ml"

  | 55 ->
# 231 "cfLexer.mll"
              ( CfParser.OP_VEC_MOD                   (CfParserUtil.next_lex lexbuf) )
# 2522 "cfLexer.ml"

  | 56 ->
# 232 "cfLexer.mll"
              ( CfParser.OP_VEC_MUL_S                 (CfParserUtil.next_lex lexbuf) )
# 2527 "cfLexer.ml"

  | 57 ->
# 233 "cfLexer.mll"
              ( CfParser.OP_ADD                       (CfParserUtil.next_lex lexbuf) )
# 2532 "cfLexer.ml"

  | 58 ->
# 234 "cfLexer.mll"
              ( CfParser.OP_SUB                       (CfParserUtil.next_lex lexbuf) )
# 2537 "cfLexer.ml"

  | 59 ->
# 235 "cfLexer.mll"
              ( CfParser.OP_VEC_ADD                   (CfParserUtil.next_lex lexbuf) )
# 2542 "cfLexer.ml"

  | 60 ->
# 236 "cfLexer.mll"
              ( CfParser.OP_VEC_SUB                   (CfParserUtil.next_lex lexbuf) )
# 2547 "cfLexer.ml"

  | 61 ->
# 237 "cfLexer.mll"
              ( CfParser.OP_LSHIFT                    (CfParserUtil.next_lex lexbuf) )
# 2552 "cfLexer.ml"

  | 62 ->
# 238 "cfLexer.mll"
              ( CfParser.OP_RSHIFT                    (CfParserUtil.next_lex lexbuf) )
# 2557 "cfLexer.ml"

  | 63 ->
# 239 "cfLexer.mll"
              ( CfParser.OP_VEC_LSHIFT                (CfParserUtil.next_lex lexbuf) )
# 2562 "cfLexer.ml"

  | 64 ->
# 240 "cfLexer.mll"
              ( CfParser.OP_VEC_RSHIFT                (CfParserUtil.next_lex lexbuf) )
# 2567 "cfLexer.ml"

  | 65 ->
# 241 "cfLexer.mll"
              ( CfParser.OP_VEC_RSHIFT_S              (CfParserUtil.next_lex lexbuf) )
# 2572 "cfLexer.ml"

  | 66 ->
# 242 "cfLexer.mll"
              ( CfParser.OP_LT                        (CfParserUtil.next_lex lexbuf) )
# 2577 "cfLexer.ml"

  | 67 ->
# 243 "cfLexer.mll"
              ( CfParser.OP_GT                        (CfParserUtil.next_lex lexbuf) )
# 2582 "cfLexer.ml"

  | 68 ->
# 244 "cfLexer.mll"
              ( CfParser.OP_LE                        (CfParserUtil.next_lex lexbuf) )
# 2587 "cfLexer.ml"

  | 69 ->
# 245 "cfLexer.mll"
              ( CfParser.OP_GE                        (CfParserUtil.next_lex lexbuf) )
# 2592 "cfLexer.ml"

  | 70 ->
# 246 "cfLexer.mll"
              ( CfParser.OP_VEC_LT                    (CfParserUtil.next_lex lexbuf) )
# 2597 "cfLexer.ml"

  | 71 ->
# 247 "cfLexer.mll"
              ( CfParser.OP_VEC_GT                    (CfParserUtil.next_lex lexbuf) )
# 2602 "cfLexer.ml"

  | 72 ->
# 248 "cfLexer.mll"
              ( CfParser.OP_VEC_LE                    (CfParserUtil.next_lex lexbuf) )
# 2607 "cfLexer.ml"

  | 73 ->
# 249 "cfLexer.mll"
              ( CfParser.OP_VEC_GE                    (CfParserUtil.next_lex lexbuf) )
# 2612 "cfLexer.ml"

  | 74 ->
# 250 "cfLexer.mll"
              ( CfParser.OP_VEC_LT_S                  (CfParserUtil.next_lex lexbuf) )
# 2617 "cfLexer.ml"

  | 75 ->
# 251 "cfLexer.mll"
              ( CfParser.OP_VEC_GT_S                  (CfParserUtil.next_lex lexbuf) )
# 2622 "cfLexer.ml"

  | 76 ->
# 252 "cfLexer.mll"
              ( CfParser.OP_VEC_LE_S                  (CfParserUtil.next_lex lexbuf) )
# 2627 "cfLexer.ml"

  | 77 ->
# 253 "cfLexer.mll"
              ( CfParser.OP_VEC_GE_S                  (CfParserUtil.next_lex lexbuf) )
# 2632 "cfLexer.ml"

  | 78 ->
# 254 "cfLexer.mll"
              ( CfParser.OP_REPEAT                    (CfParserUtil.next_lex lexbuf) )
# 2637 "cfLexer.ml"

  | 79 ->
# 255 "cfLexer.mll"
              ( CfParser.OP_VEC_REPEAT                (CfParserUtil.next_lex lexbuf) )
# 2642 "cfLexer.ml"

  | 80 ->
# 256 "cfLexer.mll"
              ( CfParser.OP_CONS                      (CfParserUtil.next_lex lexbuf) )
# 2647 "cfLexer.ml"

  | 81 ->
# 257 "cfLexer.mll"
              ( CfParser.OP_CONCAT                    (CfParserUtil.next_lex lexbuf) )
# 2652 "cfLexer.ml"

  | 82 ->
# 258 "cfLexer.mll"
              ( CfParser.OP_VEC_CONCAT                (CfParserUtil.next_lex lexbuf) )
# 2657 "cfLexer.ml"

  | 83 ->
# 259 "cfLexer.mll"
              ( CfParser.OP_RETURN                    (CfParserUtil.next_lex lexbuf) )
# 2662 "cfLexer.ml"

  | 84 ->
# 260 "cfLexer.mll"
              ( CfParser.OP_EQU                       (CfParserUtil.next_lex lexbuf) )
# 2667 "cfLexer.ml"

  | 85 ->
# 261 "cfLexer.mll"
              ( CfParser.OP_NEQ                       (CfParserUtil.next_lex lexbuf) )
# 2672 "cfLexer.ml"

  | 86 ->
# 262 "cfLexer.mll"
              ( CfParser.OP_VEC_EQU                   (CfParserUtil.next_lex lexbuf) )
# 2677 "cfLexer.ml"

  | 87 ->
# 263 "cfLexer.mll"
              ( CfParser.OP_VEC_NEQ                   (CfParserUtil.next_lex lexbuf) )
# 2682 "cfLexer.ml"

  | 88 ->
# 264 "cfLexer.mll"
              ( CfParser.OP_BW_AND                    (CfParserUtil.next_lex lexbuf) )
# 2687 "cfLexer.ml"

  | 89 ->
# 265 "cfLexer.mll"
              ( CfParser.OP_VEC_AND                   (CfParserUtil.next_lex lexbuf) )
# 2692 "cfLexer.ml"

  | 90 ->
# 266 "cfLexer.mll"
              ( CfParser.OP_BW_XOR                    (CfParserUtil.next_lex lexbuf) )
# 2697 "cfLexer.ml"

  | 91 ->
# 267 "cfLexer.mll"
              ( CfParser.OP_VEC_XOR                   (CfParserUtil.next_lex lexbuf) )
# 2702 "cfLexer.ml"

  | 92 ->
# 268 "cfLexer.mll"
              ( CfParser.OP_BW_OR                     (CfParserUtil.next_lex lexbuf) )
# 2707 "cfLexer.ml"

  | 93 ->
# 269 "cfLexer.mll"
              ( CfParser.OP_VEC_OR                    (CfParserUtil.next_lex lexbuf) )
# 2712 "cfLexer.ml"

  | 94 ->
# 270 "cfLexer.mll"
              ( CfParser.OP_AND                       (CfParserUtil.next_lex lexbuf) )
# 2717 "cfLexer.ml"

  | 95 ->
# 271 "cfLexer.mll"
              ( CfParser.OP_OR                        (CfParserUtil.next_lex lexbuf) )
# 2722 "cfLexer.ml"

  | 96 ->
# 272 "cfLexer.mll"
              ( CfParser.OP_PROP_AND                  (CfParserUtil.next_lex lexbuf) )
# 2727 "cfLexer.ml"

  | 97 ->
# 273 "cfLexer.mll"
              ( CfParser.OP_PROP_XOR                  (CfParserUtil.next_lex lexbuf) )
# 2732 "cfLexer.ml"

  | 98 ->
# 274 "cfLexer.mll"
              ( CfParser.OP_PROP_OR                   (CfParserUtil.next_lex lexbuf) )
# 2737 "cfLexer.ml"

  | 99 ->
# 275 "cfLexer.mll"
              ( CfParser.OP_PROP_EQUIV                (CfParserUtil.next_lex lexbuf) )
# 2742 "cfLexer.ml"

  | 100 ->
# 276 "cfLexer.mll"
              ( CfParser.OP_PROP_IMPLY                (CfParserUtil.next_lex lexbuf) )
# 2747 "cfLexer.ml"

  | 101 ->
# 277 "cfLexer.mll"
              ( CfParser.OP_PROP_U                    (CfParserUtil.next_lex lexbuf) )
# 2752 "cfLexer.ml"

  | 102 ->
# 278 "cfLexer.mll"
              ( CfParser.OP_THEN                      (CfParserUtil.next_lex lexbuf) )
# 2757 "cfLexer.ml"

  | 103 ->
# 279 "cfLexer.mll"
              ( CfParser.OP_VEC_THEN                  (CfParserUtil.next_lex lexbuf) )
# 2762 "cfLexer.ml"

  | 104 ->
# 280 "cfLexer.mll"
              ( CfParser.OP_VEC_ELSE                  (CfParserUtil.next_lex lexbuf) )
# 2767 "cfLexer.ml"

  | 105 ->
# 281 "cfLexer.mll"
              ( CfParser.OP_CONNECT_LEFT              (CfParserUtil.next_lex lexbuf) )
# 2772 "cfLexer.ml"

  | 106 ->
# 282 "cfLexer.mll"
              ( CfParser.OP_CONNECT_RIGHT             (CfParserUtil.next_lex lexbuf) )
# 2777 "cfLexer.ml"

  | 107 ->
# 283 "cfLexer.mll"
              ( CfParser.OP_UNIFY                     (CfParserUtil.next_lex lexbuf) )
# 2782 "cfLexer.ml"

  | 108 ->
# 285 "cfLexer.mll"
                  ( CfParser.IDENTIFIER               (CfParserUtil.next_lex lexbuf) )
# 2787 "cfLexer.ml"

  | 109 ->
# 287 "cfLexer.mll"
              ( CfParserUtil.error ("Unrecognized character: '" ^ (snd (CfParserUtil.next_lex lexbuf)) ^ "'");
                CfParser.LexerError (CfParserUtil.next_lex lexbuf) )
# 2793 "cfLexer.ml"

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

and comment lexbuf =
    __ocaml_lex_comment_rec lexbuf 409
and __ocaml_lex_comment_rec lexbuf __ocaml_lex_state =
  match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with
      | 0 ->
# 291 "cfLexer.mll"
            ( let _ = CfParserUtil.next_lex lexbuf in incr commentDepth; comment lexbuf )
# 2804 "cfLexer.ml"

  | 1 ->
# 292 "cfLexer.mll"
            ( let _ = CfParserUtil.next_lex lexbuf in decr commentDepth; if !commentDepth <> 0 then comment lexbuf else () )
# 2809 "cfLexer.ml"

  | 2 ->
# 293 "cfLexer.mll"
            ( let _ = CfParserUtil.next_lex lexbuf in comment lexbuf )
# 2814 "cfLexer.ml"

  | 3 ->
# 294 "cfLexer.mll"
            ( CfParserUtil.error ("End of file without closing comment.") )
# 2819 "cfLexer.ml"

  | 4 ->
# 295 "cfLexer.mll"
            ( let _ = CfParserUtil.next_lex lexbuf in comment lexbuf )
# 2824 "cfLexer.ml"

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