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 ->
# 57 "psl_lexer.mll"
                         ( Psl_parser.Brackl              (Parser_util.next_lex lexbuf) )
# 5541 "psl_lexer.ml"

  | 1 ->
# 58 "psl_lexer.mll"
                         ( Psl_parser.Brackr              (Parser_util.next_lex lexbuf) )
# 5546 "psl_lexer.ml"

  | 2 ->
# 59 "psl_lexer.mll"
                         ( Psl_parser.Parenl              (Parser_util.next_lex lexbuf) )
# 5551 "psl_lexer.ml"

  | 3 ->
# 60 "psl_lexer.mll"
                         ( Psl_parser.Parenr              (Parser_util.next_lex lexbuf) )
# 5556 "psl_lexer.ml"

  | 4 ->
# 61 "psl_lexer.mll"
                         ( Psl_parser.Bracel              (Parser_util.next_lex lexbuf) )
# 5561 "psl_lexer.ml"

  | 5 ->
# 62 "psl_lexer.mll"
                         ( Psl_parser.Bracer              (Parser_util.next_lex lexbuf) )
# 5566 "psl_lexer.ml"

  | 6 ->
# 63 "psl_lexer.mll"
                         ( Psl_parser.Comma               (Parser_util.next_lex lexbuf) )
# 5571 "psl_lexer.ml"

  | 7 ->
# 64 "psl_lexer.mll"
                         ( Psl_parser.Semicolon           (Parser_util.next_lex lexbuf) )
# 5576 "psl_lexer.ml"

  | 8 ->
# 65 "psl_lexer.mll"
                         ( Psl_parser.Colon               (Parser_util.next_lex lexbuf) )
# 5581 "psl_lexer.ml"

  | 9 ->
# 66 "psl_lexer.mll"
                         ( Psl_parser.Period_period       (Parser_util.next_lex lexbuf) )
# 5586 "psl_lexer.ml"

  | 10 ->
# 67 "psl_lexer.mll"
                         ( Psl_parser.Equal               (Parser_util.next_lex lexbuf) )
# 5591 "psl_lexer.ml"

  | 11 ->
# 68 "psl_lexer.mll"
                         ( Psl_parser.Colon_equal         (Parser_util.next_lex lexbuf) )
# 5596 "psl_lexer.ml"

  | 12 ->
# 69 "psl_lexer.mll"
                         ( Psl_parser.Aster               (Parser_util.next_lex lexbuf) )
# 5601 "psl_lexer.ml"

  | 13 ->
# 70 "psl_lexer.mll"
                         ( Psl_parser.Plus                (Parser_util.next_lex lexbuf) )
# 5606 "psl_lexer.ml"

  | 14 ->
# 71 "psl_lexer.mll"
                         ( Psl_parser.Bar_dash_gt         (Parser_util.next_lex lexbuf) )
# 5611 "psl_lexer.ml"

  | 15 ->
# 72 "psl_lexer.mll"
                         ( Psl_parser.Bar_equal_gt        (Parser_util.next_lex lexbuf) )
# 5616 "psl_lexer.ml"

  | 16 ->
# 73 "psl_lexer.mll"
                         ( Psl_parser.Lt_dash_gt          (Parser_util.next_lex lexbuf) )
# 5621 "psl_lexer.ml"

  | 17 ->
# 74 "psl_lexer.mll"
                         ( Psl_parser.Dash_gt             (Parser_util.next_lex lexbuf) )
# 5626 "psl_lexer.ml"

  | 18 ->
# 75 "psl_lexer.mll"
                         ( Psl_parser.Brackl_aster        (Parser_util.next_lex lexbuf) )
# 5631 "psl_lexer.ml"

  | 19 ->
# 76 "psl_lexer.mll"
                         ( Psl_parser.Brackl_plus_brackr  (Parser_util.next_lex lexbuf) )
# 5636 "psl_lexer.ml"

  | 20 ->
# 77 "psl_lexer.mll"
                         ( Psl_parser.Brackl_dash_gt      (Parser_util.next_lex lexbuf) )
# 5641 "psl_lexer.ml"

  | 21 ->
# 78 "psl_lexer.mll"
                         ( Psl_parser.Brackl_equal        (Parser_util.next_lex lexbuf) )
# 5646 "psl_lexer.ml"

  | 22 ->
# 79 "psl_lexer.mll"
                         ( Psl_parser.Amp_amp             (Parser_util.next_lex lexbuf) )
# 5651 "psl_lexer.ml"

  | 23 ->
# 80 "psl_lexer.mll"
                         ( Psl_parser.Amp                 (Parser_util.next_lex lexbuf) )
# 5656 "psl_lexer.ml"

  | 24 ->
# 81 "psl_lexer.mll"
                         ( Psl_parser.Bar_bar             (Parser_util.next_lex lexbuf) )
# 5661 "psl_lexer.ml"

  | 25 ->
# 82 "psl_lexer.mll"
                         ( Psl_parser.Bar                 (Parser_util.next_lex lexbuf) )
# 5666 "psl_lexer.ml"

  | 26 ->
# 83 "psl_lexer.mll"
                         ( Psl_parser.Bang                (Parser_util.next_lex lexbuf) )
# 5671 "psl_lexer.ml"

  | 27 ->
# 84 "psl_lexer.mll"
                         ( Psl_parser.Dollar              (Parser_util.next_lex lexbuf) )
# 5676 "psl_lexer.ml"

  | 28 ->
# 85 "psl_lexer.mll"
                         ( Psl_parser.At                  (Parser_util.next_lex lexbuf) )
# 5681 "psl_lexer.ml"

  | 29 ->
# 86 "psl_lexer.mll"
                         ( Psl_parser.Period              (Parser_util.next_lex lexbuf) )
# 5686 "psl_lexer.ml"

  | 30 ->
# 87 "psl_lexer.mll"
                         ( Psl_parser.Slash               (Parser_util.next_lex lexbuf) )
# 5691 "psl_lexer.ml"

  | 31 ->
# 88 "psl_lexer.mll"
                         ( Psl_parser.A                   (Parser_util.next_lex lexbuf) )
# 5696 "psl_lexer.ml"

  | 32 ->
# 89 "psl_lexer.mll"
                         ( Psl_parser.AG                  (Parser_util.next_lex lexbuf) )
# 5701 "psl_lexer.ml"

  | 33 ->
# 90 "psl_lexer.mll"
                         ( Psl_parser.AF                  (Parser_util.next_lex lexbuf) )
# 5706 "psl_lexer.ml"

  | 34 ->
# 91 "psl_lexer.mll"
                         ( Psl_parser.AX                  (Parser_util.next_lex lexbuf) )
# 5711 "psl_lexer.ml"

  | 35 ->
# 92 "psl_lexer.mll"
                         ( Psl_parser.Abort               (Parser_util.next_lex lexbuf) )
# 5716 "psl_lexer.ml"

  | 36 ->
# 93 "psl_lexer.mll"
                         ( Psl_parser.Always              (Parser_util.next_lex lexbuf) )
# 5721 "psl_lexer.ml"

  | 37 ->
# 94 "psl_lexer.mll"
                         ( Psl_parser.Assert              (Parser_util.next_lex lexbuf) )
# 5726 "psl_lexer.ml"

  | 38 ->
# 95 "psl_lexer.mll"
                         ( Psl_parser.Assume              (Parser_util.next_lex lexbuf) )
# 5731 "psl_lexer.ml"

  | 39 ->
# 96 "psl_lexer.mll"
                         ( Psl_parser.Assume_guarantee    (Parser_util.next_lex lexbuf) )
# 5736 "psl_lexer.ml"

  | 40 ->
# 97 "psl_lexer.mll"
                         ( Psl_parser.Before              (Parser_util.next_lex lexbuf) )
# 5741 "psl_lexer.ml"

  | 41 ->
# 98 "psl_lexer.mll"
                         ( Psl_parser.Before_bang         (Parser_util.next_lex lexbuf) )
# 5746 "psl_lexer.ml"

  | 42 ->
# 99 "psl_lexer.mll"
                         ( Psl_parser.Before_bang_        (Parser_util.next_lex lexbuf) )
# 5751 "psl_lexer.ml"

  | 43 ->
# 100 "psl_lexer.mll"
                         ( Psl_parser.Before_             (Parser_util.next_lex lexbuf) )
# 5756 "psl_lexer.ml"

  | 44 ->
# 101 "psl_lexer.mll"
                         ( Psl_parser.Boolean             (Parser_util.next_lex lexbuf) )
# 5761 "psl_lexer.ml"

  | 45 ->
# 102 "psl_lexer.mll"
                         ( Psl_parser.Clock               (Parser_util.next_lex lexbuf) )
# 5766 "psl_lexer.ml"

  | 46 ->
# 103 "psl_lexer.mll"
                         ( Psl_parser.Const               (Parser_util.next_lex lexbuf) )
# 5771 "psl_lexer.ml"

  | 47 ->
# 104 "psl_lexer.mll"
                         ( Psl_parser.Countones           (Parser_util.next_lex lexbuf) )
# 5776 "psl_lexer.ml"

  | 48 ->
# 105 "psl_lexer.mll"
                         ( Psl_parser.Cover               (Parser_util.next_lex lexbuf) )
# 5781 "psl_lexer.ml"

  | 49 ->
# 106 "psl_lexer.mll"
                         ( Psl_parser.Default             (Parser_util.next_lex lexbuf) )
# 5786 "psl_lexer.ml"

  | 50 ->
# 107 "psl_lexer.mll"
                         ( Psl_parser.E                   (Parser_util.next_lex lexbuf) )
# 5791 "psl_lexer.ml"

  | 51 ->
# 108 "psl_lexer.mll"
                         ( Psl_parser.EF                  (Parser_util.next_lex lexbuf) )
# 5796 "psl_lexer.ml"

  | 52 ->
# 109 "psl_lexer.mll"
                         ( Psl_parser.EG                  (Parser_util.next_lex lexbuf) )
# 5801 "psl_lexer.ml"

  | 53 ->
# 110 "psl_lexer.mll"
                         ( Psl_parser.EX                  (Parser_util.next_lex lexbuf) )
# 5806 "psl_lexer.ml"

  | 54 ->
# 111 "psl_lexer.mll"
                         ( Psl_parser.Endpoint            (Parser_util.next_lex lexbuf) )
# 5811 "psl_lexer.ml"

  | 55 ->
# 112 "psl_lexer.mll"
                         ( Psl_parser.Eventually_bang     (Parser_util.next_lex lexbuf) )
# 5816 "psl_lexer.ml"

  | 56 ->
# 113 "psl_lexer.mll"
                         ( Psl_parser.F                   (Parser_util.next_lex lexbuf) )
# 5821 "psl_lexer.ml"

  | 57 ->
# 114 "psl_lexer.mll"
                         ( Psl_parser.Fairness            (Parser_util.next_lex lexbuf) )
# 5826 "psl_lexer.ml"

  | 58 ->
# 115 "psl_lexer.mll"
                         ( Psl_parser.Fell                (Parser_util.next_lex lexbuf) )
# 5831 "psl_lexer.ml"

  | 59 ->
# 116 "psl_lexer.mll"
                         ( Psl_parser.Forall              (Parser_util.next_lex lexbuf) )
# 5836 "psl_lexer.ml"

  | 60 ->
# 117 "psl_lexer.mll"
                         ( Psl_parser.G                   (Parser_util.next_lex lexbuf) )
# 5841 "psl_lexer.ml"

  | 61 ->
# 118 "psl_lexer.mll"
                         ( Psl_parser.In                  (Parser_util.next_lex lexbuf) )
# 5846 "psl_lexer.ml"

  | 62 ->
# 119 "psl_lexer.mll"
                         ( Psl_parser.Inf                 (Parser_util.next_lex lexbuf) )
# 5851 "psl_lexer.ml"

  | 63 ->
# 120 "psl_lexer.mll"
                         ( Psl_parser.Inherit             (Parser_util.next_lex lexbuf) )
# 5856 "psl_lexer.ml"

  | 64 ->
# 121 "psl_lexer.mll"
                         ( Psl_parser.Isunknown           (Parser_util.next_lex lexbuf) )
# 5861 "psl_lexer.ml"

  | 65 ->
# 122 "psl_lexer.mll"
                         ( Psl_parser.Never               (Parser_util.next_lex lexbuf) )
# 5866 "psl_lexer.ml"

  | 66 ->
# 123 "psl_lexer.mll"
                         ( Psl_parser.Next                (Parser_util.next_lex lexbuf) )
# 5871 "psl_lexer.ml"

  | 67 ->
# 124 "psl_lexer.mll"
                         ( Psl_parser.Next_bang           (Parser_util.next_lex lexbuf) )
# 5876 "psl_lexer.ml"

  | 68 ->
# 125 "psl_lexer.mll"
                         ( Psl_parser.Next_a              (Parser_util.next_lex lexbuf) )
# 5881 "psl_lexer.ml"

  | 69 ->
# 126 "psl_lexer.mll"
                         ( Psl_parser.Next_a_bang         (Parser_util.next_lex lexbuf) )
# 5886 "psl_lexer.ml"

  | 70 ->
# 127 "psl_lexer.mll"
                         ( Psl_parser.Next_e              (Parser_util.next_lex lexbuf) )
# 5891 "psl_lexer.ml"

  | 71 ->
# 128 "psl_lexer.mll"
                         ( Psl_parser.Next_e_bang         (Parser_util.next_lex lexbuf) )
# 5896 "psl_lexer.ml"

  | 72 ->
# 129 "psl_lexer.mll"
                         ( Psl_parser.Next_event          (Parser_util.next_lex lexbuf) )
# 5901 "psl_lexer.ml"

  | 73 ->
# 130 "psl_lexer.mll"
                         ( Psl_parser.Next_event_bang     (Parser_util.next_lex lexbuf) )
# 5906 "psl_lexer.ml"

  | 74 ->
# 131 "psl_lexer.mll"
                         ( Psl_parser.Next_event_a        (Parser_util.next_lex lexbuf) )
# 5911 "psl_lexer.ml"

  | 75 ->
# 132 "psl_lexer.mll"
                         ( Psl_parser.Next_event_a_bang   (Parser_util.next_lex lexbuf) )
# 5916 "psl_lexer.ml"

  | 76 ->
# 133 "psl_lexer.mll"
                         ( Psl_parser.Next_event_e        (Parser_util.next_lex lexbuf) )
# 5921 "psl_lexer.ml"

  | 77 ->
# 134 "psl_lexer.mll"
                         ( Psl_parser.Next_event_e_bang   (Parser_util.next_lex lexbuf) )
# 5926 "psl_lexer.ml"

  | 78 ->
# 135 "psl_lexer.mll"
                         ( Psl_parser.Onehot              (Parser_util.next_lex lexbuf) )
# 5931 "psl_lexer.ml"

  | 79 ->
# 136 "psl_lexer.mll"
                         ( Psl_parser.Onehot0             (Parser_util.next_lex lexbuf) )
# 5936 "psl_lexer.ml"

  | 80 ->
# 137 "psl_lexer.mll"
                         ( Psl_parser.Property            (Parser_util.next_lex lexbuf) )
# 5941 "psl_lexer.ml"

  | 81 ->
# 138 "psl_lexer.mll"
                         ( Psl_parser.Prev                (Parser_util.next_lex lexbuf) )
# 5946 "psl_lexer.ml"

  | 82 ->
# 139 "psl_lexer.mll"
                         ( Psl_parser.Report              (Parser_util.next_lex lexbuf) )
# 5951 "psl_lexer.ml"

  | 83 ->
# 140 "psl_lexer.mll"
                         ( Psl_parser.Restrict            (Parser_util.next_lex lexbuf) )
# 5956 "psl_lexer.ml"

  | 84 ->
# 141 "psl_lexer.mll"
                         ( Psl_parser.Restrict_guarantee  (Parser_util.next_lex lexbuf) )
# 5961 "psl_lexer.ml"

  | 85 ->
# 142 "psl_lexer.mll"
                         ( Psl_parser.Rose                (Parser_util.next_lex lexbuf) )
# 5966 "psl_lexer.ml"

  | 86 ->
# 143 "psl_lexer.mll"
                         ( Psl_parser.Sequence            (Parser_util.next_lex lexbuf) )
# 5971 "psl_lexer.ml"

  | 87 ->
# 144 "psl_lexer.mll"
                         ( Psl_parser.Stable              (Parser_util.next_lex lexbuf) )
# 5976 "psl_lexer.ml"

  | 88 ->
# 145 "psl_lexer.mll"
                         ( Psl_parser.Strong              (Parser_util.next_lex lexbuf) )
# 5981 "psl_lexer.ml"

  | 89 ->
# 146 "psl_lexer.mll"
                         ( Psl_parser.U                   (Parser_util.next_lex lexbuf) )
# 5986 "psl_lexer.ml"

  | 90 ->
# 147 "psl_lexer.mll"
                         ( Psl_parser.Union               (Parser_util.next_lex lexbuf) )
# 5991 "psl_lexer.ml"

  | 91 ->
# 148 "psl_lexer.mll"
                         ( Psl_parser.Until               (Parser_util.next_lex lexbuf) )
# 5996 "psl_lexer.ml"

  | 92 ->
# 149 "psl_lexer.mll"
                         ( Psl_parser.Until_bang          (Parser_util.next_lex lexbuf) )
# 6001 "psl_lexer.ml"

  | 93 ->
# 150 "psl_lexer.mll"
                         ( Psl_parser.Until_bang_         (Parser_util.next_lex lexbuf) )
# 6006 "psl_lexer.ml"

  | 94 ->
# 151 "psl_lexer.mll"
                         ( Psl_parser.Until_              (Parser_util.next_lex lexbuf) )
# 6011 "psl_lexer.ml"

  | 95 ->
# 152 "psl_lexer.mll"
                         ( Psl_parser.Vmode               (Parser_util.next_lex lexbuf) )
# 6016 "psl_lexer.ml"

  | 96 ->
# 153 "psl_lexer.mll"
                         ( Psl_parser.Vprop               (Parser_util.next_lex lexbuf) )
# 6021 "psl_lexer.ml"

  | 97 ->
# 154 "psl_lexer.mll"
                         ( Psl_parser.Vunit               (Parser_util.next_lex lexbuf) )
# 6026 "psl_lexer.ml"

  | 98 ->
# 155 "psl_lexer.mll"
                         ( Psl_parser.Within              (Parser_util.next_lex lexbuf) )
# 6031 "psl_lexer.ml"

  | 99 ->
# 156 "psl_lexer.mll"
                         ( Psl_parser.X                   (Parser_util.next_lex lexbuf) )
# 6036 "psl_lexer.ml"

  | 100 ->
# 157 "psl_lexer.mll"
                         ( Psl_parser.X_bang              (Parser_util.next_lex lexbuf) )
# 6041 "psl_lexer.ml"

  | 101 ->
# 159 "psl_lexer.mll"
                         ( Psl_parser.Posedge             (Parser_util.next_lex lexbuf) )
# 6046 "psl_lexer.ml"

  | 102 ->
# 160 "psl_lexer.mll"
                         ( Psl_parser.Negedge             (Parser_util.next_lex lexbuf) )
# 6051 "psl_lexer.ml"

  | 103 ->
# 162 "psl_lexer.mll"
                         ( Psl_parser.Integer             (Parser_util.next_lex lexbuf) )
# 6056 "psl_lexer.ml"

  | 104 ->
# 163 "psl_lexer.mll"
                         ( Psl_parser.Identifier          (Parser_util.next_lex lexbuf) )
# 6061 "psl_lexer.ml"

  | 105 ->
# 164 "psl_lexer.mll"
                         ( Psl_parser.Identifier_esc      (Parser_util.next_lex lexbuf) )
# 6066 "psl_lexer.ml"

  | 106 ->
# 166 "psl_lexer.mll"
                         ( Psl_parser.String              (Parser_util.next_lex lexbuf) )
# 6071 "psl_lexer.ml"

  | 107 ->
# 168 "psl_lexer.mll"
                         ( Psl_parser.EOF                 (Parser_util.next_lex lexbuf) )
# 6076 "psl_lexer.ml"

  | 108 ->
# 170 "psl_lexer.mll"
                         ( let _ = Parser_util.next_lex lexbuf in token lexbuf )
# 6081 "psl_lexer.ml"

  | 109 ->
# 172 "psl_lexer.mll"
                         ( let _ = Parser_util.next_lex lexbuf in token lexbuf )
# 6086 "psl_lexer.ml"

  | 110 ->
# 173 "psl_lexer.mll"
                         ( let _ = Parser_util.next_lex lexbuf in comment lexbuf )
# 6091 "psl_lexer.ml"

  | 111 ->
# 175 "psl_lexer.mll"
                         ( let token = Parser_util.next_lex lexbuf in
                           Parser_util.error ("Unrecognized character: '" ^ (fst token) ^ "'");
                           Psl_parser.Lexer_error token )
# 6098 "psl_lexer.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 308
and __ocaml_lex_comment_rec lexbuf __ocaml_lex_state =
  match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with
      | 0 ->
# 180 "psl_lexer.mll"
                         ( let _ = Parser_util.next_lex lexbuf in token lexbuf )
# 6109 "psl_lexer.ml"

  | 1 ->
# 182 "psl_lexer.mll"
                         ( let token = Parser_util.next_lex lexbuf in
                           Parser_util.error ("End of File without closing comment.");
                           Psl_parser.Lexer_error token )
# 6116 "psl_lexer.ml"

  | 2 ->
# 186 "psl_lexer.mll"
                         ( let _ = Parser_util.next_lex lexbuf in comment lexbuf )
# 6121 "psl_lexer.ml"

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