/* $Id: paramstate.h,v 1.2 2009/01/04 18:44:40 kiesling Exp $ -*-c-*-**/

/*
  This file is part of Ctalk.
  Copyright  2005-2009 Robert Kiesling, ctalk@ctalklang.org.
  Permission is granted to copy this software provided that this copyright
  notice is included in all source code modules.

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

/*
 *  Function parameter states.  fn_param_declarations (fn_param.c)
 *  depends on this order.
 */

  OPENPAREN,  LABEL,         /* 0. */
  LABEL,  CHAR,              /* 1. */
  LABEL,  ASTERISK,          /* 2. */
  LABEL,  LABEL,             /* 3. */
  LABEL,  CLOSEPAREN,        /* 4. */
  LABEL,  ARGSEPARATOR,      /* 5. */
  ARGSEPARATOR, LABEL,       /* 6. */
  CHAR,  LABEL,              /* 7. */
  ASTERISK, LABEL,           /* 8. */
  ASTERISK, ASTERISK,        /* 9. */
  CLOSEPAREN,  OPENBLOCK,    /* 10. */
  OPENPAREN, ELLIPSIS,       /* 11. */
  ELLIPSIS, CLOSEPAREN,      /* 12. */
  CLOSEPAREN, SEMICOLON,     /* 13. */
  CLOSEPAREN, OPENBLOCK,     /* 14. */
  LABEL,      OPENPAREN,     /* 15. */
  OPENPAREN,  LITERAL,       /* 16. */
  LITERAL,    CLOSEPAREN,    /* 17. */
  CLOSEPAREN, CLOSEPAREN,    /* 18. */
  ARGSEPARATOR, ELLIPSIS,    /* 19. */
  ELLIPSIS,   ARGSEPARATOR,  /* 20. */
  ELLIPSIS,   CLOSEPAREN,    /* 21. */
  ASTERISK,   OPENPAREN,     /* 22.  e.g. OBJECT *(*)() */
  OPENPAREN,  ASTERISK,      /* 23. ... */
  ASTERISK,   CLOSEPAREN,    /* 24. ...      */
  CLOSEPAREN, OPENPAREN,     /* 25. ...      */
  OPENPAREN,  CLOSEPAREN,    /* 26. ...      */
  CLOSEPAREN, ARGSEPARATOR,  /* 27. ...      */
  LABEL,      ARRAYOPEN,     /* 28. */
  ARRAYCLOSE, ARGSEPARATOR,  /* 29. */
  ARRAYCLOSE, CLOSEPAREN,    /* 30. */
  ARRAYOPEN,  CHAR,          /* 31. Subscript constant expressions. */
  ARRAYOPEN,  LABEL,         /* 32. ... */
  ARRAYOPEN,  INTEGER,       /* 33. ... */
  ARRAYOPEN,  FLOAT,         /* 34. ... */
  ARRAYOPEN,  DOUBLE,        /* 35. ... */
  ARRAYOPEN,  LONG,          /* 36. ... */
  ARRAYOPEN,  LONGLONG,      /* 37. ... */
  ARRAYOPEN,  AMPERSAND,     /* 38. ... */
  ARRAYOPEN,  EXCLAM,        /* 39. ... */
  ARRAYOPEN,  INCREMENT,     /* 40. ... */
  ARRAYOPEN,  DECREMENT,     /* 41. ... */
  ARRAYOPEN,  BIT_COMP,      /* 42. ... */
  ARRAYOPEN,  ASTERISK,      /* 43. ... */
  ARRAYOPEN,  ARRAYCLOSE,    /* 44. ... */
  /* 
   * The next two states are for parameter prototypes
   * that do not include the parameter name.
   * In these cases the prototype is not listed as
   * a parameter.
   */
  ASTERISK,   ARGSEPARATOR,  /* 45. */
  ASTERISK,   CLOSEPAREN,    /* 46. */
  OPENPAREN,  CHAR,          /* 47. */
  OPENPAREN,  INTEGER,       /* 48. */
  OPENPAREN,  FLOAT,         /* 49. */
  OPENPAREN,       DOUBLE,                /* 50. */
  OPENPAREN,       LONG,                  /* 51. */
  OPENPAREN,       LONGLONG,             /* 52. */
  OPENPAREN,       AMPERSAND,           /* 53. */
  OPENPAREN,       EXCLAM,              /* 54. */
  OPENPAREN,       INCREMENT,           /* 55. */
  OPENPAREN,       DECREMENT,           /* 56. */
  OPENPAREN,       BIT_COMP,            /* 57. */
  OPENPAREN,       ASTERISK,            /* 58. */
  /*
   *  More closing paren states.
   */
  CHAR,            CLOSEPAREN,          /* 59. */
  INTEGER,         CLOSEPAREN,          /* 60. */
  FLOAT,           CLOSEPAREN,          /* 61. */
  DOUBLE,          CLOSEPAREN,          /* 62. */
  LONG,            CLOSEPAREN,          /* 63. */
  LONGLONG,        CLOSEPAREN,          /* 64. */
  INCREMENT,       CLOSEPAREN,          /* 65. */
  DECREMENT,       CLOSEPAREN,          /* 66. */

  /*
   *  States for args that end at the argument separator.
   */
  CHAR,            ARGSEPARATOR,        /* 67. */
  INTEGER,         ARGSEPARATOR,        /* 68. */
  FLOAT,           ARGSEPARATOR,        /* 69. */
  DOUBLE,          ARGSEPARATOR,        /* 70. */
  LONG,            ARGSEPARATOR,        /* 71. */
  LONGLONG,        ARGSEPARATOR,        /* 72. */
  INCREMENT,       ARGSEPARATOR,        /* 73. */
  DECREMENT,       ARGSEPARATOR,        /* 74. */
  LITERAL,         ARGSEPARATOR,        /* 75. */
  LITERAL_CHAR,    ARGSEPARATOR,        /* 76. */

  /* 
   */
  LABEL,           DEREF,               /* 77. */
  DEREF,           LABEL,               /* 78. */

  ARGSEPARATOR,    LITERAL,             /* 79. */
  ARGSEPARATOR,    LITERAL_CHAR,        /* 80. */
  ARGSEPARATOR,    CHAR,                /* 81. */
  ARGSEPARATOR,    INTEGER,             /* 82. */
  ARGSEPARATOR,    FLOAT,               /* 83. */
  ARGSEPARATOR,    DOUBLE,              /* 84. */
  ARGSEPARATOR,    LONG,                /* 85. */
  ARGSEPARATOR,    LONGLONG,            /* 86. */
  ARGSEPARATOR,    AMPERSAND,           /* 87. */
  ARGSEPARATOR,    EXCLAM,              /* 88. */
  ARGSEPARATOR,    INCREMENT,           /* 89. */
  ARGSEPARATOR,    DECREMENT,           /* 90. */
  ARGSEPARATOR,    BIT_COMP,            /* 91. */
  ARGSEPARATOR,    ASTERISK,            /* 92. */

  AMPERSAND,       LABEL,               /* 93. */
  LABEL,           LABEL,               /* 94. */
  /*
   *   More unusual states.
   */
  LITERAL_CHAR,    CLOSEPAREN,          /* 95. */
  ARGSEPARATOR,    OPENPAREN,           /* 96. */
  OPENPAREN,       OPENPAREN,           /* 97. */
  CLOSEPAREN,      INTEGER,             /* 98. */
  ASTERISK,        CLOSEPAREN,          /* 99. */
  OPENPAREN,       LITERAL_CHAR,        /* 100. */
  CLOSEPAREN,      LABEL,               /* 101. */
  LABEL,           PERIOD,              /* 102. */
  PERIOD,          LABEL,               /* 103. */

  /*
   *  States for parameter expressions.
   */
  CLOSEPAREN,      DEREF,               /* 104. */
  CLOSEPAREN,      PLUS,                /* 105. */
  CLOSEPAREN,      MINUS,               /* 106. */
  CLOSEPAREN,      ASTERISK,            /* 107. */
  CLOSEPAREN,      DIVIDE,              /* 109. */
  CLOSEPAREN,      MODULUS,             /* 110. */
  CLOSEPAREN,      ASL,                 /* 111. */
  CLOSEPAREN,      ASR,                 /* 112. */
  CLOSEPAREN,      LT,                  /* 113. */
  CLOSEPAREN,      LE,                  /* 114. */
  CLOSEPAREN,      GT,                  /* 115. */
  CLOSEPAREN,      GE,                  /* 116. */
  CLOSEPAREN,      BOOLEAN_EQ,          /* 117. */
  CLOSEPAREN,      INEQUALITY,          /* 118. */
  CLOSEPAREN,      BIT_AND,             /* 119. */
  CLOSEPAREN,      BIT_OR,              /* 120. */
  CLOSEPAREN,      BIT_XOR,             /* 121. */
  CLOSEPAREN,      BOOLEAN_AND,         /* 122. */
  CLOSEPAREN,      BOOLEAN_OR,          /* 123. */
  CLOSEPAREN,      EQ,                  /* 124. */
  CLOSEPAREN,      ASR_ASSIGN,          /* 125. */
  CLOSEPAREN,      ASL_ASSIGN,          /* 126. */
  CLOSEPAREN,      PLUS_ASSIGN,         /* 127. */
  CLOSEPAREN,      MINUS_ASSIGN,        /* 128. */
  CLOSEPAREN,      MULT_ASSIGN,         /* 129. */
  CLOSEPAREN,      DIV_ASSIGN,          /* 130. */
  CLOSEPAREN,      BIT_AND_ASSIGN,      /* 131. */
  CLOSEPAREN,      BIT_OR_ASSIGN,       /* 132. */
  CLOSEPAREN,      BIT_XOR_ASSIGN,      /* 130. */

  DEREF, LABEL,              /* 131. */
  PLUS, LABEL,               /* 132. */
  MINUS, LABEL,              /* 133. */
  ASTERISK, LABEL,           /* 134. */
  DIVIDE, LABEL,             /* 135. */
  MODULUS, LABEL,            /* 136. */
  ASL, LABEL,                /* 137. */
  ASR, LABEL,                /* 138. */
  LT, LABEL,                 /* 139. */
  LE, LABEL,                 /* 140. */
  GT, LABEL,                 /* 141. */
  GE, LABEL,                 /* 142. */
  BOOLEAN_EQ, LABEL,         /* 143. */
  INEQUALITY, LABEL,         /* 144. */
  BIT_AND, LABEL,            /* 145. */
  BIT_OR, LABEL,             /* 146. */
  BIT_XOR, LABEL,            /* 147. */
  BOOLEAN_AND, LABEL,        /* 148. */
  BOOLEAN_OR, LABEL,         /* 149. */
  EQ, LABEL,                 /* 150. */
  ASR_ASSIGN, LABEL,         /* 151. */
  ASL_ASSIGN, LABEL,         /* 152. */
  PLUS_ASSIGN, LABEL,        /* 153. */
  MINUS_ASSIGN, LABEL,       /* 154. */
  MULT_ASSIGN, LABEL,        /* 155. */
  DIV_ASSIGN, LABEL,         /* 156. */
  BIT_AND_ASSIGN, LABEL,     /* 157. */
  BIT_OR_ASSIGN, LABEL,      /* 158. */
  BIT_XOR_ASSIGN, LABEL,     /* 159. */
  CONDITIONAL, LABEL,        /* 160. */
  COLON, LABEL,              /* 161. */
  AMPERSAND, LABEL,          /* 162. */

  DEREF, OPENPAREN,              /* 163. */
  PLUS, OPENPAREN,               /* 164. */
  MINUS, OPENPAREN,              /* 165. */
  ASTERISK, OPENPAREN,           /* 166. */
  DIVIDE, OPENPAREN,             /* 167. */
  MODULUS, OPENPAREN,            /* 168. */
  ASL, OPENPAREN,                /* 169. */
  ASR, OPENPAREN,                /* 170. */
  LT, OPENPAREN,                 /* 171. */
  LE, OPENPAREN,                 /* 172. */
  GT, OPENPAREN,                 /* 173. */
  GE, OPENPAREN,                 /* 174. */
  BOOLEAN_EQ, OPENPAREN,         /* 175. */
  INEQUALITY, OPENPAREN,         /* 176. */
  BIT_AND, OPENPAREN,            /* 177. */
  BIT_OR, OPENPAREN,             /* 178. */
  BIT_XOR, OPENPAREN,            /* 179. */
  BOOLEAN_AND, OPENPAREN,        /* 180. */
  BOOLEAN_OR, OPENPAREN,         /* 181. */
  EQ, OPENPAREN,                 /* 182. */
  ASR_ASSIGN, OPENPAREN,         /* 183. */
  ASL_ASSIGN, OPENPAREN,         /* 184. */
  PLUS_ASSIGN, OPENPAREN,        /* 185. */
  MINUS_ASSIGN, OPENPAREN,       /* 186. */
  MULT_ASSIGN, OPENPAREN,        /* 187. */
  DIV_ASSIGN, OPENPAREN,         /* 188. */
  BIT_AND_ASSIGN, OPENPAREN,     /* 189. */
  BIT_OR_ASSIGN, OPENPAREN,      /* 190. */
  BIT_XOR_ASSIGN, OPENPAREN,     /* 191. */
  CONDITIONAL, OPENPAREN,        /* 192. */
  COLON, OPENPAREN,              /* 193. */
  AMPERSAND, OPENPAREN,          /* 194. */

  DEREF, CHAR,              /* 195. */
  PLUS, CHAR,               /* 196. */
  MINUS, CHAR,              /* 197. */
  ASTERISK, CHAR,           /* 198. */
  DIVIDE, CHAR,             /* 199. */
  MODULUS, CHAR,            /* 200. */
  ASL, CHAR,                /* 201. */
  ASR, CHAR,                /* 202. */
  LT, CHAR,                 /* 203. */
  LE, CHAR,                 /* 204. */
  GT, CHAR,                 /* 205. */
  GE, CHAR,                 /* 206. */
  BOOLEAN_EQ, CHAR,         /* 207. */
  INEQUALITY, CHAR,         /* 208. */
  BIT_AND, CHAR,            /* 209. */
  BIT_OR, CHAR,             /* 210. */
  BIT_XOR, CHAR,            /* 211. */
  BOOLEAN_AND, CHAR,        /* 212. */
  BOOLEAN_OR, CHAR,         /* 213. */
  EQ, CHAR,                 /* 214. */
  ASR_ASSIGN, CHAR,         /* 215. */
  ASL_ASSIGN, CHAR,         /* 216. */
  PLUS_ASSIGN, CHAR,        /* 217. */
  MINUS_ASSIGN, CHAR,       /* 218. */
  MULT_ASSIGN, CHAR,        /* 219. */
  DIV_ASSIGN, CHAR,         /* 220. */
  BIT_AND_ASSIGN, CHAR,     /* 221. */
  BIT_OR_ASSIGN, CHAR,      /* 222. */
  BIT_XOR_ASSIGN, CHAR,     /* 223. */
  CONDITIONAL, CHAR,        /* 224. */
  COLON, CHAR,              /* 225. */

  DEREF, LITERAL,              /* 226. */
  PLUS, LITERAL,               /* 227. */
  MINUS, LITERAL,              /* 228. */
  ASTERISK, LITERAL,           /* 229. */
  DIVIDE, LITERAL,             /* 230. */
  MODULUS, LITERAL,            /* 231. */
  ASL, LITERAL,                /* 232. */
  ASR, LITERAL,                /* 233. */
  LT, LITERAL,                 /* 234. */
  LE, LITERAL,                 /* 235. */
  GT, LITERAL,                 /* 236. */
  GE, LITERAL,                 /* 237. */
  BOOLEAN_EQ, LITERAL,         /* 238. */
  INEQUALITY, LITERAL,         /* 239. */
  BIT_AND, LITERAL,            /* 240. */
  BIT_OR, LITERAL,             /* 241. */
  BIT_XOR, LITERAL,            /* 242. */
  BOOLEAN_AND, LITERAL,        /* 243. */
  BOOLEAN_OR, LITERAL,         /* 244. */
  EQ, LITERAL,                 /* 245. */
  ASR_ASSIGN, LITERAL,         /* 246. */
  ASL_ASSIGN, LITERAL,         /* 247. */
  PLUS_ASSIGN, LITERAL,        /* 248. */
  MINUS_ASSIGN, LITERAL,       /* 249. */
  MULT_ASSIGN, LITERAL,        /* 250. */
  DIV_ASSIGN, LITERAL,         /* 251. */
  BIT_AND_ASSIGN, LITERAL,     /* 252. */
  BIT_OR_ASSIGN, LITERAL,      /* 253. */
  BIT_XOR_ASSIGN, LITERAL,     /* 254. */
  CONDITIONAL, LITERAL,        /* 255. */
  COLON, LITERAL,              /* 256. */

  DEREF, LITERAL_CHAR,              /* 257. */
  PLUS, LITERAL_CHAR,               /* 258. */
  MINUS, LITERAL_CHAR,              /* 259. */
  ASTERISK, LITERAL_CHAR,           /* 260. */
  DIVIDE, LITERAL_CHAR,             /* 261. */
  MODULUS, LITERAL_CHAR,            /* 262. */
  ASL, LITERAL_CHAR,                /* 263. */
  ASR, LITERAL_CHAR,                /* 264. */
  LT, LITERAL_CHAR,                 /* 265. */
  LE, LITERAL_CHAR,                 /* 266. */
  GT, LITERAL_CHAR,                 /* 267. */
  GE, LITERAL_CHAR,                 /* 268. */
  BOOLEAN_EQ, LITERAL_CHAR,         /* 269. */
  INEQUALITY, LITERAL_CHAR,         /* 270. */
  BIT_AND, LITERAL_CHAR,            /* 271. */
  BIT_OR, LITERAL_CHAR,             /* 272. */
  BIT_XOR, LITERAL_CHAR,            /* 273. */
  BOOLEAN_AND, LITERAL_CHAR,        /* 274. */
  BOOLEAN_OR, LITERAL_CHAR,         /* 275. */
  EQ, LITERAL_CHAR,                 /* 276. */
  ASR_ASSIGN, LITERAL_CHAR,         /* 277. */
  ASL_ASSIGN, LITERAL_CHAR,         /* 278. */
  PLUS_ASSIGN, LITERAL_CHAR,        /* 279. */
  MINUS_ASSIGN, LITERAL_CHAR,       /* 280. */
  MULT_ASSIGN, LITERAL_CHAR,        /* 281. */
  DIV_ASSIGN, LITERAL_CHAR,         /* 282. */
  BIT_AND_ASSIGN, LITERAL_CHAR,     /* 283. */
  BIT_OR_ASSIGN, LITERAL_CHAR,      /* 284. */
  BIT_XOR_ASSIGN, LITERAL_CHAR,     /* 285. */
  CONDITIONAL, LITERAL_CHAR,        /* 286. */
  COLON, LITERAL_CHAR,              /* 287. */

  DEREF, INTEGER,              /* 288. */
  PLUS, INTEGER,               /* 289. */
  MINUS, INTEGER,              /* 290. */
  ASTERISK, INTEGER,           /* 291. */
  DIVIDE, INTEGER,             /* 292. */
  MODULUS, INTEGER,            /* 293. */
  ASL, INTEGER,                /* 294. */
  ASR, INTEGER,                /* 295. */
  LT, INTEGER,                 /* 296. */
  LE, INTEGER,                 /* 297. */
  GT, INTEGER,                 /* 298. */
  GE, INTEGER,                 /* 299. */
  BOOLEAN_EQ, INTEGER,         /* 300. */
  INEQUALITY, INTEGER,         /* 301. */
  BIT_AND, INTEGER,            /* 302. */
  BIT_OR, INTEGER,             /* 303. */
  BIT_XOR, INTEGER,            /* 304. */
  BOOLEAN_AND, INTEGER,        /* 305. */
  BOOLEAN_OR, INTEGER,         /* 306. */
  EQ, INTEGER,                 /* 307. */
  ASR_ASSIGN, INTEGER,         /* 308. */
  ASL_ASSIGN, INTEGER,         /* 309. */
  PLUS_ASSIGN, INTEGER,        /* 310. */
  MINUS_ASSIGN, INTEGER,       /* 311. */
  MULT_ASSIGN, INTEGER,        /* 312. */
  DIV_ASSIGN, INTEGER,         /* 313. */
  BIT_AND_ASSIGN, INTEGER,     /* 314. */
  BIT_OR_ASSIGN, INTEGER,      /* 315. */
  BIT_XOR_ASSIGN, INTEGER,     /* 316. */
  CONDITIONAL, INTEGER,        /* 317. */
  COLON, INTEGER,              /* 318. */

  DEREF, DOUBLE,              /* 319. */
  PLUS, DOUBLE,               /* 320. */
  MINUS, DOUBLE,              /* 321. */
  ASTERISK, DOUBLE,           /* 322. */
  DIVIDE, DOUBLE,             /* 323. */
  MODULUS, DOUBLE,            /* 324. */
  ASL, DOUBLE,                /* 325. */
  ASR, DOUBLE,                /* 326. */
  LT, DOUBLE,                 /* 327. */
  LE, DOUBLE,                 /* 328. */
  GT, DOUBLE,                 /* 329. */
  GE, DOUBLE,                 /* 330. */
  BOOLEAN_EQ, DOUBLE,         /* 331. */
  INEQUALITY, DOUBLE,         /* 332. */
  BIT_AND, DOUBLE,            /* 333. */
  BIT_OR, DOUBLE,             /* 334. */
  BIT_XOR, DOUBLE,            /* 335. */
  BOOLEAN_AND, DOUBLE,        /* 336. */
  BOOLEAN_OR, DOUBLE,         /* 337. */
  EQ, DOUBLE,                 /* 338. */
  ASR_ASSIGN, DOUBLE,         /* 339. */
  ASL_ASSIGN, DOUBLE,         /* 340. */
  PLUS_ASSIGN, DOUBLE,        /* 341. */
  MINUS_ASSIGN, DOUBLE,       /* 342. */
  MULT_ASSIGN, DOUBLE,        /* 343. */
  DIV_ASSIGN, DOUBLE,         /* 344. */
  BIT_AND_ASSIGN, DOUBLE,     /* 345. */
  BIT_OR_ASSIGN, DOUBLE,      /* 346. */
  BIT_XOR_ASSIGN, DOUBLE,     /* 347. */
  CONDITIONAL, DOUBLE,        /* 348. */
  COLON, DOUBLE,              /* 349. */

  DEREF, LONG,              /* 350. */
  PLUS, LONG,               /* 351. */
  MINUS, LONG,              /* 352. */
  ASTERISK, LONG,           /* 353. */
  DIVIDE, LONG,             /* 354. */
  MODULUS, LONG,            /* 355. */
  ASL, LONG,                /* 356. */
  ASR, LONG,                /* 357. */
  LT, LONG,                 /* 358. */
  LE, LONG,                 /* 359. */
  GT, LONG,                 /* 360. */
  GE, LONG,                 /* 361. */
  BOOLEAN_EQ, LONG,         /* 362. */
  INEQUALITY, LONG,         /* 363. */
  BIT_AND, LONG,            /* 364. */
  BIT_OR, LONG,             /* 365. */
  BIT_XOR, LONG,            /* 366. */
  BOOLEAN_AND, LONG,        /* 367. */
  BOOLEAN_OR, LONG,         /* 368. */
  EQ, LONG,                 /* 369. */
  ASR_ASSIGN, LONG,         /* 370. */
  ASL_ASSIGN, LONG,         /* 371. */
  PLUS_ASSIGN, LONG,        /* 372. */
  MINUS_ASSIGN, LONG,       /* 373. */
  MULT_ASSIGN, LONG,        /* 374. */
  DIV_ASSIGN, LONG,         /* 375. */
  BIT_AND_ASSIGN, LONG,     /* 376. */
  BIT_OR_ASSIGN, LONG,      /* 377. */
  BIT_XOR_ASSIGN, LONG,     /* 378. */
  CONDITIONAL, LONG,        /* 379. */
  COLON, LONG,              /* 380. */
  AMPERSAND, LONG,          /* 381. */

  DEREF, LONGLONG,              /* 131. */
  PLUS, LONGLONG,               /* 132. */
  MINUS, LONGLONG,              /* 133. */
  ASTERISK, LONGLONG,           /* 134. */
  DIVIDE, LONGLONG,             /* 135. */
  MODULUS, LONGLONG,            /* 136. */
  ASL, LONGLONG,                /* 137. */
  ASR, LONGLONG,                /* 138. */
  LT, LONGLONG,                 /* 139. */
  LE, LONGLONG,                 /* 140. */
  GT, LONGLONG,                 /* 141. */
  GE, LONGLONG,                 /* 142. */
  BOOLEAN_EQ, LONGLONG,         /* 143. */
  INEQUALITY, LONGLONG,         /* 144. */
  BIT_AND, LONGLONG,          /* 145. */
  BIT_OR, LONGLONG,             /* 146. */
  BIT_XOR, LONGLONG,            /* 147. */
  BOOLEAN_AND, LONGLONG,        /* 148. */
  BOOLEAN_OR, LONGLONG,         /* 149. */
  EQ, LONGLONG,                 /* 150. */
  ASR_ASSIGN, LONGLONG,         /* 151. */
  ASL_ASSIGN, LONGLONG,         /* 152. */
  PLUS_ASSIGN, LONGLONG,        /* 153. */
  MINUS_ASSIGN, LONGLONG,       /* 154. */
  MULT_ASSIGN, LONGLONG,        /* 155. */
  DIV_ASSIGN, LONGLONG,         /* 156. */
  BIT_AND_ASSIGN, LONGLONG,     /* 157. */
  BIT_OR_ASSIGN, LONGLONG,      /* 158. */
  BIT_XOR_ASSIGN, LONGLONG,     /* 159. */
  CONDITIONAL, LONGLONG,        /* 160. */
  COLON, LONGLONG,              /* 161. */
  AMPERSAND, LONGLONG,          /* 145. */

  CHAR,      DEREF,               /* 104. */
  CHAR,      PLUS,                /* 105. */
  CHAR,      MINUS,               /* 106. */
  CHAR,      ASTERISK,            /* 107. */
  CHAR,      DIVIDE,              /* 109. */
  CHAR,      MODULUS,             /* 110. */
  CHAR,      ASL,                 /* 111. */
  CHAR,      ASR,                 /* 112. */
  CHAR,      LT,                  /* 113. */
  CHAR,      LE,                  /* 114. */
  CHAR,      GT,                  /* 115. */
  CHAR,      GE,                  /* 116. */
  CHAR,      BOOLEAN_EQ,          /* 117. */
  CHAR,      INEQUALITY,          /* 118. */
  CHAR,      AMPERSAND,           /* 119. */
  CHAR,      BIT_OR,              /* 120. */
  CHAR,      BIT_XOR,             /* 121. */
  CHAR,      BOOLEAN_AND,         /* 122. */
  CHAR,      BOOLEAN_OR,          /* 123. */
  CHAR,      EQ,                  /* 124. */
  CHAR,      ASR_ASSIGN,          /* 125. */
  CHAR,      ASL_ASSIGN,          /* 126. */
  CHAR,      PLUS_ASSIGN,         /* 127. */
  CHAR,      MINUS_ASSIGN,        /* 128. */
  CHAR,      MULT_ASSIGN,         /* 129. */
  CHAR,      DIV_ASSIGN,          /* 130. */
  CHAR,      BIT_AND_ASSIGN,      /* 131. */
  CHAR,      BIT_OR_ASSIGN,       /* 132. */
  CHAR,      BIT_XOR_ASSIGN,      /* 130. */
  CHAR,      CONDITIONAL,      /* 130. */
  CHAR,      COLON,      /* 130. */

  LABEL,      DEREF,               /* 104. */
  LABEL,      PLUS,                /* 105. */
  LABEL,      MINUS,               /* 106. */
  LABEL,      ASTERISK,            /* 107. */
  LABEL,      DIVIDE,              /* 109. */
  LABEL,      MODULUS,             /* 110. */
  LABEL,      ASL,                 /* 111. */
  LABEL,      ASR,                 /* 112. */
  LABEL,      LT,                  /* 113. */
  LABEL,      LE,                  /* 114. */
  LABEL,      GT,                  /* 115. */
  LABEL,      GE,                  /* 116. */
  LABEL,      BOOLEAN_EQ,          /* 117. */
  LABEL,      INEQUALITY,          /* 118. */
  LABEL,      BIT_AND,             /* 119. */
  LABEL,      BIT_OR,              /* 120. */
  LABEL,      BIT_XOR,             /* 121. */
  LABEL,      BOOLEAN_AND,         /* 122. */
  LABEL,      BOOLEAN_OR,          /* 123. */
  LABEL,      EQ,                  /* 124. */
  LABEL,      ASR_ASSIGN,          /* 125. */
  LABEL,      ASL_ASSIGN,          /* 126. */
  LABEL,      PLUS_ASSIGN,         /* 127. */
  LABEL,      MINUS_ASSIGN,        /* 128. */
  LABEL,      MULT_ASSIGN,         /* 129. */
  LABEL,      DIV_ASSIGN,          /* 130. */
  LABEL,      BIT_AND_ASSIGN,      /* 131. */
  LABEL,      BIT_OR_ASSIGN,       /* 132. */
  LABEL,      BIT_XOR_ASSIGN,      /* 130. */
  LABEL,      CONDITIONAL,      /* 130. */
  LABEL,      COLON,      /* 130. */
  LABEL,      INTEGER,
  LABEL,      DOUBLE,
  LABEL,      LONG,
  LABEL,      LONGLONG,

  LITERAL,      DEREF,               /* 104. */
  LITERAL,      PLUS,                /* 105. */
  LITERAL,      MINUS,               /* 106. */
  LITERAL,      ASTERISK,            /* 107. */
  LITERAL,      DIVIDE,              /* 109. */
  LITERAL,      MODULUS,             /* 110. */
  LITERAL,      ASL,                 /* 111. */
  LITERAL,      ASR,                 /* 112. */
  LITERAL,      LT,                  /* 113. */
  LITERAL,      LE,                  /* 114. */
  LITERAL,      GT,                  /* 115. */
  LITERAL,      GE,                  /* 116. */
  LITERAL,      BOOLEAN_EQ,          /* 117. */
  LITERAL,      INEQUALITY,          /* 118. */
  LITERAL,      BIT_AND,           /* 119. */
  LITERAL,      BIT_OR,              /* 120. */
  LITERAL,      BIT_XOR,             /* 121. */
  LITERAL,      BOOLEAN_AND,         /* 122. */
  LITERAL,      BOOLEAN_OR,          /* 123. */
  LITERAL,      EQ,                  /* 124. */
  LITERAL,      ASR_ASSIGN,          /* 125. */
  LITERAL,      ASL_ASSIGN,          /* 126. */
  LITERAL,      PLUS_ASSIGN,         /* 127. */
  LITERAL,      MINUS_ASSIGN,        /* 128. */
  LITERAL,      MULT_ASSIGN,         /* 129. */
  LITERAL,      DIV_ASSIGN,          /* 130. */
  LITERAL,      BIT_AND_ASSIGN,      /* 131. */
  LITERAL,      BIT_OR_ASSIGN,       /* 132. */
  LITERAL,      BIT_XOR_ASSIGN,      /* 130. */
  LITERAL,      CONDITIONAL,      /* 130. */
  LITERAL,      COLON,      /* 130. */

  LITERAL_CHAR,      DEREF,               /* 104. */
  LITERAL_CHAR,      PLUS,                /* 105. */
  LITERAL_CHAR,      MINUS,               /* 106. */
  LITERAL_CHAR,      ASTERISK,            /* 107. */
  LITERAL_CHAR,      DIVIDE,              /* 109. */
  LITERAL_CHAR,      MODULUS,             /* 110. */
  LITERAL_CHAR,      ASL,                 /* 111. */
  LITERAL_CHAR,      ASR,                 /* 112. */
  LITERAL_CHAR,      LT,                  /* 113. */
  LITERAL_CHAR,      LE,                  /* 114. */
  LITERAL_CHAR,      GT,                  /* 115. */
  LITERAL_CHAR,      GE,                  /* 116. */
  LITERAL_CHAR,      BOOLEAN_EQ,          /* 117. */
  LITERAL_CHAR,      INEQUALITY,          /* 118. */
  LITERAL_CHAR,      BIT_AND,             /* 119. */
  LITERAL_CHAR,      BIT_OR,              /* 120. */
  LITERAL_CHAR,      BIT_XOR,             /* 121. */
  LITERAL_CHAR,      BOOLEAN_AND,         /* 122. */
  LITERAL_CHAR,      BOOLEAN_OR,          /* 123. */
  LITERAL_CHAR,      EQ,                  /* 124. */
  LITERAL_CHAR,      ASR_ASSIGN,          /* 125. */
  LITERAL_CHAR,      ASL_ASSIGN,          /* 126. */
  LITERAL_CHAR,      PLUS_ASSIGN,         /* 127. */
  LITERAL_CHAR,      MINUS_ASSIGN,        /* 128. */
  LITERAL_CHAR,      MULT_ASSIGN,         /* 129. */
  LITERAL_CHAR,      DIV_ASSIGN,          /* 130. */
  LITERAL_CHAR,      BIT_AND_ASSIGN,      /* 131. */
  LITERAL_CHAR,      BIT_OR_ASSIGN,       /* 132. */
  LITERAL_CHAR,      BIT_XOR_ASSIGN,      /* 130. */
  LITERAL_CHAR,      CONDITIONAL,      /* 130. */
  LITERAL_CHAR,      COLON,      /* 130. */

  INTEGER,      DEREF,               /* 104. */
  INTEGER,      PLUS,                /* 105. */
  INTEGER,      MINUS,               /* 106. */
  INTEGER,      ASTERISK,            /* 107. */
  INTEGER,      DIVIDE,              /* 109. */
  INTEGER,      MODULUS,             /* 110. */
  INTEGER,      ASL,                 /* 111. */
  INTEGER,      ASR,                 /* 112. */
  INTEGER,      LT,                  /* 113. */
  INTEGER,      LE,                  /* 114. */
  INTEGER,      GT,                  /* 115. */
  INTEGER,      GE,                  /* 116. */
  INTEGER,      BOOLEAN_EQ,          /* 117. */
  INTEGER,      INEQUALITY,          /* 118. */
  INTEGER,      BIT_AND,             /* 119. */
  INTEGER,      BIT_OR,              /* 120. */
  INTEGER,      BIT_XOR,             /* 121. */
  INTEGER,      BOOLEAN_AND,         /* 122. */
  INTEGER,      BOOLEAN_OR,          /* 123. */
  INTEGER,      EQ,                  /* 124. */
  INTEGER,      ASR_ASSIGN,          /* 125. */
  INTEGER,      ASL_ASSIGN,          /* 126. */
  INTEGER,      PLUS_ASSIGN,         /* 127. */
  INTEGER,      MINUS_ASSIGN,        /* 128. */
  INTEGER,      MULT_ASSIGN,         /* 129. */
  INTEGER,      DIV_ASSIGN,          /* 130. */
  INTEGER,      BIT_AND_ASSIGN,      /* 131. */
  INTEGER,      BIT_OR_ASSIGN,       /* 132. */
  INTEGER,      BIT_XOR_ASSIGN,      /* 130. */
  INTEGER,      CONDITIONAL,      /* 130. */
  INTEGER,      COLON,      /* 130. */

  DOUBLE,      DEREF,               /* 104. */
  DOUBLE,      PLUS,                /* 105. */
  DOUBLE,      MINUS,               /* 106. */
  DOUBLE,      ASTERISK,            /* 107. */
  DOUBLE,      DIVIDE,              /* 109. */
  DOUBLE,      MODULUS,             /* 110. */
  DOUBLE,      ASL,                 /* 111. */
  DOUBLE,      ASR,                 /* 112. */
  DOUBLE,      LT,                  /* 113. */
  DOUBLE,      LE,                  /* 114. */
  DOUBLE,      GT,                  /* 115. */
  DOUBLE,      GE,                  /* 116. */
  DOUBLE,      BOOLEAN_EQ,          /* 117. */
  DOUBLE,      INEQUALITY,          /* 118. */
  DOUBLE,      BIT_AND,             /* 119. */
  DOUBLE,      BIT_OR,              /* 120. */
  DOUBLE,      BIT_XOR,             /* 121. */
  DOUBLE,      BOOLEAN_AND,         /* 122. */
  DOUBLE,      BOOLEAN_OR,          /* 123. */
  DOUBLE,      EQ,                  /* 124. */
  DOUBLE,      ASR_ASSIGN,          /* 125. */
  DOUBLE,      ASL_ASSIGN,          /* 126. */
  DOUBLE,      PLUS_ASSIGN,         /* 127. */
  DOUBLE,      MINUS_ASSIGN,        /* 128. */
  DOUBLE,      MULT_ASSIGN,         /* 129. */
  DOUBLE,      DIV_ASSIGN,          /* 130. */
  DOUBLE,      BIT_AND_ASSIGN,      /* 131. */
  DOUBLE,      BIT_OR_ASSIGN,       /* 132. */
  DOUBLE,      BIT_XOR_ASSIGN,      /* 130. */
  DOUBLE,      CONDITIONAL,      /* 130. */
  DOUBLE,      COLON,      /* 130. */

  LONG,      DEREF,               /* 104. */
  LONG,      PLUS,                /* 105. */
  LONG,      MINUS,               /* 106. */
  LONG,      ASTERISK,            /* 107. */
  LONG,      DIVIDE,              /* 109. */
  LONG,      MODULUS,             /* 110. */
  LONG,      ASL,                 /* 111. */
  LONG,      ASR,                 /* 112. */
  LONG,      LT,                  /* 113. */
  LONG,      LE,                  /* 114. */
  LONG,      GT,                  /* 115. */
  LONG,      GE,                  /* 116. */
  LONG,      BOOLEAN_EQ,          /* 117. */
  LONG,      INEQUALITY,          /* 118. */
  LONG,      BIT_AND,             /* 119. */
  LONG,      BIT_OR,              /* 120. */
  LONG,      BIT_XOR,             /* 121. */
  LONG,      BOOLEAN_AND,         /* 122. */
  LONG,      BOOLEAN_OR,          /* 123. */
  LONG,      EQ,                  /* 124. */
  LONG,      ASR_ASSIGN,          /* 125. */
  LONG,      ASL_ASSIGN,          /* 126. */
  LONG,      PLUS_ASSIGN,         /* 127. */
  LONG,      MINUS_ASSIGN,        /* 128. */
  LONG,      MULT_ASSIGN,         /* 129. */
  LONG,      DIV_ASSIGN,          /* 130. */
  LONG,      BIT_AND_ASSIGN,      /* 131. */
  LONG,      BIT_OR_ASSIGN,       /* 132. */
  LONG,      BIT_XOR_ASSIGN,      /* 130. */
  LONG,      CONDITIONAL,      /* 130. */
  LONG,      COLON,      /* 130. */

  LONGLONG,      DEREF,               /* 104. */
  LONGLONG,      PLUS,                /* 105. */
  LONGLONG,      MINUS,               /* 106. */
  LONGLONG,      ASTERISK,            /* 107. */
  LONGLONG,      DIVIDE,              /* 109. */
  LONGLONG,      MODULUS,             /* 110. */
  LONGLONG,      ASL,                 /* 111. */
  LONGLONG,      ASR,                 /* 112. */
  LONGLONG,      LT,                  /* 113. */
  LONGLONG,      LE,                  /* 114. */
  LONGLONG,      GT,                  /* 115. */
  LONGLONG,      GE,                  /* 116. */
  LONGLONG,      BOOLEAN_EQ,          /* 117. */
  LONGLONG,      INEQUALITY,          /* 118. */
  LONGLONG,      BIT_AND,             /* 119. */
  LONGLONG,      BIT_OR,              /* 120. */
  LONGLONG,      BIT_XOR,             /* 121. */
  LONGLONG,      BOOLEAN_AND,         /* 122. */
  LONGLONG,      BOOLEAN_OR,          /* 123. */
  LONGLONG,      EQ,                  /* 124. */
  LONGLONG,      ASR_ASSIGN,          /* 125. */
  LONGLONG,      ASL_ASSIGN,          /* 126. */
  LONGLONG,      PLUS_ASSIGN,         /* 127. */
  LONGLONG,      MINUS_ASSIGN,        /* 128. */
  LONGLONG,      MULT_ASSIGN,         /* 129. */
  LONGLONG,      DIV_ASSIGN,          /* 130. */
  LONGLONG,      BIT_AND_ASSIGN,      /* 131. */
  LONGLONG,      BIT_OR_ASSIGN,       /* 132. */
  LONGLONG,      BIT_XOR_ASSIGN,      /* 130. */
  LONGLONG,      CONDITIONAL,      /* 130. */
  LONGLONG,      COLON,      /* 130. */

  LABEL,      DEREF,               /* 104. */
  LABEL,      PLUS,                /* 105. */
  LABEL,      MINUS,               /* 106. */
  LABEL,      ASTERISK,            /* 107. */
  LABEL,      DIVIDE,              /* 109. */
  LABEL,      MODULUS,             /* 110. */
  LABEL,      ASL,                 /* 111. */
  LABEL,      ASR,                 /* 112. */
  LABEL,      LT,                  /* 113. */
  LABEL,      LE,                  /* 114. */
  LABEL,      GT,                  /* 115. */
  LABEL,      GE,                  /* 116. */
  LABEL,      BOOLEAN_EQ,          /* 117. */
  LABEL,      INEQUALITY,          /* 118. */
  LABEL,      BIT_AND,           /* 119. */
  LABEL,      BIT_OR,              /* 120. */
  LABEL,      BIT_XOR,             /* 121. */
  LABEL,      BOOLEAN_AND,         /* 122. */
  LABEL,      BOOLEAN_OR,          /* 123. */
  LABEL,      EQ,                  /* 124. */
  LABEL,      ASR_ASSIGN,          /* 125. */
  LABEL,      ASL_ASSIGN,          /* 126. */
  LABEL,      PLUS_ASSIGN,         /* 127. */
  LABEL,      MINUS_ASSIGN,        /* 128. */
  LABEL,      MULT_ASSIGN,         /* 129. */
  LABEL,      DIV_ASSIGN,          /* 130. */
  LABEL,      BIT_AND_ASSIGN,      /* 131. */
  LABEL,      BIT_OR_ASSIGN,       /* 132. */
  LABEL,      BIT_XOR_ASSIGN,      /* 130. */
  LABEL,      CONDITIONAL,      /* 130. */
  LABEL,      COLON,      /* 130. */

  CLOSEPAREN,      DEREF,               /* 104. */
  CLOSEPAREN,      PLUS,                /* 105. */
  CLOSEPAREN,      MINUS,               /* 106. */
  CLOSEPAREN,      ASTERISK,            /* 107. */
  CLOSEPAREN,      DIVIDE,              /* 109. */
  CLOSEPAREN,      MODULUS,             /* 110. */
  CLOSEPAREN,      ASL,                 /* 111. */
  CLOSEPAREN,      ASR,                 /* 112. */
  CLOSEPAREN,      LT,                  /* 113. */
  CLOSEPAREN,      LE,                  /* 114. */
  CLOSEPAREN,      GT,                  /* 115. */
  CLOSEPAREN,      GE,                  /* 116. */
  CLOSEPAREN,      BOOLEAN_EQ,          /* 117. */
  CLOSEPAREN,      INEQUALITY,          /* 118. */
  CLOSEPAREN,      BIT_AND,           /* 119. */
  CLOSEPAREN,      BIT_OR,              /* 120. */
  CLOSEPAREN,      BIT_XOR,             /* 121. */
  CLOSEPAREN,      BOOLEAN_AND,         /* 122. */
  CLOSEPAREN,      BOOLEAN_OR,          /* 123. */
  CLOSEPAREN,      EQ,                  /* 124. */
  CLOSEPAREN,      ASR_ASSIGN,          /* 125. */
  CLOSEPAREN,      ASL_ASSIGN,          /* 126. */
  CLOSEPAREN,      PLUS_ASSIGN,         /* 127. */
  CLOSEPAREN,      MINUS_ASSIGN,        /* 128. */
  CLOSEPAREN,      MULT_ASSIGN,         /* 129. */
  CLOSEPAREN,      DIV_ASSIGN,          /* 130. */
  CLOSEPAREN,      BIT_AND_ASSIGN,      /* 131. */
  CLOSEPAREN,      BIT_OR_ASSIGN,       /* 132. */
  CLOSEPAREN,      BIT_XOR_ASSIGN,      /* 130. */
  CLOSEPAREN,      CONDITIONAL,      /* 130. */
  CLOSEPAREN,      COLON,      /* 130. */

  /* More unusual states. */
  EXCLAM, OPENPAREN,             /* 160. */
  EXCLAM, LABEL,             /* 160. */
  EXCLAM, CHAR,             /* 160. */
  EXCLAM, LITERAL,             /* 160. */
  EXCLAM, LITERAL_CHAR,             /* 160. */
  EXCLAM, INTEGER,             /* 160. */
  EXCLAM, DOUBLE,             /* 160. */
 EXCLAM, LONG,             /* 160. */
 EXCLAM, LONGLONG,             /* 160. */

  CLOSEPAREN, CONDITIONAL,       /* 161. */
  CLOSEPAREN, COLON,             /* 162. */
  ARRAYOPEN,  OPENPAREN,
  CLOSEPAREN, ARRAYCLOSE,
    /*
     *
     */
    LABEL, ARRAYOPEN,
    ARRAYOPEN, ARRAYCLOSE,
    ARRAYOPEN, OPENPAREN,
  ARRAYOPEN,      DEREF,               /* 104. */
  ARRAYOPEN,      PLUS,                /* 105. */
  ARRAYOPEN,      MINUS,               /* 106. */
  ARRAYOPEN,      ASTERISK,            /* 107. */
  ARRAYOPEN,      DIVIDE,              /* 109. */
  ARRAYOPEN,      MODULUS,             /* 110. */
  ARRAYOPEN,      ASL,                 /* 111. */
  ARRAYOPEN,      ASR,                 /* 112. */
  ARRAYOPEN,      LT,                  /* 113. */
  ARRAYOPEN,      LE,                  /* 114. */
  ARRAYOPEN,      GT,                  /* 115. */
  ARRAYOPEN,      GE,                  /* 116. */
  ARRAYOPEN,      BOOLEAN_EQ,          /* 117. */
  ARRAYOPEN,      INEQUALITY,          /* 118. */
  ARRAYOPEN,      AMPERSAND,           /* 119. */
  ARRAYOPEN,      BIT_OR,              /* 120. */
  ARRAYOPEN,      BIT_XOR,             /* 121. */
  ARRAYOPEN,      BOOLEAN_AND,         /* 122. */
  ARRAYOPEN,      BOOLEAN_OR,          /* 123. */
  ARRAYOPEN,      EQ,                  /* 124. */
  ARRAYOPEN,      ASR_ASSIGN,          /* 125. */
  ARRAYOPEN,      ASL_ASSIGN,          /* 126. */
  ARRAYOPEN,      PLUS_ASSIGN,         /* 127. */
  ARRAYOPEN,      MINUS_ASSIGN,        /* 128. */
  ARRAYOPEN,      MULT_ASSIGN,         /* 129. */
  ARRAYOPEN,      DIV_ASSIGN,          /* 130. */
  ARRAYOPEN,      BIT_AND_ASSIGN,      /* 131. */
  ARRAYOPEN,      BIT_OR_ASSIGN,       /* 132. */
  ARRAYOPEN,      BIT_XOR_ASSIGN,      /* 130. */
  ARRAYOPEN,      CONDITIONAL,      /* 130. */
  ARRAYOPEN,      COLON,      /* 130. */

    CHAR, ARRAYCLOSE,
    LABEL, ARRAYCLOSE,
    LITERAL, ARRAYCLOSE,
    LITERAL_CHAR, ARRAYCLOSE,
    INTEGER, ARRAYCLOSE,
    DOUBLE, ARRAYCLOSE,
    LONG, ARRAYCLOSE,
    LONGLONG, ARRAYCLOSE,
    CLOSEPAREN, ARRAYCLOSE,
    CONDITIONAL, EXCLAM,
    COLON, EXCLAM,

    ARGSEPARATOR, SIZEOF,
    SIZEOF, OPENPAREN,
    ARRAYOPEN, SIZEOF,
    OPENPAREN, SIZEOF,
  DEREF, SIZEOF, 
  PLUS, SIZEOF,  
  MINUS, SIZEOF, 
  ASTERISK, SIZEOF,
  DIVIDE, SIZEOF,  
  MODULUS, SIZEOF, 
  ASL, SIZEOF,     
  ASR, SIZEOF,     
  LT, SIZEOF,      
  LE, SIZEOF,      
  GT, SIZEOF,      
  GE, SIZEOF,      
  BOOLEAN_EQ, SIZEOF, 
  INEQUALITY, SIZEOF, 
  BIT_AND, SIZEOF,    
  BIT_OR, SIZEOF,     
  BIT_XOR, SIZEOF,    
  BOOLEAN_AND, SIZEOF,
  BOOLEAN_OR, SIZEOF, 
  EQ, SIZEOF,         
  ASR_ASSIGN, SIZEOF, 
  ASL_ASSIGN, SIZEOF, 
  PLUS_ASSIGN, SIZEOF,
  MINUS_ASSIGN, SIZEOF,
  MULT_ASSIGN, SIZEOF, 
  DIV_ASSIGN, SIZEOF,  
  BIT_AND_ASSIGN, SIZEOF,
  BIT_OR_ASSIGN, SIZEOF, 
  BIT_XOR_ASSIGN, SIZEOF,
  CONDITIONAL, SIZEOF,   
  COLON, SIZEOF,         
    EXCLAM, SIZEOF,
    ASTERISK, ARRAYOPEN,
    
