| 1 |  |   | 
    
      | 2 |  |   | 
    
      | 3 |  |   | 
    
      | 4 |  |   | 
    
      | 5 |  |   | 
    
      | 6 |  |   | 
    
      | 7 |  |   | 
    
      | 8 |  |   | 
    
      | 9 |  |   | 
    
      | 10 |  |   | 
    
      | 11 |  |   | 
    
      | 12 |  |   | 
    
      | 13 |  |   | 
    
      | 14 |  |   | 
    
      | 15 |  |   | 
    
      | 16 |  |   | 
    
      | 17 |  |  package org.apache.commons.jexl.parser; | 
    
      | 18 |  |   | 
    
      | 19 |  |  public class ParserTokenManager implements ParserConstants { | 
    
      | 20 | 14 |      public java.io.PrintStream debugStream = System.out; | 
    
      | 21 |  |   | 
    
      | 22 |  |      public void setDebugStream(java.io.PrintStream ds) { | 
    
      | 23 | 0 |          debugStream = ds; | 
    
      | 24 | 0 |      } | 
    
      | 25 |  |   | 
    
      | 26 |  |      private final int jjStopStringLiteralDfa_0(class="keyword">int pos, long active0) { | 
    
      | 27 | 346 |          switch (pos) { | 
    
      | 28 |  |              case 0: | 
    
      | 29 | 230 |                  if ((active0 & 0x3ef285550a4800L) != 0L) { | 
    
      | 30 | 153 |                      jjmatchedKind = 58; | 
    
      | 31 | 153 |                      return 5; | 
    
      | 32 |  |                  } | 
    
      | 33 | 77 |                  return -1; | 
    
      | 34 |  |              case 1: | 
    
      | 35 | 116 |                  if ((active0 & 0x1cf28000084800L) != 0L) { | 
    
      | 36 | 116 |                      jjmatchedKind = 58; | 
    
      | 37 | 116 |                      jjmatchedPos = 1; | 
    
      | 38 | 116 |                      return 5; | 
    
      | 39 |  |                  } | 
    
      | 40 | 0 |                  if ((active0 & 0x22000555020000L) != 0L) | 
    
      | 41 | 0 |                      return 5; | 
    
      | 42 | 0 |                  return -1; | 
    
      | 43 |  |              case 2: | 
    
      | 44 | 0 |                  if ((active0 & 0x1ce00000004800L) != 0L) { | 
    
      | 45 | 0 |                      jjmatchedKind = 58; | 
    
      | 46 | 0 |                      jjmatchedPos = 2; | 
    
      | 47 | 0 |                      return 5; | 
    
      | 48 |  |                  } | 
    
      | 49 | 0 |                  if ((active0 & 0x128000080000L) != 0L) | 
    
      | 50 | 0 |                      return 5; | 
    
      | 51 | 0 |                  return -1; | 
    
      | 52 |  |              case 3: | 
    
      | 53 | 0 |                  if ((active0 & 0x18800000000800L) != 0L) { | 
    
      | 54 | 0 |                      jjmatchedKind = 58; | 
    
      | 55 | 0 |                      jjmatchedPos = 3; | 
    
      | 56 | 0 |                      return 5; | 
    
      | 57 |  |                  } | 
    
      | 58 | 0 |                  if ((active0 & 0x4600000004000L) != 0L) | 
    
      | 59 | 0 |                      return 5; | 
    
      | 60 | 0 |                  return -1; | 
    
      | 61 |  |              case 4: | 
    
      | 62 | 0 |                  if ((active0 & 0x10000000000000L) != 0L) { | 
    
      | 63 | 0 |                      jjmatchedKind = 58; | 
    
      | 64 | 0 |                      jjmatchedPos = 4; | 
    
      | 65 | 0 |                      return 5; | 
    
      | 66 |  |                  } | 
    
      | 67 | 0 |                  if ((active0 & 0x8800000000800L) != 0L) | 
    
      | 68 | 0 |                      return 5; | 
    
      | 69 | 0 |                  return -1; | 
    
      | 70 |  |              case 5: | 
    
      | 71 | 0 |                  if ((active0 & 0x10000000000000L) != 0L) { | 
    
      | 72 | 0 |                      jjmatchedKind = 58; | 
    
      | 73 | 0 |                      jjmatchedPos = 5; | 
    
      | 74 | 0 |                      return 5; | 
    
      | 75 |  |                  } | 
    
      | 76 | 0 |                  return -1; | 
    
      | 77 |  |              default: | 
    
      | 78 | 0 |                  return -1; | 
    
      | 79 |  |          } | 
    
      | 80 |  |      } | 
    
      | 81 |  |   | 
    
      | 82 |  |      private final int jjStartNfa_0(class="keyword">int pos, long active0) { | 
    
      | 83 | 346 |          return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1); | 
    
      | 84 |  |      } | 
    
      | 85 |  |   | 
    
      | 86 |  |      private final int jjStopAtPos(class="keyword">int pos, class="keyword">int kind) { | 
    
      | 87 | 901 |          jjmatchedKind = kind; | 
    
      | 88 | 901 |          jjmatchedPos = pos; | 
    
      | 89 | 901 |          return pos + 1; | 
    
      | 90 |  |      } | 
    
      | 91 |  |   | 
    
      | 92 |  |      private final int jjStartNfaWithStates_0(class="keyword">int pos, class="keyword">int kind, class="keyword">int state) { | 
    
      | 93 | 190 |          jjmatchedKind = kind; | 
    
      | 94 | 190 |          jjmatchedPos = pos; | 
    
      | 95 |  |          try { | 
    
      | 96 | 190 |              curChar = input_stream.readChar(); | 
    
      | 97 | 190 |          } catch (java.io.IOException e) { | 
    
      | 98 | 0 |              return pos + 1; | 
    
      | 99 |  |          } | 
    
      | 100 | 190 |          return jjMoveNfa_0(state, pos + 1); | 
    
      | 101 |  |      } | 
    
      | 102 |  |   | 
    
      | 103 |  |      private final int jjMoveStringLiteralDfa0_0() { | 
    
      | 104 | 1848 |          switch (curChar) { | 
    
      | 105 |  |              case 33: | 
    
      | 106 | 30 |                  jjmatchedKind = 43; | 
    
      | 107 | 30 |                  return jjMoveStringLiteralDfa1_0(0x2000000L); | 
    
      | 108 |  |              case 37: | 
    
      | 109 | 2 |                  return jjStopAtPos(0, 40); | 
    
      | 110 |  |              case 38: | 
    
      | 111 | 9 |                  jjmatchedKind = 22; | 
    
      | 112 | 9 |                  return jjMoveStringLiteralDfa1_0(0x40000L); | 
    
      | 113 |  |              case 40: | 
    
      | 114 | 117 |                  return jjStopAtPos(0, 12); | 
    
      | 115 |  |              case 41: | 
    
      | 116 | 117 |                  return jjStopAtPos(0, 13); | 
    
      | 117 |  |              case 42: | 
    
      | 118 | 14 |                  return jjStopAtPos(0, 37); | 
    
      | 119 |  |              case 43: | 
    
      | 120 | 32 |                  return jjStopAtPos(0, 35); | 
    
      | 121 |  |              case 44: | 
    
      | 122 | 5 |                  return jjStopAtPos(0, 54); | 
    
      | 123 |  |              case 45: | 
    
      | 124 | 21 |                  return jjStopAtPos(0, 36); | 
    
      | 125 |  |              case 46: | 
    
      | 126 | 93 |                  return jjStopAtPos(0, 57); | 
    
      | 127 |  |              case 47: | 
    
      | 128 | 4 |                  return jjStopAtPos(0, 38); | 
    
      | 129 |  |              case 59: | 
    
      | 130 | 324 |                  return jjStopAtPos(0, 48); | 
    
      | 131 |  |              case 60: | 
    
      | 132 | 22 |                  jjmatchedKind = 27; | 
    
      | 133 | 22 |                  return jjMoveStringLiteralDfa1_0(0x80000000L); | 
    
      | 134 |  |              case 61: | 
    
      | 135 | 88 |                  jjmatchedKind = 15; | 
    
      | 136 | 88 |                  return jjMoveStringLiteralDfa1_0(0x800000L); | 
    
      | 137 |  |              case 62: | 
    
      | 138 | 20 |                  jjmatchedKind = 29; | 
    
      | 139 | 20 |                  return jjMoveStringLiteralDfa1_0(0x200000000L); | 
    
      | 140 |  |              case 91: | 
    
      | 141 | 15 |                  return jjStopAtPos(0, 55); | 
    
      | 142 |  |              case 93: | 
    
      | 143 | 15 |                  return jjStopAtPos(0, 56); | 
    
      | 144 |  |              case 94: | 
    
      | 145 | 6 |                  return jjStopAtPos(0, 21); | 
    
      | 146 |  |              case 97: | 
    
      | 147 | 52 |                  return jjMoveStringLiteralDfa1_0(0x80000L); | 
    
      | 148 |  |              case 100: | 
    
      | 149 | 0 |                  return jjMoveStringLiteralDfa1_0(0x8000000000L); | 
    
      | 150 |  |              case 101: | 
    
      | 151 | 31 |                  return jjMoveStringLiteralDfa1_0(0x4000001000800L); | 
    
      | 152 |  |              case 102: | 
    
      | 153 | 109 |                  return jjMoveStringLiteralDfa1_0(0x10800000000000L); | 
    
      | 154 |  |              case 103: | 
    
      | 155 | 7 |                  return jjMoveStringLiteralDfa1_0(0x440000000L); | 
    
      | 156 |  |              case 105: | 
    
      | 157 | 62 |                  return jjMoveStringLiteralDfa1_0(0x22000000000000L); | 
    
      | 158 |  |              case 108: | 
    
      | 159 | 30 |                  return jjMoveStringLiteralDfa1_0(0x110000000L); | 
    
      | 160 |  |              case 109: | 
    
      | 161 | 10 |                  return jjMoveStringLiteralDfa1_0(0x20000000000L); | 
    
      | 162 |  |              case 110: | 
    
      | 163 | 69 |                  return jjMoveStringLiteralDfa1_0(0x300004000000L); | 
    
      | 164 |  |              case 111: | 
    
      | 165 | 19 |                  return jjMoveStringLiteralDfa1_0(0x20000L); | 
    
      | 166 |  |              case 115: | 
    
      | 167 | 43 |                  return jjMoveStringLiteralDfa1_0(0x4000L); | 
    
      | 168 |  |              case 116: | 
    
      | 169 | 23 |                  return jjMoveStringLiteralDfa1_0(0x400000000000L); | 
    
      | 170 |  |              case 119: | 
    
      | 171 | 4 |                  return jjMoveStringLiteralDfa1_0(0x8000000000000L); | 
    
      | 172 |  |              case 123: | 
    
      | 173 | 16 |                  return jjStopAtPos(0, 9); | 
    
      | 174 |  |              case 124: | 
    
      | 175 | 8 |                  jjmatchedKind = 20; | 
    
      | 176 | 8 |                  return jjMoveStringLiteralDfa1_0(0x10000L); | 
    
      | 177 |  |              case 125: | 
    
      | 178 | 16 |                  return jjStopAtPos(0, 10); | 
    
      | 179 |  |              case 126: | 
    
      | 180 | 4 |                  return jjStopAtPos(0, 42); | 
    
      | 181 |  |              default: | 
    
      | 182 | 411 |                  return jjMoveNfa_0(3, 0); | 
    
      | 183 |  |          } | 
    
      | 184 |  |      } | 
    
      | 185 |  |   | 
    
      | 186 |  |      private final int jjMoveStringLiteralDfa1_0(long active0) { | 
    
      | 187 |  |          try { | 
    
      | 188 | 636 |              curChar = input_stream.readChar(); | 
    
      | 189 | 636 |          } catch (java.io.IOException e) { | 
    
      | 190 | 0 |              jjStopStringLiteralDfa_0(0, active0); | 
    
      | 191 | 0 |              return 1; | 
    
      | 192 |  |          } | 
    
      | 193 | 636 |          switch (curChar) { | 
    
      | 194 |  |              case 38: | 
    
      | 195 | 3 |                  if ((active0 & 0x40000L) != 0L) | 
    
      | 196 | 3 |                      return jjStopAtPos(1, 18); | 
    
      | 197 |  |                  break; | 
    
      | 198 |  |              case 61: | 
    
      | 199 | 100 |                  if ((active0 & 0x800000L) != 0L) | 
    
      | 200 | 53 |                      return jjStopAtPos(1, 23); | 
    
      | 201 | 47 |                  else if ((active0 & 0x2000000L) != 0L) | 
    
      | 202 | 21 |                      return jjStopAtPos(1, 25); | 
    
      | 203 | 26 |                  else if ((active0 & 0x80000000L) != 0L) | 
    
      | 204 | 10 |                      return jjStopAtPos(1, 31); | 
    
      | 205 | 16 |                  else if ((active0 & 0x200000000L) != 0L) | 
    
      | 206 | 11 |                      return jjStopAtPos(1, 33); | 
    
      | 207 |  |                  break; | 
    
      | 208 |  |              case 97: | 
    
      | 209 | 21 |                  return jjMoveStringLiteralDfa2_0(active0, 0x800000000000L); | 
    
      | 210 |  |              case 101: | 
    
      | 211 | 20 |                  if ((active0 & 0x4000000L) != 0L) | 
    
      | 212 | 2 |                      return jjStartNfaWithStates_0(1, 26, 5); | 
    
      | 213 | 18 |                  else if ((active0 & 0x100000000L) != 0L) | 
    
      | 214 | 5 |                      return jjStartNfaWithStates_0(1, 32, 5); | 
    
      | 215 | 13 |                  else if ((active0 & 0x400000000L) != 0L) | 
    
      | 216 | 7 |                      return jjStartNfaWithStates_0(1, 34, 5); | 
    
      | 217 |  |                  break; | 
    
      | 218 |  |              case 102: | 
    
      | 219 | 26 |                  if ((active0 & 0x2000000000000L) != 0L) | 
    
      | 220 | 24 |                      return jjStartNfaWithStates_0(1, 49, 5); | 
    
      | 221 |  |                  break; | 
    
      | 222 |  |              case 104: | 
    
      | 223 | 7 |                  return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L); | 
    
      | 224 |  |              case 105: | 
    
      | 225 | 47 |                  return jjMoveStringLiteralDfa2_0(active0, 0x8000004000L); | 
    
      | 226 |  |              case 108: | 
    
      | 227 | 5 |                  return jjMoveStringLiteralDfa2_0(active0, 0x4000000000000L); | 
    
      | 228 |  |              case 109: | 
    
      | 229 | 25 |                  return jjMoveStringLiteralDfa2_0(active0, 0x800L); | 
    
      | 230 |  |              case 110: | 
    
      | 231 | 18 |                  if ((active0 & 0x20000000000000L) != 0L) | 
    
      | 232 | 14 |                      return jjStartNfaWithStates_0(1, 53, 5); | 
    
      | 233 | 4 |                  return jjMoveStringLiteralDfa2_0(active0, 0x80000L); | 
    
      | 234 |  |              case 111: | 
    
      | 235 | 112 |                  return jjMoveStringLiteralDfa2_0(active0, 0x10120000000000L); | 
    
      | 236 |  |              case 113: | 
    
      | 237 | 6 |                  if ((active0 & 0x1000000L) != 0L) | 
    
      | 238 | 4 |                      return jjStartNfaWithStates_0(1, 24, 5); | 
    
      | 239 |  |                  break; | 
    
      | 240 |  |              case 114: | 
    
      | 241 | 29 |                  if ((active0 & 0x20000L) != 0L) | 
    
      | 242 | 3 |                      return jjStartNfaWithStates_0(1, 17, 5); | 
    
      | 243 | 26 |                  return jjMoveStringLiteralDfa2_0(active0, 0x400000000000L); | 
    
      | 244 |  |              case 116: | 
    
      | 245 | 26 |                  if ((active0 & 0x10000000L) != 0L) | 
    
      | 246 | 0 |                      return jjStartNfaWithStates_0(1, 28, 5); | 
    
      | 247 | 26 |                  else if ((active0 & 0x40000000L) != 0L) | 
    
      | 248 | 0 |                      return jjStartNfaWithStates_0(1, 30, 5); | 
    
      | 249 |  |                  break; | 
    
      | 250 |  |              case 117: | 
    
      | 251 | 73 |                  return jjMoveStringLiteralDfa2_0(active0, 0x200000000000L); | 
    
      | 252 |  |              case 124: | 
    
      | 253 | 2 |                  if ((active0 & 0x10000L) != 0L) | 
    
      | 254 | 2 |                      return jjStopAtPos(1, 16); | 
    
      | 255 |  |                  break; | 
    
      | 256 |  |              default: | 
    
      | 257 |  |                  break; | 
    
      | 258 |  |          } | 
    
      | 259 | 157 |          return jjStartNfa_0(0, active0); | 
    
      | 260 |  |      } | 
    
      | 261 |  |   | 
    
      | 262 |  |      private final int jjMoveStringLiteralDfa2_0(long old0, class="keyword">long active0) { | 
    
      | 263 | 320 |          if (((active0 &= old0)) == 0L) | 
    
      | 264 | 73 |              return jjStartNfa_0(0, old0); | 
    
      | 265 |  |          try { | 
    
      | 266 | 247 |              curChar = input_stream.readChar(); | 
    
      | 267 | 247 |          } catch (java.io.IOException e) { | 
    
      | 268 | 0 |              jjStopStringLiteralDfa_0(1, active0); | 
    
      | 269 | 0 |              return 2; | 
    
      | 270 |  |          } | 
    
      | 271 | 247 |          switch (curChar) { | 
    
      | 272 |  |              case 100: | 
    
      | 273 | 3 |                  if ((active0 & 0x80000L) != 0L) | 
    
      | 274 | 3 |                      return jjStartNfaWithStates_0(2, 19, 5); | 
    
      | 275 | 0 |                  else if ((active0 & 0x20000000000L) != 0L) | 
    
      | 276 | 0 |                      return jjStartNfaWithStates_0(2, 41, 5); | 
    
      | 277 |  |                  break; | 
    
      | 278 |  |              case 105: | 
    
      | 279 | 4 |                  return jjMoveStringLiteralDfa3_0(active0, 0x8000000000000L); | 
    
      | 280 |  |              case 108: | 
    
      | 281 | 42 |                  return jjMoveStringLiteralDfa3_0(active0, 0xa00000000000L); | 
    
      | 282 |  |              case 112: | 
    
      | 283 | 22 |                  return jjMoveStringLiteralDfa3_0(active0, 0x800L); | 
    
      | 284 |  |              case 114: | 
    
      | 285 | 10 |                  return jjMoveStringLiteralDfa3_0(active0, 0x10000000000000L); | 
    
      | 286 |  |              case 115: | 
    
      | 287 | 5 |                  return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000L); | 
    
      | 288 |  |              case 116: | 
    
      | 289 | 6 |                  if ((active0 & 0x100000000000L) != 0L) | 
    
      | 290 | 6 |                      return jjStartNfaWithStates_0(2, 44, 5); | 
    
      | 291 |  |                  break; | 
    
      | 292 |  |              case 117: | 
    
      | 293 | 19 |                  return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L); | 
    
      | 294 |  |              case 118: | 
    
      | 295 | 0 |                  if ((active0 & 0x8000000000L) != 0L) | 
    
      | 296 | 0 |                      return jjStartNfaWithStates_0(2, 39, 5); | 
    
      | 297 |  |                  break; | 
    
      | 298 |  |              case 122: | 
    
      | 299 | 20 |                  return jjMoveStringLiteralDfa3_0(active0, 0x4000L); | 
    
      | 300 |  |              default: | 
    
      | 301 |  |                  break; | 
    
      | 302 |  |          } | 
    
      | 303 | 116 |          return jjStartNfa_0(1, active0); | 
    
      | 304 |  |      } | 
    
      | 305 |  |   | 
    
      | 306 |  |      private final int jjMoveStringLiteralDfa3_0(long old0, class="keyword">long active0) { | 
    
      | 307 | 122 |          if (((active0 &= old0)) == 0L) | 
    
      | 308 | 0 |              return jjStartNfa_0(1, old0); | 
    
      | 309 |  |          try { | 
    
      | 310 | 122 |              curChar = input_stream.readChar(); | 
    
      | 311 | 122 |          } catch (java.io.IOException e) { | 
    
      | 312 | 0 |              jjStopStringLiteralDfa_0(2, active0); | 
    
      | 313 | 0 |              return 3; | 
    
      | 314 |  |          } | 
    
      | 315 | 122 |          switch (curChar) { | 
    
      | 316 |  |              case 101: | 
    
      | 317 | 54 |                  if ((active0 & 0x4000L) != 0L) | 
    
      | 318 | 20 |                      return jjStartNfaWithStates_0(3, 14, 5); | 
    
      | 319 | 34 |                  else if ((active0 & 0x400000000000L) != 0L) | 
    
      | 320 | 19 |                      return jjStartNfaWithStates_0(3, 46, 5); | 
    
      | 321 | 15 |                  else if ((active0 & 0x4000000000000L) != 0L) | 
    
      | 322 | 5 |                      return jjStartNfaWithStates_0(3, 50, 5); | 
    
      | 323 | 10 |                  return jjMoveStringLiteralDfa4_0(active0, 0x10000000000000L); | 
    
      | 324 |  |              case 108: | 
    
      | 325 | 35 |                  if ((active0 & 0x200000000000L) != 0L) | 
    
      | 326 | 31 |                      return jjStartNfaWithStates_0(3, 45, 5); | 
    
      | 327 | 4 |                  return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000L); | 
    
      | 328 |  |              case 115: | 
    
      | 329 | 11 |                  return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L); | 
    
      | 330 |  |              case 116: | 
    
      | 331 | 22 |                  return jjMoveStringLiteralDfa4_0(active0, 0x800L); | 
    
      | 332 |  |              default: | 
    
      | 333 |  |                  break; | 
    
      | 334 |  |          } | 
    
      | 335 | 0 |          return jjStartNfa_0(2, active0); | 
    
      | 336 |  |      } | 
    
      | 337 |  |   | 
    
      | 338 |  |      private final int jjMoveStringLiteralDfa4_0(long old0, class="keyword">long active0) { | 
    
      | 339 | 47 |          if (((active0 &= old0)) == 0L) | 
    
      | 340 | 0 |              return jjStartNfa_0(2, old0); | 
    
      | 341 |  |          try { | 
    
      | 342 | 47 |              curChar = input_stream.readChar(); | 
    
      | 343 | 47 |          } catch (java.io.IOException e) { | 
    
      | 344 | 0 |              jjStopStringLiteralDfa_0(3, active0); | 
    
      | 345 | 0 |              return 4; | 
    
      | 346 |  |          } | 
    
      | 347 | 47 |          switch (curChar) { | 
    
      | 348 |  |              case 97: | 
    
      | 349 | 10 |                  return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L); | 
    
      | 350 |  |              case 101: | 
    
      | 351 | 15 |                  if ((active0 & 0x800000000000L) != 0L) | 
    
      | 352 | 11 |                      return jjStartNfaWithStates_0(4, 47, 5); | 
    
      | 353 | 4 |                  else if ((active0 & 0x8000000000000L) != 0L) | 
    
      | 354 | 4 |                      return jjStartNfaWithStates_0(4, 51, 5); | 
    
      | 355 |  |                  break; | 
    
      | 356 |  |              case 121: | 
    
      | 357 | 22 |                  if ((active0 & 0x800L) != 0L) | 
    
      | 358 | 22 |                      return jjStartNfaWithStates_0(4, 11, 5); | 
    
      | 359 |  |                  break; | 
    
      | 360 |  |              default: | 
    
      | 361 |  |                  break; | 
    
      | 362 |  |          } | 
    
      | 363 | 0 |          return jjStartNfa_0(3, active0); | 
    
      | 364 |  |      } | 
    
      | 365 |  |   | 
    
      | 366 |  |      private final int jjMoveStringLiteralDfa5_0(long old0, class="keyword">long active0) { | 
    
      | 367 | 10 |          if (((active0 &= old0)) == 0L) | 
    
      | 368 | 0 |              return jjStartNfa_0(3, old0); | 
    
      | 369 |  |          try { | 
    
      | 370 | 10 |              curChar = input_stream.readChar(); | 
    
      | 371 | 10 |          } catch (java.io.IOException e) { | 
    
      | 372 | 0 |              jjStopStringLiteralDfa_0(4, active0); | 
    
      | 373 | 0 |              return 5; | 
    
      | 374 |  |          } | 
    
      | 375 | 10 |          switch (curChar) { | 
    
      | 376 |  |              case 99: | 
    
      | 377 | 10 |                  return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L); | 
    
      | 378 |  |              default: | 
    
      | 379 |  |                  break; | 
    
      | 380 |  |          } | 
    
      | 381 | 0 |          return jjStartNfa_0(4, active0); | 
    
      | 382 |  |      } | 
    
      | 383 |  |   | 
    
      | 384 |  |      private final int jjMoveStringLiteralDfa6_0(long old0, class="keyword">long active0) { | 
    
      | 385 | 10 |          if (((active0 &= old0)) == 0L) | 
    
      | 386 | 0 |              return jjStartNfa_0(4, old0); | 
    
      | 387 |  |          try { | 
    
      | 388 | 10 |              curChar = input_stream.readChar(); | 
    
      | 389 | 10 |          } catch (java.io.IOException e) { | 
    
      | 390 | 0 |              jjStopStringLiteralDfa_0(5, active0); | 
    
      | 391 | 0 |              return 6; | 
    
      | 392 |  |          } | 
    
      | 393 | 10 |          switch (curChar) { | 
    
      | 394 |  |              case 104: | 
    
      | 395 | 10 |                  if ((active0 & 0x10000000000000L) != 0L) | 
    
      | 396 | 10 |                      return jjStartNfaWithStates_0(6, 52, 5); | 
    
      | 397 |  |                  break; | 
    
      | 398 |  |              default: | 
    
      | 399 |  |                  break; | 
    
      | 400 |  |          } | 
    
      | 401 | 0 |          return jjStartNfa_0(5, active0); | 
    
      | 402 |  |      } | 
    
      | 403 |  |   | 
    
      | 404 |  |      private final void jjCheckNAdd(int state) { | 
    
      | 405 | 2179 |          if (jjrounds[state] != jjround) { | 
    
      | 406 | 2179 |              jjstateSet[jjnewStateCnt++] = state; | 
    
      | 407 | 2179 |              jjrounds[state] = jjround; | 
    
      | 408 |  |          } | 
    
      | 409 | 2179 |      } | 
    
      | 410 |  |   | 
    
      | 411 |  |      private final void jjAddStates(int start, class="keyword">int end) { | 
    
      | 412 |  |          do { | 
    
      | 413 | 876 |              jjstateSet[jjnewStateCnt++] = jjnextStates[start]; | 
    
      | 414 | 876 |          } while (start++ != end); | 
    
      | 415 | 438 |      } | 
    
      | 416 |  |   | 
    
      | 417 |  |      private final void jjCheckNAddTwoStates(int state1, class="keyword">int state2) { | 
    
      | 418 | 186 |          jjCheckNAdd(state1); | 
    
      | 419 | 186 |          jjCheckNAdd(state2); | 
    
      | 420 | 186 |      } | 
    
      | 421 |  |   | 
    
      | 422 |  |      private final void jjCheckNAddStates(int start, class="keyword">int end) { | 
    
      | 423 |  |          do { | 
    
      | 424 | 492 |              jjCheckNAdd(jjnextStates[start]); | 
    
      | 425 | 492 |          } while (start++ != end); | 
    
      | 426 | 164 |      } | 
    
      | 427 |  |   | 
    
      | 428 |  |      private final void jjCheckNAddStates(int start) { | 
    
      | 429 | 0 |          jjCheckNAdd(jjnextStates[start]); | 
    
      | 430 | 0 |          jjCheckNAdd(jjnextStates[start + 1]); | 
    
      | 431 | 0 |      } | 
    
      | 432 |  |   | 
    
      | 433 | 22 |      static final long[] jjbitVec0 = { 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL }; | 
    
      | 434 |  |   | 
    
      | 435 |  |      private final int jjMoveNfa_0(class="keyword">int startState, class="keyword">int curPos) { | 
    
      | 436 |  |          int[] nextStates; | 
    
      | 437 | 947 |          int startsAt = 0; | 
    
      | 438 | 947 |          jjnewStateCnt = 17; | 
    
      | 439 | 947 |          int i = 1; | 
    
      | 440 | 947 |          jjstateSet[0] = startState; | 
    
      | 441 | 947 |          int j, kind = 0x7fffffff; | 
    
      | 442 | 947 |          for (;;) { | 
    
      | 443 | 3060 |              if (++jjround == 0x7fffffff) | 
    
      | 444 | 0 |                  ReInitRounds(); | 
    
      | 445 | 3060 |              if (curChar < 64) { | 
    
      | 446 | 1304 |                  long l = 1L << curChar; | 
    
      | 447 |  |                  MatchLoop: do { | 
    
      | 448 | 1805 |                      switch (jjstateSet[--i]) { | 
    
      | 449 |  |                          case 3: | 
    
      | 450 | 263 |                              if ((0x3ff000000000000L & l) != 0L) { | 
    
      | 451 | 164 |                                  if (kind > 7) | 
    
      | 452 | 164 |                                      kind = 7; | 
    
      | 453 | 164 |                                  jjCheckNAddStates(0, 2); | 
    
      | 454 | 99 |                              } else if (curChar == 39) | 
    
      | 455 | 65 |                                  jjCheckNAddTwoStates(10, 11); | 
    
      | 456 | 34 |                              else if (curChar == 34) | 
    
      | 457 | 14 |                                  jjCheckNAddTwoStates(7, 8); | 
    
      | 458 | 20 |                              else if (curChar == 36) { | 
    
      | 459 | 0 |                                  if (kind > 58) | 
    
      | 460 | 0 |                                      kind = 58; | 
    
      | 461 | 0 |                                  jjCheckNAdd(5); | 
    
      | 462 | 20 |                              } else if (curChar == 35) | 
    
      | 463 | 17 |                                  jjstateSet[jjnewStateCnt++] = 0; | 
    
      | 464 |  |                              break; | 
    
      | 465 |  |                          case 0: | 
    
      | 466 | 17 |                              if (curChar == 35) | 
    
      | 467 | 17 |                                  jjCheckNAddTwoStates(1, 2); | 
    
      | 468 |  |                              break; | 
    
      | 469 |  |                          case 1: | 
    
      | 470 | 56 |                              if ((0xfffffffbffffdbffL & l) != 0L) | 
    
      | 471 | 39 |                                  jjCheckNAddTwoStates(1, 2); | 
    
      | 472 |  |                              break; | 
    
      | 473 |  |                          case 2: | 
    
      | 474 | 56 |                              if ((0x2400L & l) != 0L) | 
    
      | 475 | 17 |                                  kind = 1; | 
    
      | 476 |  |                              break; | 
    
      | 477 |  |                          case 4: | 
    
      | 478 | 0 |                              if (curChar != 36) | 
    
      | 479 | 0 |                                  break; | 
    
      | 480 | 0 |                              if (kind > 58) | 
    
      | 481 | 0 |                                  kind = 58; | 
    
      | 482 | 0 |                              jjCheckNAdd(5); | 
    
      | 483 | 0 |                              break; | 
    
      | 484 |  |                          case 5: | 
    
      | 485 | 598 |                              if ((0x3ff001000000000L & l) == 0L) | 
    
      | 486 | 593 |                                  break; | 
    
      | 487 | 5 |                              if (kind > 58) | 
    
      | 488 | 5 |                                  kind = 58; | 
    
      | 489 | 5 |                              jjCheckNAdd(5); | 
    
      | 490 | 5 |                              break; | 
    
      | 491 |  |                          case 6: | 
    
      | 492 | 0 |                              if (curChar == 34) | 
    
      | 493 | 0 |                                  jjCheckNAddTwoStates(7, 8); | 
    
      | 494 |  |                              break; | 
    
      | 495 |  |                          case 7: | 
    
      | 496 | 29 |                              if ((0xfffffffbffffdbffL & l) != 0L) | 
    
      | 497 | 15 |                                  jjCheckNAddTwoStates(7, 8); | 
    
      | 498 |  |                              break; | 
    
      | 499 |  |                          case 8: | 
    
      | 500 | 29 |                              if (curChar == 34 && kind > 61) | 
    
      | 501 | 14 |                                  kind = 61; | 
    
      | 502 |  |                              break; | 
    
      | 503 |  |                          case 9: | 
    
      | 504 | 0 |                              if (curChar == 39) | 
    
      | 505 | 0 |                                  jjCheckNAddTwoStates(10, 11); | 
    
      | 506 |  |                              break; | 
    
      | 507 |  |                          case 10: | 
    
      | 508 | 94 |                              if ((0xffffff7fffffdbffL & l) != 0L) | 
    
      | 509 | 29 |                                  jjCheckNAddTwoStates(10, 11); | 
    
      | 510 |  |                              break; | 
    
      | 511 |  |                          case 11: | 
    
      | 512 | 94 |                              if (curChar == 39 && kind > 61) | 
    
      | 513 | 65 |                                  kind = 61; | 
    
      | 514 |  |                              break; | 
    
      | 515 |  |                          case 12: | 
    
      | 516 | 0 |                              if ((0x3ff000000000000L & l) == 0L) | 
    
      | 517 | 0 |                                  break; | 
    
      | 518 | 0 |                              if (kind > 7) | 
    
      | 519 | 0 |                                  kind = 7; | 
    
      | 520 | 0 |                              jjCheckNAddStates(0, 2); | 
    
      | 521 | 0 |                              break; | 
    
      | 522 |  |                          case 13: | 
    
      | 523 | 161 |                              if ((0x3ff000000000000L & l) == 0L) | 
    
      | 524 | 154 |                                  break; | 
    
      | 525 | 7 |                              if (kind > 7) | 
    
      | 526 | 7 |                                  kind = 7; | 
    
      | 527 | 7 |                              jjCheckNAdd(13); | 
    
      | 528 | 7 |                              break; | 
    
      | 529 |  |                          case 14: | 
    
      | 530 | 161 |                              if ((0x3ff000000000000L & l) != 0L) | 
    
      | 531 | 7 |                                  jjCheckNAddTwoStates(14, 15); | 
    
      | 532 |  |                              break; | 
    
      | 533 |  |                          case 15: | 
    
      | 534 | 161 |                              if (curChar == 46) | 
    
      | 535 | 8 |                                  jjCheckNAdd(16); | 
    
      | 536 |  |                              break; | 
    
      | 537 |  |                          case 16: | 
    
      | 538 | 16 |                              if ((0x3ff000000000000L & l) == 0L) | 
    
      | 539 | 8 |                                  break; | 
    
      | 540 | 8 |                              if (kind > 8) | 
    
      | 541 | 8 |                                  kind = 8; | 
    
      | 542 | 8 |                              jjCheckNAdd(16); | 
    
      | 543 | 8 |                              break; | 
    
      | 544 |  |                          default: | 
    
      | 545 |  |                              break; | 
    
      | 546 |  |                      } | 
    
      | 547 | 1805 |                  } while (i != startsAt); | 
    
      | 548 | 1756 |              } else if (curChar < 128) { | 
    
      | 549 | 1756 |                  long l = 1L << (curChar & 077); | 
    
      | 550 |  |                  MatchLoop: do { | 
    
      | 551 | 2214 |                      switch (jjstateSet[--i]) { | 
    
      | 552 |  |                          case 3: | 
    
      | 553 |  |                          case 5: | 
    
      | 554 | 1301 |                              if ((0x7fffffe87fffffeL & l) == 0L) | 
    
      | 555 | 14 |                                  break; | 
    
      | 556 | 1287 |                              if (kind > 58) | 
    
      | 557 | 1287 |                                  kind = 58; | 
    
      | 558 | 1287 |                              jjCheckNAdd(5); | 
    
      | 559 | 1287 |                              break; | 
    
      | 560 |  |                          case 1: | 
    
      | 561 | 143 |                              jjAddStates(3, 4); | 
    
      | 562 | 143 |                              break; | 
    
      | 563 |  |                          case 7: | 
    
      | 564 | 77 |                              jjAddStates(5, 6); | 
    
      | 565 | 77 |                              break; | 
    
      | 566 |  |                          case 10: | 
    
      | 567 | 218 |                              jjAddStates(7, 8); | 
    
      | 568 | 218 |                              break; | 
    
      | 569 |  |                          default: | 
    
      | 570 |  |                              break; | 
    
      | 571 |  |                      } | 
    
      | 572 | 2214 |                  } while (i != startsAt); | 
    
      | 573 |  |              } else { | 
    
      | 574 | 0 |                  int i2 = (curChar & 0xff) >> 6; | 
    
      | 575 | 0 |                  long l2 = 1L << (curChar & 077); | 
    
      | 576 |  |                  MatchLoop: do { | 
    
      | 577 | 0 |                      switch (jjstateSet[--i]) { | 
    
      | 578 |  |                          case 1: | 
    
      | 579 | 0 |                              if ((jjbitVec0[i2] & l2) != 0L) | 
    
      | 580 | 0 |                                  jjAddStates(3, 4); | 
    
      | 581 |  |                              break; | 
    
      | 582 |  |                          case 7: | 
    
      | 583 | 0 |                              if ((jjbitVec0[i2] & l2) != 0L) | 
    
      | 584 | 0 |                                  jjAddStates(5, 6); | 
    
      | 585 |  |                              break; | 
    
      | 586 |  |                          case 10: | 
    
      | 587 | 0 |                              if ((jjbitVec0[i2] & l2) != 0L) | 
    
      | 588 | 0 |                                  jjAddStates(7, 8); | 
    
      | 589 |  |                              break; | 
    
      | 590 |  |                          default: | 
    
      | 591 |  |                              break; | 
    
      | 592 |  |                      } | 
    
      | 593 | 0 |                  } while (i != startsAt); | 
    
      | 594 |  |              } | 
    
      | 595 | 3060 |              if (kind != 0x7fffffff) { | 
    
      | 596 | 1567 |                  jjmatchedKind = kind; | 
    
      | 597 | 1567 |                  jjmatchedPos = curPos; | 
    
      | 598 | 1567 |                  kind = 0x7fffffff; | 
    
      | 599 |  |              } | 
    
      | 600 | 3060 |              ++curPos; | 
    
      | 601 | 3060 |              if ((i = jjnewStateCnt) == (startsAt = 17 - (jjnewStateCnt = startsAt))) | 
    
      | 602 | 947 |                  return curPos; | 
    
      | 603 |  |              try { | 
    
      | 604 | 2113 |                  curChar = input_stream.readChar(); | 
    
      | 605 | 2113 |              } catch (java.io.IOException e) { | 
    
      | 606 | 0 |                  return curPos; | 
    
      | 607 | 2113 |              } | 
    
      | 608 |  |          } | 
    
      | 609 |  |      } | 
    
      | 610 |  |   | 
    
      | 611 | 11 |      static final int[] jjnextStates = { 13, 14, 15, 1, 2, 7, 8, 10, 11, }; | 
    
      | 612 |  |   | 
    
      | 613 | 11 |      public static final String[] jjstrLiteralImages = { "", null, class="keyword">null, class="keyword">null, class="keyword">null, class="keyword">null, class="keyword">null, class="keyword">null, class="keyword">null, "\173", | 
    
      | 614 |  |          "\175", "\145\155\160\164\171", "\50", "\51", "\163\151\172\145", "\75", "\174\174", "\157\162", "\46\46", | 
    
      | 615 |  |          "\141\156\144", "\174", "\136", "\46", "\75\75", "\145\161", "\41\75", "\156\145", "\74", "\154\164", "\76", | 
    
      | 616 |  |          "\147\164", "\74\75", "\154\145", "\76\75", "\147\145", "\53", "\55", "\52", "\57", "\144\151\166", "\45", | 
    
      | 617 |  |          "\155\157\144", "\176", "\41", "\156\157\164", "\156\165\154\154", "\164\162\165\145", "\146\141\154\163\145", | 
    
      | 618 |  |          "\73", "\151\146", "\145\154\163\145", "\167\150\151\154\145", "\146\157\162\145\141\143\150", "\151\156", | 
    
      | 619 |  |          "\54", "\133", "\135", "\56", null, class="keyword">null, class="keyword">null, class="keyword">null, }; | 
    
      | 620 |  |   | 
    
      | 621 | 11 |      public static final String[] lexStateNames = { "DEFAULT", }; | 
    
      | 622 |  |   | 
    
      | 623 | 11 |      static final long[] jjtoToken = { 0x27ffffffffffff81L, }; | 
    
      | 624 |  |   | 
    
      | 625 | 11 |      static final long[] jjtoSkip = { 0x7eL, }; | 
    
      | 626 |  |   | 
    
      | 627 |  |      private SimpleCharStream input_stream; | 
    
      | 628 |  |   | 
    
      | 629 | 14 |      private final int[] jjrounds = new class="keyword">int[17]; | 
    
      | 630 |  |   | 
    
      | 631 | 14 |      private final int[] jjstateSet = new class="keyword">int[34]; | 
    
      | 632 |  |   | 
    
      | 633 |  |      protected char curChar; | 
    
      | 634 |  |   | 
    
      | 635 | 14 |      public ParserTokenManager(SimpleCharStream stream) { | 
    
      | 636 |  |          if (SimpleCharStream.staticFlag) | 
    
      | 637 |  |              throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); | 
    
      | 638 | 14 |          input_stream = stream; | 
    
      | 639 | 14 |      } | 
    
      | 640 |  |   | 
    
      | 641 |  |      public ParserTokenManager(SimpleCharStream stream, int lexState) { | 
    
      | 642 | 0 |          this(stream); | 
    
      | 643 | 0 |          SwitchTo(lexState); | 
    
      | 644 | 0 |      } | 
    
      | 645 |  |   | 
    
      | 646 |  |      public void ReInit(SimpleCharStream stream) { | 
    
      | 647 | 288 |          jjmatchedPos = jjnewStateCnt = 0; | 
    
      | 648 | 288 |          curLexState = defaultLexState; | 
    
      | 649 | 288 |          input_stream = stream; | 
    
      | 650 | 288 |          ReInitRounds(); | 
    
      | 651 | 288 |      } | 
    
      | 652 |  |   | 
    
      | 653 |  |      private final void ReInitRounds() { | 
    
      | 654 |  |          int i; | 
    
      | 655 | 288 |          jjround = 0x80000001; | 
    
      | 656 | 5472 |          for (i = 17; i-- > 0;) | 
    
      | 657 | 4896 |              jjrounds[i] = 0x80000000; | 
    
      | 658 | 288 |      } | 
    
      | 659 |  |   | 
    
      | 660 |  |      public void ReInit(SimpleCharStream stream, int lexState) { | 
    
      | 661 | 0 |          ReInit(stream); | 
    
      | 662 | 0 |          SwitchTo(lexState); | 
    
      | 663 | 0 |      } | 
    
      | 664 |  |   | 
    
      | 665 |  |      public void SwitchTo(int lexState) { | 
    
      | 666 | 0 |          if (lexState >= 1 || lexState < 0) | 
    
      | 667 | 0 |              throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", | 
    
      | 668 |  |                  TokenMgrError.INVALID_LEXICAL_STATE); | 
    
      | 669 |  |          else | 
    
      | 670 | 0 |              curLexState = lexState; | 
    
      | 671 | 0 |      } | 
    
      | 672 |  |   | 
    
      | 673 |  |      private final Token jjFillToken() { | 
    
      | 674 | 2110 |          Token t = Token.newToken(jjmatchedKind); | 
    
      | 675 | 2110 |          t.kind = jjmatchedKind; | 
    
      | 676 | 2110 |          String im = jjstrLiteralImages[jjmatchedKind]; | 
    
      | 677 | 2110 |          t.image = (im == null) ? input_stream.GetImage() : im; | 
    
      | 678 | 2110 |          t.beginLine = input_stream.getBeginLine(); | 
    
      | 679 | 2110 |          t.beginColumn = input_stream.getBeginColumn(); | 
    
      | 680 | 2110 |          t.endLine = input_stream.getEndLine(); | 
    
      | 681 | 2110 |          t.endColumn = input_stream.getEndColumn(); | 
    
      | 682 | 2110 |          return t; | 
    
      | 683 |  |      } | 
    
      | 684 |  |   | 
    
      | 685 | 14 |      int curLexState = 0; | 
    
      | 686 |  |   | 
    
      | 687 | 14 |      int defaultLexState = 0; | 
    
      | 688 |  |   | 
    
      | 689 |  |      int jjnewStateCnt; | 
    
      | 690 |  |   | 
    
      | 691 |  |      int jjround; | 
    
      | 692 |  |   | 
    
      | 693 |  |      int jjmatchedPos; | 
    
      | 694 |  |   | 
    
      | 695 |  |      int jjmatchedKind; | 
    
      | 696 |  |   | 
    
      | 697 |  |      public final Token getNextToken() { | 
    
      | 698 |  |          int kind; | 
    
      | 699 | 2113 |          Token specialToken = null; | 
    
      | 700 |  |          Token matchedToken; | 
    
      | 701 | 2113 |          int curPos = 0; | 
    
      | 702 |  |   | 
    
      | 703 | 2113 |          EOFLoop: for (;;) { | 
    
      | 704 |  |              try { | 
    
      | 705 | 2130 |                  curChar = input_stream.BeginToken(); | 
    
      | 706 | 1848 |              } catch (java.io.IOException e) { | 
    
      | 707 | 282 |                  jjmatchedKind = 0; | 
    
      | 708 | 282 |                  matchedToken = jjFillToken(); | 
    
      | 709 | 282 |                  return matchedToken; | 
    
      | 710 |  |              } | 
    
      | 711 |  |   | 
    
      | 712 |  |              try { | 
    
      | 713 | 1848 |                  input_stream.backup(0); | 
    
      | 714 | 4325 |                  while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L) | 
    
      | 715 | 629 |                      curChar = input_stream.BeginToken(); | 
    
      | 716 | 1848 |              } catch (java.io.IOException e1) { | 
    
      | 717 | 0 |                  continue EOFLoop; | 
    
      | 718 |  |              } | 
    
      | 719 | 1848 |              jjmatchedKind = 0x7fffffff; | 
    
      | 720 | 1848 |              jjmatchedPos = 0; | 
    
      | 721 | 1848 |              curPos = jjMoveStringLiteralDfa0_0(); | 
    
      | 722 | 1848 |              if (jjmatchedKind != 0x7fffffff) { | 
    
      | 723 | 1845 |                  if (jjmatchedPos + 1 < curPos) | 
    
      | 724 | 848 |                      input_stream.backup(curPos - jjmatchedPos - 1); | 
    
      | 725 | 1845 |                  if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) { | 
    
      | 726 | 1828 |                      matchedToken = jjFillToken(); | 
    
      | 727 | 1828 |                      return matchedToken; | 
    
      | 728 |  |                  } else { | 
    
      | 729 |  |                      continue EOFLoop; | 
    
      | 730 |  |                  } | 
    
      | 731 |  |              } | 
    
      | 732 | 3 |              int error_line = input_stream.getEndLine(); | 
    
      | 733 | 3 |              int error_column = input_stream.getEndColumn(); | 
    
      | 734 | 3 |              String error_after = null; | 
    
      | 735 | 3 |              boolean EOFSeen = false; | 
    
      | 736 |  |              try { | 
    
      | 737 | 3 |                  input_stream.readChar(); | 
    
      | 738 | 3 |                  input_stream.backup(1); | 
    
      | 739 | 3 |              } catch (java.io.IOException e1) { | 
    
      | 740 | 0 |                  EOFSeen = true; | 
    
      | 741 | 0 |                  error_after = curPos <= 1 ? "" : input_stream.GetImage(); | 
    
      | 742 | 0 |                  if (curChar == '\n' || curChar == '\r') { | 
    
      | 743 | 0 |                      error_line++; | 
    
      | 744 | 0 |                      error_column = 0; | 
    
      | 745 |  |                  } else | 
    
      | 746 | 0 |                      error_column++; | 
    
      | 747 |  |              } | 
    
      | 748 | 3 |              if (!EOFSeen) { | 
    
      | 749 | 3 |                  input_stream.backup(1); | 
    
      | 750 | 3 |                  error_after = curPos <= 1 ? "" : input_stream.GetImage(); | 
    
      | 751 |  |              } | 
    
      | 752 | 3 |              throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, | 
    
      | 753 |  |                  TokenMgrError.LEXICAL_ERROR); | 
    
      | 754 |  |          } | 
    
      | 755 |  |      } | 
    
      | 756 |  |   | 
    
      | 757 |  |  } |