text: /* parser generated by jison 0.4.18 */
  /*
    Returns a Parser object of the following structure:
  
    Parser: {
      yy: {}
    }
  
    Parser.prototype: {
      yy: {},
      trace: function(),
      symbols_: {associative list: name ==> number},
      terminals_: {associative list: number ==> name},
      productions_: [...],
      performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
      table: [...],
      defaultActions: {...},
      parseError: function(str, hash),
      parse: function(input),
  
      lexer: {
          EOF: 1,
          parseError: function(str, hash),
          setInput: function(input),
          input: function(),
          unput: function(str),
          more: function(),
          less: function(n),
          pastInput: function(),
          upcomingInput: function(),
          showPosition: function(),
          test_match: function(regex_match_array, rule_index),
          next: function(),
          lex: function(),
          begin: function(condition),
          popState: function(),
          _currentRules: function(),
          topState: function(),
          pushState: function(condition),
  
          options: {
              ranges: boolean           (optional: true ==> token location info will include a .range[] member)
              flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
              backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
          },
  
          performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
          rules: [...],
          conditions: {associative list: name ==> set},
      }
    }
  
  
    token location info (@$, _$, etc.): {
      first_line: n,
      last_line: n,
      first_column: n,
      last_column: n,
      range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
    }
  
  
    the parseError function receives a 'hash' object with these members for lexer and parser errors: {
      text:        (matched text)
      token:       (the produced terminal token, if any)
      line:        (yylineno)
    }
    while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
      loc:         (yylloc)
      expected:    (string describing the set of expected tokens)
      recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
    }
  */
  var sqlparser = (function(){
  var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[1,16],$V1=[1,17],$V2=[1,18],$V3=[1,19],$V4=[1,25],$V5=[1,20],$V6=[1,21],$V7=[1,22],$V8=[1,23],$V9=[1,26],$Va=[5,6],$Vb=[5,6,103,105],$Vc=[1,35],$Vd=[1,36],$Ve=[5,6,105],$Vf=[20,21,111],$Vg=[1,51],$Vh=[5,6,23,28,53,64,70,72,79,83,86,89,91,96,103,104,105,112,117,122,126,127,128,129,130,131,133,134,142,144,153,158],$Vi=[1,68],$Vj=[1,71],$Vk=[53,96],$Vl=[5,6,86,103,104,105,117,122],$Vm=[5,6,53,86,96,103,104,105,117,122],$Vn=[53,86],$Vo=[5,6,86,103,104,105,122],$Vp=[5,6,103,105,122],$Vq=[1,137],$Vr=[1,135],$Vs=[1,136],$Vt=[1,138],$Vu=[1,139],$Vv=[1,140],$Vw=[1,142],$Vx=[1,141],$Vy=[1,143],$Vz=[5,6,53],$VA=[5,6,103,104,105,122],$VB=[5,6,52,53,62,86,91],$VC=[5,6,52,53,62,86],$VD=[53,62],$VE=[2,90],$VF=[1,167],$VG=[1,168],$VH=[52,53],$VI=[2,58],$VJ=[5,6,103,104,105],$VK=[1,202],$VL=[1,203],$VM=[1,204],$VN=[1,198],$VO=[1,213],$VP=[1,214],$VQ=[1,211],$VR=[5,6,91],$VS=[1,243],$VT=[1,247],$VU=[1,245],$VV=[1,248],$VW=[1,249],$VX=[1,250],$VY=[1,251],$VZ=[1,252],$V_=[1,253],$V$=[5,6,83,91,103,104,105,122,126,127,128,129,130,131,133],$V01=[5,6,83,91,103,104,105,122,126,127,128,129,130,131,133,134],$V11=[1,256],$V21=[1,254],$V31=[1,257],$V41=[1,258],$V51=[1,259],$V61=[1,260],$V71=[1,261],$V81=[1,262],$V91=[1,263],$Va1=[5,6,83,91,103,105,126,127,128,129,130,131,133,134],$Vb1=[5,6,83,91,103,104,105,126,127,128,129,130,131,133,134],$Vc1=[1,289],$Vd1=[1,293],$Ve1=[1,291],$Vf1=[1,294],$Vg1=[1,295],$Vh1=[1,296],$Vi1=[1,297],$Vj1=[1,298],$Vk1=[1,299],$Vl1=[1,300],$Vm1=[1,326],$Vn1=[1,327],$Vo1=[1,330],$Vp1=[53,72],$Vq1=[2,228],$Vr1=[1,366],$Vs1=[5,6,53,86],$Vt1=[2,230],$Vu1=[1,379],$Vv1=[53,72,148];
  var parser = {trace: function trace() { },
  yy: {},
  symbols_: {"error":2,"main":3,"sql_stmt_list":4,"EOF":5,"SEMICOLON":6,"sql_stmt":7,"select_stmt":8,"insert_stmt":9,"update_stmt":10,"replace_stmt":11,"delete_stmt":12,"create_table_stmt":13,"show_tables_stmt":14,"drop_table_stmt":15,"describe_table_stmt":16,"drop_index_stmt":17,"scan_stmt":18,"name":19,"LITERAL":20,"BRALITERAL":21,"database_table_name":22,"DOT":23,"dynamodb_table_name":24,"database_index_name":25,"dynamodb_index_name":26,"signed_number":27,"NUMBER":28,"string_literal":29,"SINGLE_QUOTED_STRING":30,"DOUBLE_QUOTED_STRING":31,"XSTRING":32,"literal_value":33,"boolean":34,"TRUE":35,"FALSE":36,"boolean_value":37,"dynamodb_data_string":38,"dynamodb_raw_string":39,"dynamodb_data_number":40,"dynamodb_raw_number":41,"dynamodb_data_boolean":42,"dynamodb_raw_boolean":43,"dynamodb_data_null":44,"NULL":45,"dynamodb_raw_null":46,"dynamodb_data_undefined":47,"UNDEFINED":48,"dynamodb_data_array":49,"ARRAYLPAR":50,"array_list":51,"ARRAYRPAR":52,"COMMA":53,"array_value":54,"dynamodb_data_json":55,"dynamodb_raw_array":56,"array_list_raw":57,"array_value_raw":58,"dynamodb_raw_json":59,"JSONLPAR":60,"dynamodb_data_json_list":61,"JSONRPAR":62,"dynamodb_data_json_kv":63,"COLON":64,"dynamodb_data_json_list_raw":65,"dynamodb_raw_json_kv":66,"dynamodb_raw_stringset":67,"NEW":68,"STRINGSET":69,"LPAR":70,"stringset_list":71,"RPAR":72,"dynamodb_raw_numberset":73,"NUMBERSET":74,"numberset_list":75,"INSERT":76,"def_insert_ignore":77,"INTO":78,"SET":79,"def_insert_columns":80,"IGNORE":81,"def_insert_onecolumn":82,"EQ":83,"UPDATE":84,"def_update_columns":85,"WHERE":86,"def_update_where":87,"def_update_onecolumn":88,"PLUSEQ":89,"def_update_where_cond":90,"AND":91,"REPLACE":92,"def_replace_columns":93,"def_replace_onecolumn":94,"DELETE":95,"FROM":96,"def_delete_where":97,"def_delete_where_cond":98,"def_select":99,"sort_clause":100,"limit_clause":101,"def_consistent_read":102,"LIMIT":103,"DESC":104,"CONSISTENT_READ":105,"distinct_all":106,"DISTINCT":107,"ALL":108,"def_select_columns":109,"def_select_onecolumn":110,"STAR":111,"AS":112,"join_clause":113,"table_or_subquery":114,"from":115,"use_index":116,"USE":117,"INDEX":118,"def_where":119,"where_expr":120,"def_having":121,"HAVING":122,"having_expr":123,"SELECT":124,"bind_parameter":125,"OR":126,"GT":127,"GE":128,"LT":129,"LE":130,"BETWEEN":131,"where_between":132,"LIKE":133,"CONTAINS":134,"CREATE":135,"TABLE":136,"def_ct_typedef_list":137,"def_ct_pk":138,"def_ct_indexes":139,"def_ct_index_list":140,"def_ct_index":141,"LSI":142,"def_ct_projection":143,"GSI":144,"def_ct_throughput":145,"PRIMARY":146,"KEY":147,"THROUGHPUT":148,"PROJECTION":149,"KEYS_ONLY":150,"def_ct_projection_list":151,"def_ct_typedef":152,"STRING":153,"SHOW":154,"TABLES":155,"DROP":156,"DESCRIBE":157,"ON":158,"def_scan":159,"def_scan_limit_clause":160,"def_scan_consistent_read":161,"SCAN":162,"def_scan_columns":163,"def_scan_use_index":164,"def_scan_having":165,"def_scan_onecolumn":166,"def_scan_from":167,"def_scan_having_expr":168,"$accept":0,"$end":1},
  terminals_: {2:"error",5:"EOF",6:"SEMICOLON",20:"LITERAL",21:"BRALITERAL",23:"DOT",28:"NUMBER",30:"SINGLE_QUOTED_STRING",31:"DOUBLE_QUOTED_STRING",32:"XSTRING",35:"TRUE",36:"FALSE",45:"NULL",48:"UNDEFINED",50:"ARRAYLPAR",52:"ARRAYRPAR",53:"COMMA",60:"JSONLPAR",62:"JSONRPAR",64:"COLON",68:"NEW",69:"STRINGSET",70:"LPAR",72:"RPAR",74:"NUMBERSET",76:"INSERT",78:"INTO",79:"SET",81:"IGNORE",83:"EQ",84:"UPDATE",86:"WHERE",89:"PLUSEQ",91:"AND",92:"REPLACE",95:"DELETE",96:"FROM",103:"LIMIT",104:"DESC",105:"CONSISTENT_READ",107:"DISTINCT",108:"ALL",111:"STAR",112:"AS",117:"USE",118:"INDEX",122:"HAVING",124:"SELECT",125:"bind_parameter",126:"OR",127:"GT",128:"GE",129:"LT",130:"LE",131:"BETWEEN",133:"LIKE",134:"CONTAINS",135:"CREATE",136:"TABLE",142:"LSI",144:"GSI",146:"PRIMARY",147:"KEY",148:"THROUGHPUT",149:"PROJECTION",150:"KEYS_ONLY",153:"STRING",154:"SHOW",155:"TABLES",156:"DROP",157:"DESCRIBE",158:"ON",162:"SCAN"},
  productions_: [0,[3,2],[4,3],[4,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[19,1],[19,1],[22,3],[22,1],[24,1],[25,1],[26,1],[27,1],[29,1],[29,1],[29,1],[33,1],[33,1],[34,1],[34,1],[37,1],[37,1],[38,1],[38,1],[39,1],[39,1],[40,1],[41,1],[42,1],[42,1],[43,1],[43,1],[44,1],[46,1],[47,1],[49,3],[51,3],[51,1],[54,0],[54,1],[54,1],[54,1],[54,1],[54,1],[54,1],[56,3],[57,3],[57,1],[58,0],[58,1],[58,1],[58,1],[58,1],[58,1],[58,1],[55,3],[61,3],[61,1],[63,0],[63,3],[63,3],[63,3],[63,3],[63,3],[63,3],[63,3],[63,3],[63,3],[63,3],[63,3],[63,3],[63,3],[63,3],[63,3],[63,3],[63,3],[63,3],[59,3],[65,3],[65,1],[66,0],[66,3],[66,3],[66,3],[66,3],[66,3],[66,3],[66,3],[66,3],[66,3],[66,3],[66,3],[66,3],[66,3],[66,3],[66,3],[66,3],[66,3],[66,3],[67,7],[71,3],[71,1],[73,7],[75,3],[75,1],[9,6],[77,0],[77,1],[80,3],[80,1],[82,3],[82,3],[82,3],[82,3],[82,3],[82,3],[82,3],[82,3],[10,6],[85,3],[85,1],[88,3],[88,3],[88,3],[88,3],[88,3],[88,3],[88,3],[88,3],[88,3],[88,3],[87,1],[87,3],[90,3],[90,3],[11,5],[93,3],[93,1],[94,3],[94,3],[94,3],[94,3],[94,3],[94,3],[94,3],[94,3],[12,5],[97,1],[97,3],[98,3],[98,3],[8,4],[101,0],[101,2],[100,0],[100,1],[102,0],[102,1],[106,0],[106,1],[106,1],[109,3],[109,1],[110,1],[110,1],[110,3],[113,1],[114,1],[115,0],[115,2],[116,0],[116,3],[119,2],[119,0],[121,2],[121,0],[99,7],[120,1],[120,1],[120,1],[120,3],[120,3],[120,3],[120,3],[120,3],[120,3],[120,3],[120,3],[120,3],[132,3],[132,3],[123,1],[123,1],[123,1],[123,1],[123,3],[123,3],[123,3],[123,3],[123,3],[123,3],[123,3],[123,3],[123,3],[123,3],[123,3],[123,3],[13,9],[139,0],[139,2],[140,3],[140,1],[141,7],[141,8],[141,9],[141,10],[138,6],[138,8],[145,0],[145,3],[143,0],[143,2],[143,2],[143,4],[151,3],[151,1],[137,3],[137,1],[152,2],[152,2],[14,2],[15,3],[16,3],[17,5],[18,3],[159,6],[160,0],[160,2],[161,0],[161,1],[163,3],[163,1],[166,1],[166,1],[166,3],[167,0],[167,2],[164,0],[164,3],[165,2],[165,0],[168,1],[168,1],[168,1],[168,1],[168,3],[168,3],[168,3],[168,3],[168,3],[168,3],[168,3],[168,3],[168,3],[168,3],[168,3],[168,3]],
  performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
  /* this == yyval */
  
  var $0 = $$.length - 1;
  switch (yystate) {
  case 1:
  
  			this.$ = $$[$0-1];
  			return this.$;
  		
  break;
  case 2:
   this.$ = $$[$0-2]; if($$[$0]) this.$.push($$[$0]); 
  break;
  case 3: case 47: case 57: case 67: case 89: case 111: case 119: case 130: case 147: case 172: case 176: case 235: case 251:
   this.$ = [$$[$0]]; 
  break;
  case 15: case 19: case 21: case 22: case 23: case 24: case 25: case 177: case 181: case 187: case 201: case 202: case 258: case 261: case 262:
   this.$ = $$[$0]; 
  break;
  case 16:
   this.$ = $$[$0].substr(1,$$[$0].length-2); 
  break;
  case 17:
   this.$ = {database:$$[$0-2], table:$$[$0]}; 
  break;
  case 18:
   this.$ = {table:$$[$0]}; 
  break;
  case 20:
   this.$ = {index:$$[$0]}; 
  break;
  case 26:
   this.$ = {type:'number', number:$$[$0]}; 
  break;
  case 27:
   this.$ = {type:'string', string: $$[$0]}
  break;
  case 28: case 38:
   this.$ = true; 
  break;
  case 29: case 39:
   this.$ = false; 
  break;
  case 30:
   this.$ = {type:'boolean', value: true }; 
  break;
  case 31:
   this.$ = {type:'boolean', value: false }; 
  break;
  case 32: case 33: case 36:
   this.$ = eval($$[$0]); 
  break;
  case 34: case 35:
   this.$ = { 'S': eval($$[$0]).toString() } 
  break;
  case 37:
   this.$ = { 'N': eval($$[$0]).toString() } 
  break;
  case 40:
   this.$ = { 'BOOL': true  } 
  break;
  case 41:
   this.$ = { 'BOOL': false } 
  break;
  case 42:
   this.$ = null; 
  break;
  case 43:
   this.$ = { 'NULL': true } 
  break;
  case 44:
   this.$ = "\0"; 
  break;
  case 45:
  
  			if ($$[$0-1].slice(-1) == "\0") {
  				this.$ = $$[$0-1].slice(0,-1)
  			} else
  				this.$ = $$[$0-1];
  		
  break;
  case 46: case 56: case 110:
  
  			this.$ = $$[$0-2] 
  			this.$.push($$[$0]); 
  		
  break;
  case 48: case 58:
   this.$ = "\0" 
  break;
  case 49: case 50: case 51: case 52: case 53: case 54: case 59: case 60: case 61: case 62: case 63: case 64: case 256:
   this.$ = $$[$0] 
  break;
  case 55:
  
  			if ($$[$0-1].slice(-1) == "\0") {
  				$$[$0-1] = $$[$0-1].slice(0,-1)
  			}
  			this.$ = { 'L': $$[$0-1] }
  		
  break;
  case 65:
   
  			var $kv = {}
  			if ($$[$0-1]) {
  				$$[$0-1].map(function(v) {
  					if (v)
  						$kv[v[0]] = v[1]
  				})
  			}
  			this.$ = $kv
  		
  break;
  case 66: case 88: case 118: case 129: case 146: case 171: case 220: case 234: case 250:
   this.$ = $$[$0-2]; this.$.push($$[$0]); 
  break;
  case 68: case 90: case 162: case 164: case 166: case 168: case 178: case 180: case 218: case 246: case 248: case 255: case 257:
   this.$ = undefined; 
  break;
  case 69: case 70: case 71: case 72: case 73: case 74: case 75: case 76: case 77: case 78: case 79: case 80: case 81: case 82: case 83: case 84: case 85: case 86: case 91: case 94: case 97: case 100: case 103: case 106:
   this.$ = [$$[$0-2], $$[$0] ] 
  break;
  case 87:
   
  			var $kv = {}
  			if ($$[$0-1]) {
  				$$[$0-1].map(function(v) {
  					if (v)
  						$kv[v[0]] = v[1]
  				})
  			}
  			this.$ = { 'M': $kv }
  		
  break;
  case 92: case 93: case 95: case 96: case 98: case 99: case 101: case 102: case 104: case 105: case 107: case 108:
   this.$ = [eval($$[$0-2]), $$[$0] ] 
  break;
  case 109:
  
  			if ($$[$0-2].slice(-1) == "\0") {
  				$$[$0-2] = $$[$0-2].slice(0,-1)
  			}
  			this.$ = { 'SS': $$[$0-2] }
  		
  break;
  case 112:
  
  			if ($$[$0-2].slice(-1) == "\0") {
  				$$[$0-2] = $$[$0-2].slice(0,-1)
  			}
  			this.$ = { 'NS': $$[$0-2] }
  		
  break;
  case 113:
  
  			this.$ = $$[$0-2] 
  			this.$.push( ($$[$0]).toString() ); 
  		
  break;
  case 114:
   this.$ = [ ($$[$0]).toString() ]; 
  break;
  case 115:
  
  			var $kv = {}
  			$$[$0].map(function(v) { $kv[v[0]] = v[1] })
  
  			this.$ = {
  				statement: 'INSERT', 
  				operation: 'putItem',
  				ignore: $$[$0-4],
  				dynamodb: {
  					TableName: $$[$0-2],
  					Item: $kv,
  				},
  				
  			};
  
  		
  break;
  case 116:
   this.$ = false 
  break;
  case 117:
   this.$ = true 
  break;
  case 120: case 121: case 122: case 123: case 124: case 125: case 126: case 127: case 131: case 132: case 133: case 134: case 135: case 136: case 137: case 138: case 148: case 149: case 150: case 151: case 152: case 153: case 154: case 155:
   this.$ = [ $$[$0-2], $$[$0] ]; 
  break;
  case 128:
  
  
  			var Key = {}
  			$$[$0].map(function(k) {
  				Key[k.k] = k.v
  			})
  			var Expected = {}
  			$$[$0].map(function(k) {
  				Expected[k.k] = {
  					ComparisonOperator: 'EQ',
  					Value: k.v,
  					
  				}
  			})
  
  			var AttributeUpdates = {}
  			$$[$0-2].map(function(k) {
  				var Value = k[1]
  				var Action = 'PUT' // default
  
  				if (k[2] === '+=')
  					Action = 'ADD'
  
  				if (k[2] === 'delete') {
  					Action = 'DELETE'
  					
  				}
  
  				AttributeUpdates[k[0]] = {
  					Action: Action,
  					Value: Value,
  				}
  			})
  			
  			this.$ = {
  				statement: 'UPDATE', 
  				operation: 'updateItem',
  				dynamodb: {
  					TableName: $$[$0-4],
  					Key: Key,
  					Expected: Expected,
  					AttributeUpdates: AttributeUpdates, 
  				},
  			}
  		
  break;
  case 139:
   this.$ = [ $$[$0-2], $$[$0], '+=' ]; 
  break;
  case 140:
   this.$ = [ $$[$0-2], undefined, 'delete' ]; 
  break;
  case 141: case 157: case 221: case 237:
   this.$ = [ $$[$0] ]; 
  break;
  case 142: case 158:
   this.$ = [$$[$0-2], $$[$0]]; 
  break;
  case 143: case 144: case 159: case 160:
   this.$ = {k: $$[$0-2], v: $$[$0] }; 
  break;
  case 145:
  
  			var $kv = {}
  			$$[$0].map(function(v) { 
  				$kv[v[0]] = v[1]
  			})
  			this.$ = {
  				statement: 'REPLACE', 
  				operation: 'putItem',
  				dynamodb: {
  					TableName: $$[$0-2],
  					Item: $kv 
  				},
  			}
  		
  break;
  case 156:
  
  			var $kv = {}
  			$$[$0].map(function(v) { $kv[v.k] = v.v })
  
  			this.$ = {
  				statement: 'DELETE', 
  				operation: 'deleteItem',
  				dynamodb: {
  					TableName: $$[$0-2],
  					Key: $kv,
  				}
  			}
  		
  break;
  case 161:
  
  			this.$ = {
  				statement: 'SELECT', 
  				dynamodb: $$[$0-3]
  			};
  
  			yy.extend(this.$.dynamodb,$$[$0-2]);
  			yy.extend(this.$.dynamodb,$$[$0-1]);
  			yy.extend(this.$.dynamodb,$$[$0]);
  		
  break;
  case 163: case 247:
   this.$ = {limit: $$[$0]}; 
  break;
  case 165:
   this.$ = { sort: 'DESC' }; 
  break;
  case 167: case 249:
   this.$ = { consistent_read: true }; 
  break;
  case 169:
   this.$ = {distinct:true}; 
  break;
  case 170:
   this.$ = {all:true}; 
  break;
  case 173: case 252:
   this.$ = {type: 'star', star:true}; 
  break;
  case 174: case 253:
   this.$ = {type: 'column', column: $$[$0]}; 
  break;
  case 175: case 254:
   this.$ = {type: 'column', column: $$[$0-2], alias: $$[$0] }; 
  break;
  case 179:
   this.$ = {from:$$[$0]}; 
  break;
  case 182:
   this.$ = {where: $$[$0]}; 
  break;
  case 184: case 259:
   this.$ = {having: $$[$0]}; 
  break;
  case 186:
  
  			this.$ = {
  				columns:$$[$0-4]
  			};
  			yy.extend(this.$,$$[$0-5]);
  			yy.extend(this.$,$$[$0-3]);
  			yy.extend(this.$,$$[$0-2]);
  			yy.extend(this.$,$$[$0-1]);
  			yy.extend(this.$,$$[$0]);
  		
  break;
  case 188: case 203: case 263:
   this.$ = {bind_parameter: $$[$0]}; 
  break;
  case 189: case 204: case 264:
   this.$ = {column: $$[$0]}; 
  break;
  case 190: case 205: case 265:
   this.$ = {op: 'AND', left: $$[$0-2], right: $$[$0]}; 
  break;
  case 191: case 206: case 266:
   this.$ = {op: 'OR', left: $$[$0-2], right: $$[$0]}; 
  break;
  case 192: case 207: case 267:
   this.$ = {op: '=', left: $$[$0-2], right: $$[$0]}; 
  break;
  case 193: case 208: case 268:
   this.$ = {op: '>', left: $$[$0-2], right: $$[$0]}; 
  break;
  case 194: case 209: case 269:
   this.$ = {op: '>=', left: $$[$0-2], right: $$[$0]}; 
  break;
  case 195: case 210: case 270:
   this.$ = {op: '<', left: $$[$0-2], right: $$[$0]}; 
  break;
  case 196: case 211: case 271:
   this.$ = {op: '<=', left: $$[$0-2], right: $$[$0]}; 
  break;
  case 197: case 212: case 272:
   this.$ = {op: 'BETWEEN', left: $$[$0-2], right:$$[$0] }; 
  break;
  case 198: case 213: case 273:
   this.$ = {op: 'LIKE', left:$$[$0-2], right: { type: 'string', string: $$[$0] } }; 
  break;
  case 199:
   this.$ = {left: { type: 'number', number: $$[$0-2]}, right: {type: 'number', number: $$[$0] } }; 
  break;
  case 200:
   this.$ = {left: { type: 'string', string: $$[$0-2]}, right: {type: 'string', string: $$[$0] } }; 
  break;
  case 214: case 274:
   this.$ = {op: 'CONTAINS', left:$$[$0-2], right: { type: 'string', string: $$[$0] } }; 
  break;
  case 215: case 275:
   this.$ = {op: 'CONTAINS', left:$$[$0-2], right: { type: 'number', number: $$[$0] } }; 
  break;
  case 216: case 276:
   this.$ = {op: 'CONTAINS', left:$$[$0-2], right: { type: 'boolean', value: $$[$0] } }; 
  break;
  case 217:
  
  			this.$ = {
  				statement: 'CREATE_TABLE',
  				dynamodb: {
  					TableName: $$[$0-6],
  					AttributeDefinitions: $$[$0-4],
  				}
  				
  			};
  			yy.extend(this.$.dynamodb,$$[$0-2]); // extend with pk
  			yy.extend(this.$.dynamodb,$$[$0-1]); // extend with indexes
  		
  break;
  case 219:
  
  			var indexes = {
  				LocalSecondaryIndexes: [],
  				GlobalSecondaryIndexes: []
  			}
  			
  			$$[$0].map(function(idx) {
  				if (idx.hasOwnProperty('LSI'))
  					indexes.LocalSecondaryIndexes.push(idx.LSI)
  				if (idx.hasOwnProperty('GSI'))
  					indexes.GlobalSecondaryIndexes.push(idx.GSI)
  			})
  			this.$ = indexes
  		
  break;
  case 222:
  
  			this.$ = {}
  			this.$[$$[$0-4]] = { 
  				IndexName: $$[$0-5], 
  				KeySchema: [ { AttributeName: $$[$0-2], KeyType: 'HASH' } ], 
  				Projection: $$[$0],
  			}
  		
  break;
  case 223:
  
  			this.$ = {}
  			this.$[$$[$0-5]] = { 
  				IndexName: $$[$0-6], 
  				KeySchema: [ { AttributeName: $$[$0-3], KeyType: 'HASH' } ], 
  				Projection: $$[$0-1],
  				ProvisionedThroughput: $$[$0] 
  			}
  		
  break;
  case 224:
  
  			this.$ = {}
  			this.$[$$[$0-6]] = { 
  				IndexName: $$[$0-7], 
  				KeySchema: [ { AttributeName: $$[$0-4], KeyType: 'HASH' }, { AttributeName: $$[$0-2], KeyType: 'RANGE' } ], 
  				Projection: $$[$0],
  			}
  		
  break;
  case 225:
  
  			this.$ = {}
  			this.$[$$[$0-7]] = { 
  				IndexName: $$[$0-8], 
  				KeySchema: [ { AttributeName: $$[$0-5], KeyType: 'HASH' }, { AttributeName: $$[$0-3], KeyType: 'RANGE' } ], 
  				Projection: $$[$0-1],
  				ProvisionedThroughput: $$[$0] 
  			}
  		
  break;
  case 226:
   this.$ = { KeySchema: [ { AttributeName: $$[$0-2], KeyType: 'HASH' }], ProvisionedThroughput: $$[$0] }  
  break;
  case 227:
   this.$ = { KeySchema: [ { AttributeName: $$[$0-4], KeyType: 'HASH' } , { AttributeName: $$[$0-2], KeyType: 'RANGE' } ], ProvisionedThroughput: $$[$0] }  
  break;
  case 228:
   this.$ = { ReadCapacityUnits: 1, WriteCapacityUnits: 1 }; 
  break;
  case 229:
   this.$ = { ReadCapacityUnits: eval($$[$0-1]), WriteCapacityUnits: eval($$[$0]) } 
  break;
  case 230: case 231:
   this.$ = { ProjectionType: 'ALL' }; 
  break;
  case 232:
   this.$ = { ProjectionType: 'KEYS_ONLY' } 
  break;
  case 233:
   this.$ = { ProjectionType: 'INCLUDE', NonKeyAttributes: $$[$0-1] } 
  break;
  case 236:
   this.$ = $$[$0-2]; this.$.push($$[$0]) 
  break;
  case 238:
   this.$ = { AttributeName: $$[$0-1], AttributeType: 'S'}; 
  break;
  case 239:
   this.$ = { AttributeName: $$[$0-1], AttributeType: 'N'}; 
  break;
  case 240:
  
  			this.$ = {statement: 'SHOW_TABLES' }
  		
  break;
  case 241:
  
  			this.$ = {
  				statement: 'DROP_TABLE',
  				dynamodb: {
  					TableName: $$[$0]
  				}
  			};
  		
  break;
  case 242:
  
  			this.$ = {
  				statement: 'DESCRIBE_TABLE',
  				dynamodb: {
  					TableName: $$[$0]
  				}
  			};
  		
  break;
  case 243:
  
  			this.$ = {
  				statement: 'DROP_INDEX',
  				dynamodb: {
  					TableName: $$[$0],
  					GlobalSecondaryIndexUpdates: [
  						{
  							Delete: {
  								IndexName: $$[$0-2]
  							}
  						}
  					]
  				}
  			};
  		
  break;
  case 244:
  
  			this.$ = {
  				statement: 'SCAN', 
  				dynamodb: {
  				
  				},
  			};
  			yy.extend(this.$.dynamodb, $$[$0-2] )
  			yy.extend(this.$.dynamodb,$$[$0-1]);
  			yy.extend(this.$.dynamodb,$$[$0]);
  		
  break;
  case 245:
  
  			this.$ = {
  				TableName: $$[$0-2],
  				columns:$$[$0-4]
  			}; //columns
  
  			yy.extend(this.$,$$[$0-1]); // index
  			yy.extend(this.$,$$[$0]); // filter
  		
  break;
  }
  },
  table: [{3:1,4:2,7:3,8:4,9:5,10:6,11:7,12:8,13:9,14:10,15:11,16:12,17:13,18:14,76:$V0,84:$V1,92:$V2,95:$V3,99:15,124:$V4,135:$V5,154:$V6,156:$V7,157:$V8,159:24,162:$V9},{1:[3]},{5:[1,27],6:[1,28]},o($Va,[2,3]),o($Va,[2,4]),o($Va,[2,5]),o($Va,[2,6]),o($Va,[2,7]),o($Va,[2,8]),o($Va,[2,9]),o($Va,[2,10]),o($Va,[2,11]),o($Va,[2,12]),o($Va,[2,13]),o($Va,[2,14]),o($Vb,[2,164],{100:29,104:[1,30]}),{77:31,78:[2,116],81:[1,32]},{19:34,20:$Vc,21:$Vd,24:33},{78:[1,37]},{96:[1,38]},{136:[1,39]},{155:[1,40]},{118:[1,42],136:[1,41]},{136:[1,43]},o($Ve,[2,246],{160:44,103:[1,45]}),o($Vf,[2,168],{106:46,107:[1,47],108:[1,48]}),{19:52,20:$Vc,21:$Vd,111:$Vg,163:49,166:50},{1:[2,1]},{7:53,8:4,9:5,10:6,11:7,12:8,13:9,14:10,15:11,16:12,17:13,18:14,76:$V0,84:$V1,92:$V2,95:$V3,99:15,124:$V4,135:$V5,154:$V6,156:$V7,157:$V8,159:24,162:$V9},o($Ve,[2,162],{101:54,103:[1,55]}),o($Vb,[2,165]),{78:[1,56]},{78:[2,117]},{79:[1,57]},o([5,6,70,79,86,103,105,117,122],[2,19]),o($Vh,[2,15]),o($Vh,[2,16]),{19:34,20:$Vc,21:$Vd,24:58},{19:34,20:$Vc,21:$Vd,24:59},{19:34,20:$Vc,21:$Vd,24:60},o($Va,[2,240]),{19:34,20:$Vc,21:$Vd,24:61},{19:63,20:$Vc,21:$Vd,26:62},{19:34,20:$Vc,21:$Vd,24:64},o($Va,[2,248],{161:65,105:[1,66]}),{27:67,28:$Vi},{19:72,20:$Vc,21:$Vd,109:69,110:70,111:$Vj},o($Vf,[2,169]),o($Vf,[2,170]),{53:[1,74],96:[1,73]},o($Vk,[2,251]),o($Vk,[2,252]),o($Vk,[2,253],{112:[1,75]}),o($Va,[2,2]),o($Va,[2,166],{102:76,105:[1,77]}),{27:78,28:$Vi},{19:34,20:$Vc,21:$Vd,24:79},{19:82,20:$Vc,21:$Vd,85:80,88:81},{79:[1,83]},{86:[1,84]},{70:[1,85]},o($Va,[2,241]),{158:[1,86]},{158:[2,21]},o($Va,[2,242]),o($Va,[2,244]),o($Va,[2,249]),o($Ve,[2,247]),o([5,6,28,53,72,83,91,103,104,105,122,126,127,128,129,130,131,133,134],[2,22]),o($Vl,[2,178],{115:87,53:[1,88],96:[1,89]}),o($Vm,[2,172]),o($Vm,[2,173]),o($Vm,[2,174],{112:[1,90]}),{19:34,20:$Vc,21:$Vd,24:91},{19:52,20:$Vc,21:$Vd,111:$Vg,166:92},{19:93,20:$Vc,21:$Vd},o($Va,[2,161]),o($Va,[2,167]),o($Ve,[2,163]),{79:[1,94]},{53:[1,96],86:[1,95]},o($Vn,[2,130]),{83:[1,97],89:[1,98]},{19:101,20:$Vc,21:$Vd,93:99,94:100},{19:104,20:$Vc,21:$Vd,97:102,98:103},{19:107,20:$Vc,21:$Vd,137:105,152:106},{19:34,20:$Vc,21:$Vd,24:108},o($Vo,[2,180],{116:109,117:[1,110]}),{19:72,20:$Vc,21:$Vd,110:111,111:$Vj},{19:115,20:$Vc,21:$Vd,22:114,113:112,114:113},{19:116,20:$Vc,21:$Vd},o($Vp,[2,257],{164:117,117:[1,118]}),o($Vk,[2,250]),o($Vk,[2,254]),{19:121,20:$Vc,21:$Vd,80:119,82:120},{19:124,20:$Vc,21:$Vd,87:122,90:123},{19:82,20:$Vc,21:$Vd,88:125},{28:$Vq,30:$Vr,31:$Vs,35:$Vt,36:$Vu,39:126,41:127,43:128,45:$Vv,46:129,47:134,48:[1,144],50:$Vw,56:131,59:130,60:$Vx,67:132,68:$Vy,73:133},{28:$Vq,41:145},o($Va,[2,145],{53:[1,146]}),o($Vz,[2,147]),{83:[1,147]},o($Va,[2,156]),o($Va,[2,157],{91:[1,148]}),{83:[1,149]},{53:[1,150]},{53:[2,237]},{28:[1,152],153:[1,151]},o($Va,[2,243]),o($VA,[2,183],{119:153,86:[1,154]}),{118:[1,155]},o($Vm,[2,171]),o($Vl,[2,179]),o($Vl,[2,176]),o($Vl,[2,177]),o($Vl,[2,18],{23:[1,156]}),o($Vm,[2,175]),o($Vb,[2,260],{165:157,122:[1,158]}),{118:[1,159]},o($Va,[2,115],{53:[1,160]}),o($Vz,[2,119]),{83:[1,161]},o($Va,[2,128]),o($Va,[2,141],{91:[1,162]}),{83:[1,163]},o($Vn,[2,129]),o($Vn,[2,131]),o($Vn,[2,132]),o($Vn,[2,133]),o($Vn,[2,134]),o($Vn,[2,135]),o($Vn,[2,136]),o($Vn,[2,137]),o($Vn,[2,138]),o($Vn,[2,140]),o($VB,[2,34]),o($VB,[2,35]),o($VB,[2,37]),o($VC,[2,40]),o($VC,[2,41]),o($VC,[2,43]),o($VD,$VE,{65:164,66:165,19:166,20:$Vc,21:$Vd,30:$VF,31:$VG}),o($VH,$VI,{57:169,58:170,41:171,39:172,43:173,46:174,56:175,59:176,28:$Vq,30:$Vr,31:$Vs,35:$Vt,36:$Vu,45:$Vv,50:$Vw,60:$Vx}),{69:[1,177],74:[1,178]},o($Vn,[2,44]),o($Vn,[2,139]),{19:101,20:$Vc,21:$Vd,94:179},{28:$Vq,30:$Vr,31:$Vs,35:$Vt,36:$Vu,39:180,41:181,43:182,45:$Vv,46:183,50:$Vw,56:185,59:184,60:$Vx,67:186,68:$Vy,73:187},{19:104,20:$Vc,21:$Vd,98:188},{28:$Vq,30:$Vr,31:$Vs,39:189,41:190},{19:107,20:$Vc,21:$Vd,138:191,146:[1,193],152:192},{53:[2,238]},{53:[2,239]},o($VJ,[2,185],{121:194,122:[1,195]}),{19:199,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:197,120:196,125:$VN},{19:206,20:$Vc,21:$Vd,25:205},{19:207,20:$Vc,21:$Vd},o($Vb,[2,245]),{19:212,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:209,35:$VO,36:$VP,37:210,125:$VQ,168:208},{19:206,20:$Vc,21:$Vd,25:215},{19:121,20:$Vc,21:$Vd,82:216},{28:$Vq,30:$Vr,31:$Vs,35:$Vt,36:$Vu,39:217,41:218,43:219,45:$Vv,46:220,50:$Vw,56:222,59:221,60:$Vx,67:223,68:$Vy,73:224},{19:124,20:$Vc,21:$Vd,90:225},{28:$Vq,30:$Vr,31:$Vs,39:226,41:227},{53:[1,229],62:[1,228]},o($VD,[2,89]),{64:[1,230]},{64:[1,231]},{64:[1,232]},{52:[1,233],53:[1,234]},o($VH,[2,57]),o($VH,[2,59]),o($VH,[2,60]),o($VH,[2,61]),o($VH,[2,62]),o($VH,[2,63]),o($VH,[2,64]),{70:[1,235]},{70:[1,236]},o($Vz,[2,146]),o($Vz,[2,148]),o($Vz,[2,149]),o($Vz,[2,150]),o($Vz,[2,151]),o($Vz,[2,152]),o($Vz,[2,153]),o($Vz,[2,154]),o($Vz,[2,155]),o($Va,[2,158]),o($VR,[2,159]),o($VR,[2,160]),{53:[1,238],72:[2,218],139:237},{53:[2,236]},{147:[1,239]},o($VJ,[2,186]),{19:244,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:241,35:$VO,36:$VP,37:242,123:240,125:$VS},o($VA,[2,182],{83:$VT,91:$VU,126:[1,246],127:$VV,128:$VW,129:$VX,130:$VY,131:$VZ,133:$V_}),o($V$,[2,187]),o($V$,[2,188]),o($V$,[2,189]),o($V01,[2,26]),o($V01,[2,27]),o($V01,[2,23]),o($V01,[2,24]),o($V01,[2,25]),o($Vo,[2,181]),o($Vo,[2,20]),o($Vl,[2,17]),o($Vb,[2,259],{83:$V11,91:$V21,126:[1,255],127:$V31,128:$V41,129:$V51,130:$V61,131:$V71,133:$V81,134:$V91}),o($Va1,[2,261]),o($Va1,[2,262]),o($Va1,[2,263]),o($Va1,[2,264]),o($Vb1,[2,30]),o($Vb1,[2,31]),o($Vp,[2,258]),o($Vz,[2,118]),o($Vz,[2,120]),o($Vz,[2,121]),o($Vz,[2,122]),o($Vz,[2,123]),o($Vz,[2,124]),o($Vz,[2,125]),o($Vz,[2,126]),o($Vz,[2,127]),o($Va,[2,142]),o($VR,[2,143]),o($VR,[2,144]),o($VC,[2,87]),o($VD,$VE,{19:166,66:264,20:$Vc,21:$Vd,30:$VF,31:$VG}),{28:$Vq,30:$Vr,31:$Vs,35:$Vt,36:$Vu,39:266,41:265,43:267,45:$Vv,46:268,50:$Vw,56:269,59:270,60:$Vx},{28:$Vq,30:$Vr,31:$Vs,35:$Vt,36:$Vu,39:272,41:271,43:273,45:$Vv,46:274,50:$Vw,56:275,59:276,60:$Vx},{28:$Vq,30:$Vr,31:$Vs,35:$Vt,36:$Vu,39:278,41:277,43:279,45:$Vv,46:280,50:$Vw,56:281,59:282,60:$Vx},o($VC,[2,55]),o($VH,$VI,{41:171,39:172,43:173,46:174,56:175,59:176,58:283,28:$Vq,30:$Vr,31:$Vs,35:$Vt,36:$Vu,45:$Vv,50:$Vw,60:$Vx}),{50:[1,284]},{50:[1,285]},{72:[1,286]},{118:$Vc1,140:287,141:288},{70:[1,290]},o($VJ,[2,184],{83:$Vd1,91:$Ve1,126:[1,292],127:$Vf1,128:$Vg1,129:$Vh1,130:$Vi1,131:$Vj1,133:$Vk1,134:$Vl1}),o($Vb1,[2,201]),o($Vb1,[2,202]),o($Vb1,[2,203]),o($Vb1,[2,204]),{19:199,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:197,120:301,125:$VN},{19:199,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:197,120:302,125:$VN},{19:199,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:197,120:303,125:$VN},{19:199,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:197,120:304,125:$VN},{19:199,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:197,120:305,125:$VN},{19:199,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:197,120:306,125:$VN},{19:199,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:197,120:307,125:$VN},{27:309,28:$Vi,29:310,30:$VK,31:$VL,32:$VM,132:308},{29:311,30:$VK,31:$VL,32:$VM},{19:212,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:209,35:$VO,36:$VP,37:210,125:$VQ,168:312},{19:212,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:209,35:$VO,36:$VP,37:210,125:$VQ,168:313},{19:212,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:209,35:$VO,36:$VP,37:210,125:$VQ,168:314},{19:212,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:209,35:$VO,36:$VP,37:210,125:$VQ,168:315},{19:212,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:209,35:$VO,36:$VP,37:210,125:$VQ,168:316},{19:212,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:209,35:$VO,36:$VP,37:210,125:$VQ,168:317},{19:212,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:209,35:$VO,36:$VP,37:210,125:$VQ,168:318},{27:309,28:$Vi,29:310,30:$VK,31:$VL,32:$VM,132:319},{29:320,30:$VK,31:$VL,32:$VM},{27:322,28:$Vi,29:321,30:$VK,31:$VL,32:$VM,35:$VO,36:$VP,37:323},o($VD,[2,88]),o($VD,[2,91]),o($VD,[2,94]),o($VD,[2,97]),o($VD,[2,100]),o($VD,[2,103]),o($VD,[2,106]),o($VD,[2,92]),o($VD,[2,95]),o($VD,[2,98]),o($VD,[2,101]),o($VD,[2,104]),o($VD,[2,107]),o($VD,[2,93]),o($VD,[2,96]),o($VD,[2,99]),o($VD,[2,102]),o($VD,[2,105]),o($VD,[2,108]),o($VH,[2,56]),{30:$Vm1,31:$Vn1,38:325,71:324},{28:$Vo1,40:329,75:328},o($Va,[2,217]),{53:[1,331],72:[2,219]},o($Vp1,[2,221]),{19:332,20:$Vc,21:$Vd},{19:333,20:$Vc,21:$Vd},{19:244,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:241,35:$VO,36:$VP,37:242,123:334,125:$VS},{19:244,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:241,35:$VO,36:$VP,37:242,123:335,125:$VS},{19:244,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:241,35:$VO,36:$VP,37:242,123:336,125:$VS},{19:244,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:241,35:$VO,36:$VP,37:242,123:337,125:$VS},{19:244,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:241,35:$VO,36:$VP,37:242,123:338,125:$VS},{19:244,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:241,35:$VO,36:$VP,37:242,123:339,125:$VS},{19:244,20:$Vc,21:$Vd,27:200,28:$Vi,29:201,30:$VK,31:$VL,32:$VM,33:241,35:$VO,36:$VP,37:242,123:340,125:$VS},{27:309,28:$Vi,29:310,30:$VK,31:$VL,32:$VM,132:341},{29:342,30:$VK,31:$VL,32:$VM},{27:344,28:$Vi,29:343,30:$VK,31:$VL,32:$VM,35:$VO,36:$VP,37:345},o([5,6,91,103,104,105,122,126],[2,190],{83:$VT,127:$VV,128:$VW,129:$VX,130:$VY,131:$VZ,133:$V_}),o([5,6,103,104,105,122,126],[2,191],{83:$VT,91:$VU,127:$VV,128:$VW,129:$VX,130:$VY,131:$VZ,133:$V_}),o([5,6,83,91,103,104,105,122,126,131,133],[2,192],{127:$VV,128:$VW,129:$VX,130:$VY}),o($V$,[2,193]),o($V$,[2,194]),o($V$,[2,195]),o($V$,[2,196]),o($V$,[2,197]),{91:[1,346]},{91:[1,347]},o($V$,[2,198]),o([5,6,91,103,105,126],[2,265],{83:$V11,127:$V31,128:$V41,129:$V51,130:$V61,131:$V71,133:$V81,134:$V91}),o([5,6,103,105,126],[2,266],{83:$V11,91:$V21,127:$V31,128:$V41,129:$V51,130:$V61,131:$V71,133:$V81,134:$V91}),o([5,6,83,91,103,105,126,131,133,134],[2,267],{127:$V31,128:$V41,129:$V51,130:$V61}),o($Va1,[2,268]),o($Va1,[2,269]),o($Va1,[2,270]),o($Va1,[2,271]),o($Va1,[2,272]),o($Va1,[2,273]),o($Va1,[2,274]),o($Va1,[2,275]),o($Va1,[2,276]),{52:[1,348],53:[1,349]},o($VH,[2,111]),o($VH,[2,32]),o($VH,[2,33]),{52:[1,350],53:[1,351]},o($VH,[2,114]),o($VH,[2,36]),{118:$Vc1,141:352},{142:[1,353],144:[1,354]},{53:[1,356],72:[1,355]},o([5,6,91,103,104,105,126],[2,205],{83:$Vd1,127:$Vf1,128:$Vg1,129:$Vh1,130:$Vi1,131:$Vj1,133:$Vk1,134:$Vl1}),o([5,6,103,104,105,126],[2,206],{83:$Vd1,91:$Ve1,127:$Vf1,128:$Vg1,129:$Vh1,130:$Vi1,131:$Vj1,133:$Vk1,134:$Vl1}),o([5,6,83,91,103,104,105,126,131,133,134],[2,207],{127:$Vf1,128:$Vg1,129:$Vh1,130:$Vi1}),o($Vb1,[2,208]),o($Vb1,[2,209]),o($Vb1,[2,210]),o($Vb1,[2,211]),o($Vb1,[2,212]),o($Vb1,[2,213]),o($Vb1,[2,214]),o($Vb1,[2,215]),o($Vb1,[2,216]),{27:357,28:$Vi},{29:358,30:$VK,31:$VL,32:$VM},{72:[1,359]},{30:$Vm1,31:$Vn1,38:360},{72:[1,361]},{28:$Vo1,40:362},o($Vp1,[2,220]),{70:[1,363]},{70:[1,364]},o($Vp1,$Vq1,{145:365,148:$Vr1}),{19:367,20:$Vc,21:$Vd},o($V01,[2,199]),o($V01,[2,200]),o($Vs1,[2,109]),o($VH,[2,110]),o($Vs1,[2,112]),o($VH,[2,113]),{19:368,20:$Vc,21:$Vd},{19:369,20:$Vc,21:$Vd},o($Vp1,[2,226]),{27:370,28:$Vi},{72:[1,371]},{53:[1,373],72:[1,372]},{53:[1,375],72:[1,374]},{27:376,28:$Vi},o($Vp1,$Vq1,{145:377,148:$Vr1}),o($Vp1,$Vt1,{143:378,149:$Vu1}),{19:380,20:$Vc,21:$Vd},o($Vv1,$Vt1,{143:381,149:$Vu1}),{19:382,20:$Vc,21:$Vd},o($Vp1,[2,229]),o($Vp1,[2,227]),o($Vp1,[2,222]),{70:[1,385],108:[1,383],150:[1,384]},{72:[1,386]},o($Vp1,$Vq1,{145:387,148:$Vr1}),{72:[1,388]},o($Vv1,[2,231]),o($Vv1,[2,232]),{19:390,20:$Vc,21:$Vd,151:389},o($Vp1,$Vt1,{143:391,149:$Vu1}),o($Vp1,[2,223]),o($Vv1,$Vt1,{143:392,149:$Vu1}),{53:[1,394],72:[1,393]},o($Vp1,[2,235]),o($Vp1,[2,224]),o($Vp1,$Vq1,{145:395,148:$Vr1}),o($Vv1,[2,233]),{19:396,20:$Vc,21:$Vd},o($Vp1,[2,225]),o($Vp1,[2,234])],
  defaultActions: {27:[2,1],32:[2,117],63:[2,21],106:[2,237],151:[2,238],152:[2,239],192:[2,236]},
  parseError: function parseError(str, hash) {
      if (hash.recoverable) {
          this.trace(str);
      } else {
          var error = new Error(str);
          error.hash = hash;
          throw error;
      }
  },
  parse: function parse(input) {
      var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
      var args = lstack.slice.call(arguments, 1);
      var lexer = Object.create(this.lexer);
      var sharedState = { yy: {} };
      for (var k in this.yy) {
          if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
              sharedState.yy[k] = this.yy[k];
          }
      }
      lexer.setInput(input, sharedState.yy);
      sharedState.yy.lexer = lexer;
      sharedState.yy.parser = this;
      if (typeof lexer.yylloc == 'undefined') {
          lexer.yylloc = {};
      }
      var yyloc = lexer.yylloc;
      lstack.push(yyloc);
      var ranges = lexer.options && lexer.options.ranges;
      if (typeof sharedState.yy.parseError === 'function') {
          this.parseError = sharedState.yy.parseError;
      } else {
          this.parseError = Object.getPrototypeOf(this).parseError;
      }
      function popStack(n) {
          stack.length = stack.length - 2 * n;
          vstack.length = vstack.length - n;
          lstack.length = lstack.length - n;
      }
      _token_stack:
          var lex = function () {
              var token;
              token = lexer.lex() || EOF;
              if (typeof token !== 'number') {
                  token = self.symbols_[token] || token;
              }
              return token;
          };
      var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
      while (true) {
          state = stack[stack.length - 1];
          if (this.defaultActions[state]) {
              action = this.defaultActions[state];
          } else {
              if (symbol === null || typeof symbol == 'undefined') {
                  symbol = lex();
              }
              action = table[state] && table[state][symbol];
          }
                      if (typeof action === 'undefined' || !action.length || !action[0]) {
                  var errStr = '';
                  expected = [];
                  for (p in table[state]) {
                      if (this.terminals_[p] && p > TERROR) {
                          expected.push('\'' + this.terminals_[p] + '\'');
                      }
                  }
                  if (lexer.showPosition) {
                      errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
                  } else {
                      errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
                  }
                  this.parseError(errStr, {
                      text: lexer.match,
                      token: this.terminals_[symbol] || symbol,
                      line: lexer.yylineno,
                      loc: yyloc,
                      expected: expected
                  });
              }
          if (action[0] instanceof Array && action.length > 1) {
              throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
          }
          switch (action[0]) {
          case 1:
              stack.push(symbol);
              vstack.push(lexer.yytext);
              lstack.push(lexer.yylloc);
              stack.push(action[1]);
              symbol = null;
              if (!preErrorSymbol) {
                  yyleng = lexer.yyleng;
                  yytext = lexer.yytext;
                  yylineno = lexer.yylineno;
                  yyloc = lexer.yylloc;
                  if (recovering > 0) {
                      recovering--;
                  }
              } else {
                  symbol = preErrorSymbol;
                  preErrorSymbol = null;
              }
              break;
          case 2:
              len = this.productions_[action[1]][1];
              yyval.$ = vstack[vstack.length - len];
              yyval._$ = {
                  first_line: lstack[lstack.length - (len || 1)].first_line,
                  last_line: lstack[lstack.length - 1].last_line,
                  first_column: lstack[lstack.length - (len || 1)].first_column,
                  last_column: lstack[lstack.length - 1].last_column
              };
              if (ranges) {
                  yyval._$.range = [
                      lstack[lstack.length - (len || 1)].range[0],
                      lstack[lstack.length - 1].range[1]
                  ];
              }
              r = this.performAction.apply(yyval, [
                  yytext,
                  yyleng,
                  yylineno,
                  sharedState.yy,
                  action[1],
                  vstack,
                  lstack
              ].concat(args));
              if (typeof r !== 'undefined') {
                  return r;
              }
              if (len) {
                  stack = stack.slice(0, -1 * len * 2);
                  vstack = vstack.slice(0, -1 * len);
                  lstack = lstack.slice(0, -1 * len);
              }
              stack.push(this.productions_[action[1]][0]);
              vstack.push(yyval.$);
              lstack.push(yyval._$);
              newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
              stack.push(newState);
              break;
          case 3:
              return true;
          }
      }
      return true;
  }};
  /* generated by jison-lex 0.3.4 */
  var lexer = (function(){
  var lexer = ({
  
  EOF:1,
  
  parseError:function parseError(str, hash) {
          if (this.yy.parser) {
              this.yy.parser.parseError(str, hash);
          } else {
              throw new Error(str);
          }
      },
  
  // resets the lexer, sets new input
  setInput:function (input, yy) {
          this.yy = yy || this.yy || {};
          this._input = input;
          this._more = this._backtrack = this.done = false;
          this.yylineno = this.yyleng = 0;
          this.yytext = this.matched = this.match = '';
          this.conditionStack = ['INITIAL'];
          this.yylloc = {
              first_line: 1,
              first_column: 0,
              last_line: 1,
              last_column: 0
          };
          if (this.options.ranges) {
              this.yylloc.range = [0,0];
          }
          this.offset = 0;
          return this;
      },
  
  // consumes and returns one char from the input
  input:function () {
          var ch = this._input[0];
          this.yytext += ch;
          this.yyleng++;
          this.offset++;
          this.match += ch;
          this.matched += ch;
          var lines = ch.match(/(?:\r\n?|\n).*/g);
          if (lines) {
              this.yylineno++;
              this.yylloc.last_line++;
          } else {
              this.yylloc.last_column++;
          }
          if (this.options.ranges) {
              this.yylloc.range[1]++;
          }
  
          this._input = this._input.slice(1);
          return ch;
      },
  
  // unshifts one char (or a string) into the input
  unput:function (ch) {
          var len = ch.length;
          var lines = ch.split(/(?:\r\n?|\n)/g);
  
          this._input = ch + this._input;
          this.yytext = this.yytext.substr(0, this.yytext.length - len);
          //this.yyleng -= len;
          this.offset -= len;
          var oldLines = this.match.split(/(?:\r\n?|\n)/g);
          this.match = this.match.substr(0, this.match.length - 1);
          this.matched = this.matched.substr(0, this.matched.length - 1);
  
          if (lines.length - 1) {
              this.yylineno -= lines.length - 1;
          }
          var r = this.yylloc.range;
  
          this.yylloc = {
              first_line: this.yylloc.first_line,
              last_line: this.yylineno + 1,
              first_column: this.yylloc.first_column,
              last_column: lines ?
                  (lines.length === oldLines.length ? this.yylloc.first_column : 0)
                   + oldLines[oldLines.length - lines.length].length - lines[0].length :
                this.yylloc.first_column - len
          };
  
          if (this.options.ranges) {
              this.yylloc.range = [r[0], r[0] + this.yyleng - len];
          }
          this.yyleng = this.yytext.length;
          return this;
      },
  
  // When called from action, caches matched text and appends it on next action
  more:function () {
          this._more = true;
          return this;
      },
  
  // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
  reject:function () {
          if (this.options.backtrack_lexer) {
              this._backtrack = true;
          } else {
              return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
                  text: "",
                  token: null,
                  line: this.yylineno
              });
  
          }
          return this;
      },
  
  // retain first n characters of the match
  less:function (n) {
          this.unput(this.match.slice(n));
      },
  
  // displays already matched input, i.e. for error messages
  pastInput:function () {
          var past = this.matched.substr(0, this.matched.length - this.match.length);
          return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
      },
  
  // displays upcoming input, i.e. for error messages
  upcomingInput:function () {
          var next = this.match;
          if (next.length < 20) {
              next += this._input.substr(0, 20-next.length);
          }
          return (next.substr(0,20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
      },
  
  // displays the character position where the lexing error occurred, i.e. for error messages
  showPosition:function () {
          var pre = this.pastInput();
          var c = new Array(pre.length + 1).join("-");
          return pre + this.upcomingInput() + "\n" + c + "^";
      },
  
  // test the lexed token: return FALSE when not a match, otherwise return token
  test_match:function (match, indexed_rule) {
          var token,
              lines,
              backup;
  
          if (this.options.backtrack_lexer) {
              // save context
              backup = {
                  yylineno: this.yylineno,
                  yylloc: {
                      first_line: this.yylloc.first_line,
                      last_line: this.last_line,
                      first_column: this.yylloc.first_column,
                      last_column: this.yylloc.last_column
                  },
                  yytext: this.yytext,
                  match: this.match,
                  matches: this.matches,
                  matched: this.matched,
                  yyleng: this.yyleng,
                  offset: this.offset,
                  _more: this._more,
                  _input: this._input,
                  yy: this.yy,
                  conditionStack: this.conditionStack.slice(0),
                  done: this.done
              };
              if (this.options.ranges) {
                  backup.yylloc.range = this.yylloc.range.slice(0);
              }
          }
  
          lines = match[0].match(/(?:\r\n?|\n).*/g);
          if (lines) {
              this.yylineno += lines.length;
          }
          this.yylloc = {
              first_line: this.yylloc.last_line,
              last_line: this.yylineno + 1,
              first_column: this.yylloc.last_column,
              last_column: lines ?
                           lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length :
                           this.yylloc.last_column + match[0].length
          };
          this.yytext += match[0];
          this.match += match[0];
          this.matches = match;
          this.yyleng = this.yytext.length;
          if (this.options.ranges) {
              this.yylloc.range = [this.offset, this.offset += this.yyleng];
          }
          this._more = false;
          this._backtrack = false;
          this._input = this._input.slice(match[0].length);
          this.matched += match[0];
          token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
          if (this.done && this._input) {
              this.done = false;
          }
          if (token) {
              return token;
          } else if (this._backtrack) {
              // recover context
              for (var k in backup) {
                  this[k] = backup[k];
              }
              return false; // rule action called reject() implying the next rule should be tested instead.
          }
          return false;
      },
  
  // return next match in input
  next:function () {
          if (this.done) {
              return this.EOF;
          }
          if (!this._input) {
              this.done = true;
          }
  
          var token,
              match,
              tempMatch,
              index;
          if (!this._more) {
              this.yytext = '';
              this.match = '';
          }
          var rules = this._currentRules();
          for (var i = 0; i < rules.length; i++) {
              tempMatch = this._input.match(this.rules[rules[i]]);
              if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                  match = tempMatch;
                  index = i;
                  if (this.options.backtrack_lexer) {
                      token = this.test_match(tempMatch, rules[i]);
                      if (token !== false) {
                          return token;
                      } else if (this._backtrack) {
                          match = false;
                          continue; // rule action called reject() implying a rule MISmatch.
                      } else {
                          // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                          return false;
                      }
                  } else if (!this.options.flex) {
                      break;
                  }
              }
          }
          if (match) {
              token = this.test_match(match, rules[index]);
              if (token !== false) {
                  return token;
              }
              // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
              return false;
          }
          if (this._input === "") {
              return this.EOF;
          } else {
              return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
                  text: "",
                  token: null,
                  line: this.yylineno
              });
          }
      },
  
  // return next match that has a token
  lex:function lex() {
          var r = this.next();
          if (r) {
              return r;
          } else {
              return this.lex();
          }
      },
  
  // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
  begin:function begin(condition) {
          this.conditionStack.push(condition);
      },
  
  // pop the previously active lexer condition state off the condition stack
  popState:function popState() {
          var n = this.conditionStack.length - 1;
          if (n > 0) {
              return this.conditionStack.pop();
          } else {
              return this.conditionStack[0];
          }
      },
  
  // produce the lexer rule set which is active for the currently active lexer condition state
  _currentRules:function _currentRules() {
          if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
              return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
          } else {
              return this.conditions["INITIAL"].rules;
          }
      },
  
  // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
  topState:function topState(n) {
          n = this.conditionStack.length - 1 - Math.abs(n || 0);
          if (n >= 0) {
              return this.conditionStack[n];
          } else {
              return "INITIAL";
          }
      },
  
  // alias for begin(condition)
  pushState:function pushState(condition) {
          this.begin(condition);
      },
  
  // return the number of states currently on the stack
  stateStackSize:function stateStackSize() {
          return this.conditionStack.length;
      },
  options: {"case-insensitive":true},
  performAction: function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
  var YYSTATE=YY_START;
  switch($avoiding_name_collisions) {
  case 0:return 21
  break;
  case 1:return 30
  break;
  case 2:return 31
  break;
  case 3:/* skip -- comments */
  break;
  case 4:/* skip whitespace */
  break;
  case 5:return 'ABORT'
  break;
  case 6:return 'ADD'
  break;
  case 7:return 'AFTER'
  break;
  case 8:return 'ALTER'
  break;
  case 9:return 'ANALYZE'
  break;
  case 10:return 91
  break;
  case 11:return 112
  break;
  case 12:return 'ASC'
  break;
  case 13:return 'ATTACH'
  break;
  case 14:return 'BEFORE'
  break;
  case 15:return 'BEGIN'
  break;
  case 16:return 131
  break;
  case 17:return 'BY'
  break;
  case 18:return 'CASCADE'
  break;
  case 19:return 'CASE'
  break;
  case 20:return 'CAST'
  break;
  case 21:return 'CHECK'
  break;
  case 22:return 'COLLATE'
  break;
  case 23:return 'COLUMN'
  break;
  case 24:return 'CONFLICT'
  break;
  case 25:return 105
  break;
  case 26:return 'CONSTRAINT'
  break;
  case 27:return 135
  break;
  case 28:return 'CROSS'
  break;
  case 29:return 'CURRENT DATE'
  break;
  case 30:return 'CURRENT TIME'
  break;
  case 31:return 'CURRENT TIMESTAMP'
  break;
  case 32:return 'DATABASE'
  break;
  case 33:return 'DEFAULT'
  break;
  case 34:return 'DEFERRABLE'
  break;
  case 35:return 'DEFERRED'
  break;
  case 36:return 95
  break;
  case 37:return 104
  break;
  case 38:return 'DETACH'
  break;
  case 39:return 107
  break;
  case 40:return 156
  break;
  case 41:return 157
  break;
  case 42:return 'EACH'
  break;
  case 43:return 'ELSE'
  break;
  case 44:return 'END'
  break;
  case 45:return 'ESCAPE'
  break;
  case 46:return 'EXCEPT'
  break;
  case 47:return 'EXCLUSIVE'
  break;
  case 48:return 'EXISTS'
  break;
  case 49:return 'EXPLAIN'
  break;
  case 50:return 'FAIL'
  break;
  case 51:return 'FOR'
  break;
  case 52:return 'FOREIGN'
  break;
  case 53:return 96
  break;
  case 54:return 'FULL'
  break;
  case 55:return 'GLOB'
  break;
  case 56:return 'GROUP'
  break;
  case 57:return 122
  break;
  case 58:return 'IF'
  break;
  case 59:return 81
  break;
  case 60:return 'IMMEDIATE'
  break;
  case 61:return 'IN'
  break;
  case 62:return 117
  break;
  case 63:return 118
  break;
  case 64:return 'INDEXED'
  break;
  case 65:return 'INITIALLY'
  break;
  case 66:return 'INNER'
  break;
  case 67:return 76
  break;
  case 68:return 'INSTEAD'
  break;
  case 69:return 'INTERSECT'
  break;
  case 70:return 78
  break;
  case 71:return 'IS'
  break;
  case 72:return 'ISNULL'
  break;
  case 73:return 'JOIN'
  break;
  case 74:return 147
  break;
  case 75:return 'LEFT'
  break;
  case 76:return 133
  break;
  case 77:return 134
  break;
  case 78:return 103
  break;
  case 79:return 'MATCH'
  break;
  case 80:return 'NATURAL'
  break;
  case 81:return 'NO'
  break;
  case 82:return 'NOT'
  break;
  case 83:return 'NOTNULL'
  break;
  case 84:return 45
  break;
  case 85:return 48
  break;
  case 86:return 'OF'
  break;
  case 87:return 'OFFSET'
  break;
  case 88:return 158
  break;
  case 89:return 126
  break;
  case 90:return 'ORDER'
  break;
  case 91:return 'OUTER'
  break;
  case 92:return 'PLAN'
  break;
  case 93:return 'PRAGMA'
  break;
  case 94:return 146
  break;
  case 95:return 'QUERY'
  break;
  case 96:return 'RAISE'
  break;
  case 97:return 'RECURSIVE'
  break;
  case 98:return 'REFERENCES'
  break;
  case 99:return 'REGEXP'
  break;
  case 100:return 'REINDEX'
  break;
  case 101:return 'RELEASE'
  break;
  case 102:return 'RENAME'
  break;
  case 103:return 92
  break;
  case 104:return 'RESTRICT'
  break;
  case 105:return 'RIGHT'
  break;
  case 106:return 'ROLLBACK'
  break;
  case 107:return 'ROW'
  break;
  case 108:return 124
  break;
  case 109:return 162
  break;
  case 110:return 79
  break;
  case 111:return 136
  break;
  case 112:return 'TEMP'
  break;
  case 113:return 'THEN'
  break;
  case 114:return 'TO'
  break;
  case 115:return 'TRIGGER'
  break;
  case 116:return 'UNION'
  break;
  case 117:return 'UNIQUE'
  break;
  case 118:return 84
  break;
  case 119:return 'USING'
  break;
  case 120:return 'VACUUM'
  break;
  case 121:return 'VALUES'
  break;
  case 122:return 'VIEW'
  break;
  case 123:return 'WHEN'
  break;
  case 124:return 86
  break;
  case 125:return 'WITH'
  break;
  case 126:return 35
  break;
  case 127:return 36
  break;
  case 128:return 154
  break;
  case 129:return 155
  break;
  case 130:return 153
  break;
  case 131:return 28
  break;
  case 132:return 69
  break;
  case 133:return 74
  break;
  case 134:return 'BINARYSET'
  break;
  case 135:return 148
  break;
  case 136:return 144
  break;
  case 137:return 142
  break;
  case 138:return 149
  break;
  case 139:return 108
  break;
  case 140:return 150
  break;
  case 141:return 68
  break;
  case 142:return 'ALLOCATE'
  break;
  case 143:return 'ALTER'
  break;
  case 144:return 'ANALYZE'
  break;
  case 145:return 91
  break;
  case 146:return 'ANY'
  break;
  case 147:return 'ARCHIVE'
  break;
  case 148:return 'ARE'
  break;
  case 149:return 'ARRAY'
  break;
  case 150:return 112
  break;
  case 151:return 'ASC'
  break;
  case 152:return 'ASCII'
  break;
  case 153:return 'ASENSITIVE'
  break;
  case 154:return 'ASSERTION'
  break;
  case 155:return 'ASYMMETRIC'
  break;
  case 156:return 'AT'
  break;
  case 157:return 'ATOMIC'
  break;
  case 158:return 'ATTACH'
  break;
  case 159:return 'ATTRIBUTE'
  break;
  case 160:return 'AUTH'
  break;
  case 161:return 'AUTHORIZATION'
  break;
  case 162:return 'AUTHORIZE'
  break;
  case 163:return 'AUTO'
  break;
  case 164:return 'AVG'
  break;
  case 165:return 'BACK'
  break;
  case 166:return 'BACKUP'
  break;
  case 167:return 'BASE'
  break;
  case 168:return 'BATCH'
  break;
  case 169:return 'BEFORE'
  break;
  case 170:return 'BEGIN'
  break;
  case 171:return 131
  break;
  case 172:return 'BIGINT'
  break;
  case 173:return 'BINARY'
  break;
  case 174:return 'BIT'
  break;
  case 175:return 'BLOB'
  break;
  case 176:return 'BLOCK'
  break;
  case 177:return 'BOOLEAN'
  break;
  case 178:return 'BOTH'
  break;
  case 179:return 'BREADTH'
  break;
  case 180:return 'BUCKET'
  break;
  case 181:return 'BULK'
  break;
  case 182:return 'BY'
  break;
  case 183:return 'BYTE'
  break;
  case 184:return 'CALL'
  break;
  case 185:return 'CALLED'
  break;
  case 186:return 'CALLING'
  break;
  case 187:return 'CAPACITY'
  break;
  case 188:return 'CASCADE'
  break;
  case 189:return 'CASCADED'
  break;
  case 190:return 'CASE'
  break;
  case 191:return 'CAST'
  break;
  case 192:return 'CATALOG'
  break;
  case 193:return 'CHAR'
  break;
  case 194:return 'CHARACTER'
  break;
  case 195:return 'CHECK'
  break;
  case 196:return 'CLASS'
  break;
  case 197:return 'CLOB'
  break;
  case 198:return 'CLOSE'
  break;
  case 199:return 'CLUSTER'
  break;
  case 200:return 'CLUSTERED'
  break;
  case 201:return 'CLUSTERING'
  break;
  case 202:return 'CLUSTERS'
  break;
  case 203:return 'COALESCE'
  break;
  case 204:return 'COLLATE'
  break;
  case 205:return 'COLLATION'
  break;
  case 206:return 'COLLECTION'
  break;
  case 207:return 'COLUMN'
  break;
  case 208:return 'COLUMNS'
  break;
  case 209:return 'COMBINE'
  break;
  case 210:return 'COMMENT'
  break;
  case 211:return 'COMMIT'
  break;
  case 212:return 'COMPACT'
  break;
  case 213:return 'COMPILE'
  break;
  case 214:return 'COMPRESS'
  break;
  case 215:return 'CONDITION'
  break;
  case 216:return 'CONFLICT'
  break;
  case 217:return 'CONNECT'
  break;
  case 218:return 'CONNECTION'
  break;
  case 219:return 'CONSISTENCY'
  break;
  case 220:return 'CONSISTENT'
  break;
  case 221:return 'CONSTRAINT'
  break;
  case 222:return 'CONSTRAINTS'
  break;
  case 223:return 'CONSTRUCTOR'
  break;
  case 224:return 'CONSUMED'
  break;
  case 225:return 'CONTINUE'
  break;
  case 226:return 'CONVERT'
  break;
  case 227:return 'COPY'
  break;
  case 228:return 'CORRESPONDING'
  break;
  case 229:return 'COUNT'
  break;
  case 230:return 'COUNTER'
  break;
  case 231:return 135
  break;
  case 232:return 'CROSS'
  break;
  case 233:return 'CUBE'
  break;
  case 234:return 'CURRENT'
  break;
  case 235:return 'CURSOR'
  break;
  case 236:return 'CYCLE'
  break;
  case 237:return 'DATA'
  break;
  case 238:return 'DATABASE'
  break;
  case 239:return 'DATE'
  break;
  case 240:return 'DATETIME'
  break;
  case 241:return 'DAY'
  break;
  case 242:return 'DEALLOCATE'
  break;
  case 243:return 'DEC'
  break;
  case 244:return 'DECIMAL'
  break;
  case 245:return 'DECLARE'
  break;
  case 246:return 'DEFAULT'
  break;
  case 247:return 'DEFERRABLE'
  break;
  case 248:return 'DEFERRED'
  break;
  case 249:return 'DEFINE'
  break;
  case 250:return 'DEFINED'
  break;
  case 251:return 'DEFINITION'
  break;
  case 252:return 95
  break;
  case 253:return 'DELIMITED'
  break;
  case 254:return 'DEPTH'
  break;
  case 255:return 'DEREF'
  break;
  case 256:return 104
  break;
  case 257:return 157
  break;
  case 258:return 'DESCRIPTOR'
  break;
  case 259:return 'DETACH'
  break;
  case 260:return 'DETERMINISTIC'
  break;
  case 261:return 'DIAGNOSTICS'
  break;
  case 262:return 'DIRECTORIES'
  break;
  case 263:return 'DISABLE'
  break;
  case 264:return 'DISCONNECT'
  break;
  case 265:return 107
  break;
  case 266:return 'DISTRIBUTE'
  break;
  case 267:return 'DO'
  break;
  case 268:return 'DOMAIN'
  break;
  case 269:return 'DOUBLE'
  break;
  case 270:return 156
  break;
  case 271:return 'DUMP'
  break;
  case 272:return 'DURATION'
  break;
  case 273:return 'DYNAMIC'
  break;
  case 274:return 'EACH'
  break;
  case 275:return 'ELEMENT'
  break;
  case 276:return 'ELSE'
  break;
  case 277:return 'ELSEIF'
  break;
  case 278:return 'EMPTY'
  break;
  case 279:return 'ENABLE'
  break;
  case 280:return 'END'
  break;
  case 281:return 'EQUAL'
  break;
  case 282:return 'EQUALS'
  break;
  case 283:return 'ERROR'
  break;
  case 284:return 'ESCAPE'
  break;
  case 285:return 'ESCAPED'
  break;
  case 286:return 'EVAL'
  break;
  case 287:return 'EVALUATE'
  break;
  case 288:return 'EXCEEDED'
  break;
  case 289:return 'EXCEPT'
  break;
  case 290:return 'EXCEPTION'
  break;
  case 291:return 'EXCEPTIONS'
  break;
  case 292:return 'EXCLUSIVE'
  break;
  case 293:return 'EXEC'
  break;
  case 294:return 'EXECUTE'
  break;
  case 295:return 'EXISTS'
  break;
  case 296:return 'EXIT'
  break;
  case 297:return 'EXPLAIN'
  break;
  case 298:return 'EXPLODE'
  break;
  case 299:return 'EXPORT'
  break;
  case 300:return 'EXPRESSION'
  break;
  case 301:return 'EXTENDED'
  break;
  case 302:return 'EXTERNAL'
  break;
  case 303:return 'EXTRACT'
  break;
  case 304:return 'FAIL'
  break;
  case 305:return 36
  break;
  case 306:return 'FAMILY'
  break;
  case 307:return 'FETCH'
  break;
  case 308:return 'FIELDS'
  break;
  case 309:return 'FILE'
  break;
  case 310:return 'FILTER'
  break;
  case 311:return 'FILTERING'
  break;
  case 312:return 'FINAL'
  break;
  case 313:return 'FINISH'
  break;
  case 314:return 'FIRST'
  break;
  case 315:return 'FIXED'
  break;
  case 316:return 'FLATTERN'
  break;
  case 317:return 'FLOAT'
  break;
  case 318:return 'FOR'
  break;
  case 319:return 'FORCE'
  break;
  case 320:return 'FOREIGN'
  break;
  case 321:return 'FORMAT'
  break;
  case 322:return 'FORWARD'
  break;
  case 323:return 'FOUND'
  break;
  case 324:return 'FREE'
  break;
  case 325:return 96
  break;
  case 326:return 'FULL'
  break;
  case 327:return 'FUNCTION'
  break;
  case 328:return 'FUNCTIONS'
  break;
  case 329:return 'GENERAL'
  break;
  case 330:return 'GENERATE'
  break;
  case 331:return 'GET'
  break;
  case 332:return 'GLOB'
  break;
  case 333:return 'GLOBAL'
  break;
  case 334:return 'GO'
  break;
  case 335:return 'GOTO'
  break;
  case 336:return 'GRANT'
  break;
  case 337:return 'GREATER'
  break;
  case 338:return 'GROUP'
  break;
  case 339:return 'GROUPING'
  break;
  case 340:return 'HANDLER'
  break;
  case 341:return 'HASH'
  break;
  case 342:return 'HAVE'
  break;
  case 343:return 122
  break;
  case 344:return 'HEAP'
  break;
  case 345:return 'HIDDEN'
  break;
  case 346:return 'HOLD'
  break;
  case 347:return 'HOUR'
  break;
  case 348:return 'IDENTIFIED'
  break;
  case 349:return 'IDENTITY'
  break;
  case 350:return 'IF'
  break;
  case 351:return 81
  break;
  case 352:return 'IMMEDIATE'
  break;
  case 353:return 'IMPORT'
  break;
  case 354:return 'IN'
  break;
  case 355:return 'INCLUDING'
  break;
  case 356:return 'INCLUSIVE'
  break;
  case 357:return 'INCREMENT'
  break;
  case 358:return 'INCREMENTAL'
  break;
  case 359:return 118
  break;
  case 360:return 'INDEXED'
  break;
  case 361:return 'INDEXES'
  break;
  case 362:return 'INDICATOR'
  break;
  case 363:return 'INFINITE'
  break;
  case 364:return 'INITIALLY'
  break;
  case 365:return 'INLINE'
  break;
  case 366:return 'INNER'
  break;
  case 367:return 'INNTER'
  break;
  case 368:return 'INOUT'
  break;
  case 369:return 'INPUT'
  break;
  case 370:return 'INSENSITIVE'
  break;
  case 371:return 76
  break;
  case 372:return 'INSTEAD'
  break;
  case 373:return 'INT'
  break;
  case 374:return 'INTEGER'
  break;
  case 375:return 'INTERSECT'
  break;
  case 376:return 'INTERVAL'
  break;
  case 377:return 78
  break;
  case 378:return 'INVALIDATE'
  break;
  case 379:return 'IS'
  break;
  case 380:return 'ISOLATION'
  break;
  case 381:return 'ITEM'
  break;
  case 382:return 'ITEMS'
  break;
  case 383:return 'ITERATE'
  break;
  case 384:return 'JOIN'
  break;
  case 385:return 147
  break;
  case 386:return 'KEYS'
  break;
  case 387:return 'LAG'
  break;
  case 388:return 'LANGUAGE'
  break;
  case 389:return 'LARGE'
  break;
  case 390:return 'LAST'
  break;
  case 391:return 'LATERAL'
  break;
  case 392:return 'LEAD'
  break;
  case 393:return 'LEADING'
  break;
  case 394:return 'LEAVE'
  break;
  case 395:return 'LEFT'
  break;
  case 396:return 'LENGTH'
  break;
  case 397:return 'LESS'
  break;
  case 398:return 'LEVEL'
  break;
  case 399:return 133
  break;
  case 400:return 103
  break;
  case 401:return 'LIMITED'
  break;
  case 402:return 'LINES'
  break;
  case 403:return 'LIST'
  break;
  case 404:return 'LOAD'
  break;
  case 405:return 'LOCAL'
  break;
  case 406:return 'LOCALTIME'
  break;
  case 407:return 'LOCALTIMESTAMP'
  break;
  case 408:return 'LOCATION'
  break;
  case 409:return 'LOCATOR'
  break;
  case 410:return 'LOCK'
  break;
  case 411:return 'LOCKS'
  break;
  case 412:return 'LOG'
  break;
  case 413:return 'LOGED'
  break;
  case 414:return 'LONG'
  break;
  case 415:return 'LOOP'
  break;
  case 416:return 'LOWER'
  break;
  case 417:return 'MAP'
  break;
  case 418:return 'MATCH'
  break;
  case 419:return 'MATERIALIZED'
  break;
  case 420:return 'MAX'
  break;
  case 421:return 'MAXLEN'
  break;
  case 422:return 'MEMBER'
  break;
  case 423:return 'MERGE'
  break;
  case 424:return 'METHOD'
  break;
  case 425:return 'METRICS'
  break;
  case 426:return 'MIN'
  break;
  case 427:return 'MINUS'
  break;
  case 428:return 'MINUTE'
  break;
  case 429:return 'MISSING'
  break;
  case 430:return 'MOD'
  break;
  case 431:return 'MODE'
  break;
  case 432:return 'MODIFIES'
  break;
  case 433:return 'MODIFY'
  break;
  case 434:return 'MODULE'
  break;
  case 435:return 'MONTH'
  break;
  case 436:return 'MULTI'
  break;
  case 437:return 'MULTISET'
  break;
  case 438:return 'NAME'
  break;
  case 439:return 'NAMES'
  break;
  case 440:return 'NATIONAL'
  break;
  case 441:return 'NATURAL'
  break;
  case 442:return 'NCHAR'
  break;
  case 443:return 'NCLOB'
  break;
  case 444:return 68
  break;
  case 445:return 'NEXT'
  break;
  case 446:return 'NO'
  break;
  case 447:return 'NONE'
  break;
  case 448:return 'NOT'
  break;
  case 449:return 45
  break;
  case 450:return 'NULLIF'
  break;
  case 451:return 28
  break;
  case 452:return 'NUMERIC'
  break;
  case 453:return 'OBJECT'
  break;
  case 454:return 'OF'
  break;
  case 455:return 'OFFLINE'
  break;
  case 456:return 'OFFSET'
  break;
  case 457:return 'OLD'
  break;
  case 458:return 158
  break;
  case 459:return 'ONLINE'
  break;
  case 460:return 'ONLY'
  break;
  case 461:return 'OPAQUE'
  break;
  case 462:return 'OPEN'
  break;
  case 463:return 'OPERATOR'
  break;
  case 464:return 'OPTION'
  break;
  case 465:return 126
  break;
  case 466:return 'ORDER'
  break;
  case 467:return 'ORDINALITY'
  break;
  case 468:return 'OTHER'
  break;
  case 469:return 'OTHERS'
  break;
  case 470:return 'OUT'
  break;
  case 471:return 'OUTER'
  break;
  case 472:return 'OUTPUT'
  break;
  case 473:return 'OVER'
  break;
  case 474:return 'OVERLAPS'
  break;
  case 475:return 'OVERRIDE'
  break;
  case 476:return 'OWNER'
  break;
  case 477:return 'PAD'
  break;
  case 478:return 'PARALLEL'
  break;
  case 479:return 'PARAMETER'
  break;
  case 480:return 'PARAMETERS'
  break;
  case 481:return 'PARTIAL'
  break;
  case 482:return 'PARTITION'
  break;
  case 483:return 'PARTITIONED'
  break;
  case 484:return 'PARTITIONS'
  break;
  case 485:return 'PATH'
  break;
  case 486:return 'PERCENT'
  break;
  case 487:return 'PERCENTILE'
  break;
  case 488:return 'PERMISSION'
  break;
  case 489:return 'PERMISSIONS'
  break;
  case 490:return 'PIPE'
  break;
  case 491:return 'PIPELINED'
  break;
  case 492:return 'PLAN'
  break;
  case 493:return 'POOL'
  break;
  case 494:return 'POSITION'
  break;
  case 495:return 'PRECISION'
  break;
  case 496:return 'PREPARE'
  break;
  case 497:return 'PRESERVE'
  break;
  case 498:return 146
  break;
  case 499:return 'PRIOR'
  break;
  case 500:return 'PRIVATE'
  break;
  case 501:return 'PRIVILEGES'
  break;
  case 502:return 'PROCEDURE'
  break;
  case 503:return 'PROCESSED'
  break;
  case 504:return 'PROJECT'
  break;
  case 505:return 149
  break;
  case 506:return 'PROPERTY'
  break;
  case 507:return 'PROVISIONING'
  break;
  case 508:return 'PUBLIC'
  break;
  case 509:return 'PUT'
  break;
  case 510:return 'QUERY'
  break;
  case 511:return 'QUIT'
  break;
  case 512:return 'QUORUM'
  break;
  case 513:return 'RAISE'
  break;
  case 514:return 'RANDOM'
  break;
  case 515:return 'RANGE'
  break;
  case 516:return 'RANK'
  break;
  case 517:return 'RAW'
  break;
  case 518:return 'READ'
  break;
  case 519:return 'READS'
  break;
  case 520:return 'REAL'
  break;
  case 521:return 'REBUILD'
  break;
  case 522:return 'RECORD'
  break;
  case 523:return 'RECURSIVE'
  break;
  case 524:return 'REDUCE'
  break;
  case 525:return 'REF'
  break;
  case 526:return 'REFERENCE'
  break;
  case 527:return 'REFERENCES'
  break;
  case 528:return 'REFERENCING'
  break;
  case 529:return 'REGEXP'
  break;
  case 530:return 'REGION'
  break;
  case 531:return 'REINDEX'
  break;
  case 532:return 'RELATIVE'
  break;
  case 533:return 'RELEASE'
  break;
  case 534:return 'REMAINDER'
  break;
  case 535:return 'RENAME'
  break;
  case 536:return 'REPEAT'
  break;
  case 537:return 92
  break;
  case 538:return 'REQUEST'
  break;
  case 539:return 'RESET'
  break;
  case 540:return 'RESIGNAL'
  break;
  case 541:return 'RESOURCE'
  break;
  case 542:return 'RESPONSE'
  break;
  case 543:return 'RESTORE'
  break;
  case 544:return 'RESTRICT'
  break;
  case 545:return 'RESULT'
  break;
  case 546:return 'RETURN'
  break;
  case 547:return 'RETURNING'
  break;
  case 548:return 'RETURNS'
  break;
  case 549:return 'REVERSE'
  break;
  case 550:return 'REVOKE'
  break;
  case 551:return 'RIGHT'
  break;
  case 552:return 'ROLE'
  break;
  case 553:return 'ROLES'
  break;
  case 554:return 'ROLLBACK'
  break;
  case 555:return 'ROLLUP'
  break;
  case 556:return 'ROUTINE'
  break;
  case 557:return 'ROW'
  break;
  case 558:return 'ROWS'
  break;
  case 559:return 'RULE'
  break;
  case 560:return 'RULES'
  break;
  case 561:return 'SAMPLE'
  break;
  case 562:return 'SATISFIES'
  break;
  case 563:return 'SAVE'
  break;
  case 564:return 'SAVEPOINT'
  break;
  case 565:return 162
  break;
  case 566:return 'SCHEMA'
  break;
  case 567:return 'SCOPE'
  break;
  case 568:return 'SCROLL'
  break;
  case 569:return 'SEARCH'
  break;
  case 570:return 'SECOND'
  break;
  case 571:return 'SECTION'
  break;
  case 572:return 'SEGMENT'
  break;
  case 573:return 'SEGMENTS'
  break;
  case 574:return 124
  break;
  case 575:return 'SELF'
  break;
  case 576:return 'SEMI'
  break;
  case 577:return 'SENSITIVE'
  break;
  case 578:return 'SEPARATE'
  break;
  case 579:return 'SEQUENCE'
  break;
  case 580:return 'SERIALIZABLE'
  break;
  case 581:return 'SESSION'
  break;
  case 582:return 79
  break;
  case 583:return 'SETS'
  break;
  case 584:return 'SHARD'
  break;
  case 585:return 'SHARE'
  break;
  case 586:return 'SHARED'
  break;
  case 587:return 'SHORT'
  break;
  case 588:return 154
  break;
  case 589:return 'SIGNAL'
  break;
  case 590:return 'SIMILAR'
  break;
  case 591:return 'SIZE'
  break;
  case 592:return 'SKEWED'
  break;
  case 593:return 'SMALLINT'
  break;
  case 594:return 'SNAPSHOT'
  break;
  case 595:return 'SOME'
  break;
  case 596:return 'SOURCE'
  break;
  case 597:return 'SPACE'
  break;
  case 598:return 'SPACES'
  break;
  case 599:return 'SPARSE'
  break;
  case 600:return 'SPECIFIC'
  break;
  case 601:return 'SPECIFICTYPE'
  break;
  case 602:return 'SPLIT'
  break;
  case 603:return 'SQL'
  break;
  case 604:return 'SQLCODE'
  break;
  case 605:return 'SQLERROR'
  break;
  case 606:return 'SQLEXCEPTION'
  break;
  case 607:return 'SQLSTATE'
  break;
  case 608:return 'SQLWARNING'
  break;
  case 609:return 'START'
  break;
  case 610:return 'STATE'
  break;
  case 611:return 'STATIC'
  break;
  case 612:return 'STATUS'
  break;
  case 613:return 'STORAGE'
  break;
  case 614:return 'STORE'
  break;
  case 615:return 'STORED'
  break;
  case 616:return 'STREAM'
  break;
  case 617:return 153
  break;
  case 618:return 'STRUCT'
  break;
  case 619:return 'STYLE'
  break;
  case 620:return 'SUB'
  break;
  case 621:return 'SUBMULTISET'
  break;
  case 622:return 'SUBPARTITION'
  break;
  case 623:return 'SUBSTRING'
  break;
  case 624:return 'SUBTYPE'
  break;
  case 625:return 'SUM'
  break;
  case 626:return 'SUPER'
  break;
  case 627:return 'SYMMETRIC'
  break;
  case 628:return 'SYNONYM'
  break;
  case 629:return 'SYSTEM'
  break;
  case 630:return 136
  break;
  case 631:return 'TABLESAMPLE'
  break;
  case 632:return 'TEMP'
  break;
  case 633:return 'TEMPORARY'
  break;
  case 634:return 'TERMINATED'
  break;
  case 635:return 'TEXT'
  break;
  case 636:return 'THAN'
  break;
  case 637:return 'THEN'
  break;
  case 638:return 148
  break;
  case 639:return 'TIME'
  break;
  case 640:return 'TIMESTAMP'
  break;
  case 641:return 'TIMEZONE'
  break;
  case 642:return 'TINYINT'
  break;
  case 643:return 'TO'
  break;
  case 644:return 'TOKEN'
  break;
  case 645:return 'TOTAL'
  break;
  case 646:return 'TOUCH'
  break;
  case 647:return 'TRAILING'
  break;
  case 648:return 'TRANSACTION'
  break;
  case 649:return 'TRANSFORM'
  break;
  case 650:return 'TRANSLATE'
  break;
  case 651:return 'TRANSLATION'
  break;
  case 652:return 'TREAT'
  break;
  case 653:return 'TRIGGER'
  break;
  case 654:return 'TRIM'
  break;
  case 655:return 35
  break;
  case 656:return 'TRUNCATE'
  break;
  case 657:return 'TTL'
  break;
  case 658:return 'TUPLE'
  break;
  case 659:return 'TYPE'
  break;
  case 660:return 'UNDER'
  break;
  case 661:return 'UNDO'
  break;
  case 662:return 'UNION'
  break;
  case 663:return 'UNIQUE'
  break;
  case 664:return 'UNIT'
  break;
  case 665:return 'UNKNOWN'
  break;
  case 666:return 'UNLOGGED'
  break;
  case 667:return 'UNNEST'
  break;
  case 668:return 'UNPROCESSED'
  break;
  case 669:return 'UNSIGNED'
  break;
  case 670:return 'UNTIL'
  break;
  case 671:return 84
  break;
  case 672:return 'UPPER'
  break;
  case 673:return 'URL'
  break;
  case 674:return 'USAGE'
  break;
  case 675:return 117
  break;
  case 676:return 'USER'
  break;
  case 677:return 'USERS'
  break;
  case 678:return 'USING'
  break;
  case 679:return 'UUID'
  break;
  case 680:return 'VACUUM'
  break;
  case 681:return 'VALUE'
  break;
  case 682:return 'VALUED'
  break;
  case 683:return 'VALUES'
  break;
  case 684:return 'VARCHAR'
  break;
  case 685:return 'VARIABLE'
  break;
  case 686:return 'VARIANCE'
  break;
  case 687:return 'VARINT'
  break;
  case 688:return 'VARYING'
  break;
  case 689:return 'VIEW'
  break;
  case 690:return 'VIEWS'
  break;
  case 691:return 'VIRTUAL'
  break;
  case 692:return 'VOID'
  break;
  case 693:return 'WAIT'
  break;
  case 694:return 'WHEN'
  break;
  case 695:return 'WHENEVER'
  break;
  case 696:return 86
  break;
  case 697:return 'WHILE'
  break;
  case 698:return 'WINDOW'
  break;
  case 699:return 'WITH'
  break;
  case 700:return 'WITHIN'
  break;
  case 701:return 'WITHOUT'
  break;
  case 702:return 'WORK'
  break;
  case 703:return 'WRAPPED'
  break;
  case 704:return 'WRITE'
  break;
  case 705:return 'YEAR'
  break;
  case 706:return 'ZONE'
  break;
  case 707:return 28
  break;
  case 708:return 28
  break;
  case 709:return 'TILDEs'
  break;
  case 710:return 89
  break;
  case 711:return 'PLUS'
  break;
  case 712:return 'MINUS'
  break;
  case 713:return 111
  break;
  case 714:return 'SLASH'
  break;
  case 715:return 'REM'
  break;
  case 716:return 'RSHIFT'
  break;
  case 717:return 'LSHIFT'
  break;
  case 718:return 'NE'
  break;
  case 719:return 'NE'
  break;
  case 720:return 128
  break;
  case 721:return 127
  break;
  case 722:return 130
  break;
  case 723:return 129
  break;
  case 724:return 83
  break;
  case 725:return 'BITAND'
  break;
  case 726:return 'BITOR'
  break;
  case 727:return 70
  break;
  case 728:return 72
  break;
  case 729:return 60
  break;
  case 730:return 62
  break;
  case 731:return 50
  break;
  case 732:return 52
  break;
  case 733:return 23
  break;
  case 734:return 53
  break;
  case 735:return 64
  break;
  case 736:return 6
  break;
  case 737:return 'DOLLAR'
  break;
  case 738:return 'QUESTION'
  break;
  case 739:return 'CARET'
  break;
  case 740:return 20
  break;
  case 741:return 5
  break;
  case 742:return 'INVALID'
  break;
  }
  },
  rules: [/^(?:([`](\\.|[^"]|\\")*?[`])+)/i,/^(?:(['](\\.|[^']|\\')*?['])+)/i,/^(?:(["](\\.|[^"]|\\")*?["])+)/i,/^(?:--(.*?)($|\r\n|\r|\n))/i,/^(?:\s+)/i,/^(?:ABORT\b)/i,/^(?:ADD\b)/i,/^(?:AFTER\b)/i,/^(?:ALTER\b)/i,/^(?:ANALYZE\b)/i,/^(?:AND\b)/i,/^(?:AS\b)/i,/^(?:ASC\b)/i,/^(?:ATTACH\b)/i,/^(?:BEFORE\b)/i,/^(?:BEGIN\b)/i,/^(?:BETWEEN\b)/i,/^(?:BY\b)/i,/^(?:CASCADE\b)/i,/^(?:CASE\b)/i,/^(?:CAST\b)/i,/^(?:CHECK\b)/i,/^(?:COLLATE\b)/i,/^(?:COLUMN\b)/i,/^(?:CONFLICT\b)/i,/^(?:CONSISTENT_READ\b)/i,/^(?:CONSTRAINT\b)/i,/^(?:CREATE\b)/i,/^(?:CROSS\b)/i,/^(?:CURRENT_DATE\b)/i,/^(?:CURRENT_TIME\b)/i,/^(?:CURRENT_TIMESTAMP\b)/i,/^(?:DATABASE\b)/i,/^(?:DEFAULT\b)/i,/^(?:DEFERRABLE\b)/i,/^(?:DEFERRED\b)/i,/^(?:DELETE\b)/i,/^(?:DESC\b)/i,/^(?:DETACH\b)/i,/^(?:DISTINCT\b)/i,/^(?:DROP\b)/i,/^(?:DESCRIBE\b)/i,/^(?:EACH\b)/i,/^(?:ELSE\b)/i,/^(?:END\b)/i,/^(?:ESCAPE\b)/i,/^(?:EXCEPT\b)/i,/^(?:EXCLUSIVE\b)/i,/^(?:EXISTS\b)/i,/^(?:EXPLAIN\b)/i,/^(?:FAIL\b)/i,/^(?:FOR\b)/i,/^(?:FOREIGN\b)/i,/^(?:FROM\b)/i,/^(?:FULL\b)/i,/^(?:GLOB\b)/i,/^(?:GROUP\b)/i,/^(?:HAVING\b)/i,/^(?:IF\b)/i,/^(?:IGNORE\b)/i,/^(?:IMMEDIATE\b)/i,/^(?:IN\b)/i,/^(?:USE\b)/i,/^(?:INDEX\b)/i,/^(?:INDEXED\b)/i,/^(?:INITIALLY\b)/i,/^(?:INNER\b)/i,/^(?:INSERT\b)/i,/^(?:INSTEAD\b)/i,/^(?:INTERSECT\b)/i,/^(?:INTO\b)/i,/^(?:IS\b)/i,/^(?:ISNULL\b)/i,/^(?:JOIN\b)/i,/^(?:KEY\b)/i,/^(?:LEFT\b)/i,/^(?:LIKE\b)/i,/^(?:CONTAINS\b)/i,/^(?:LIMIT\b)/i,/^(?:MATCH\b)/i,/^(?:NATURAL\b)/i,/^(?:NO\b)/i,/^(?:NOT\b)/i,/^(?:NOTNULL\b)/i,/^(?:NULL\b)/i,/^(?:UNDEFINED\b)/i,/^(?:OF\b)/i,/^(?:OFFSET\b)/i,/^(?:ON\b)/i,/^(?:OR\b)/i,/^(?:ORDER\b)/i,/^(?:OUTER\b)/i,/^(?:PLAN\b)/i,/^(?:PRAGMA\b)/i,/^(?:PRIMARY\b)/i,/^(?:QUERY\b)/i,/^(?:RAISE\b)/i,/^(?:RECURSIVE\b)/i,/^(?:REFERENCES\b)/i,/^(?:REGEXP\b)/i,/^(?:REINDEX\b)/i,/^(?:RELEASE\b)/i,/^(?:RENAME\b)/i,/^(?:REPLACE\b)/i,/^(?:RESTRICT\b)/i,/^(?:RIGHT\b)/i,/^(?:ROLLBACK\b)/i,/^(?:ROW\b)/i,/^(?:SELECT\b)/i,/^(?:SCAN\b)/i,/^(?:SET\b)/i,/^(?:TABLE\b)/i,/^(?:TEMP\b)/i,/^(?:THEN\b)/i,/^(?:TO\b)/i,/^(?:TRIGGER\b)/i,/^(?:UNION\b)/i,/^(?:UNIQUE\b)/i,/^(?:UPDATE\b)/i,/^(?:USING\b)/i,/^(?:VACUUM\b)/i,/^(?:VALUES\b)/i,/^(?:VIEW\b)/i,/^(?:WHEN\b)/i,/^(?:WHERE\b)/i,/^(?:WITH\b)/i,/^(?:TRUE\b)/i,/^(?:FALSE\b)/i,/^(?:SHOW\b)/i,/^(?:TABLES\b)/i,/^(?:STRING\b)/i,/^(?:NUMBER\b)/i,/^(?:STRINGSET\b)/i,/^(?:NUMBERSET\b)/i,/^(?:BINARYSET\b)/i,/^(?:THROUGHPUT\b)/i,/^(?:GSI\b)/i,/^(?:LSI\b)/i,/^(?:PROJECTION\b)/i,/^(?:ALL\b)/i,/^(?:KEYS_ONLY\b)/i,/^(?:NEW\b)/i,/^(?:ALLOCATE\b)/i,/^(?:ALTER\b)/i,/^(?:ANALYZE\b)/i,/^(?:AND\b)/i,/^(?:ANY\b)/i,/^(?:ARCHIVE\b)/i,/^(?:ARE\b)/i,/^(?:ARRAY\b)/i,/^(?:AS\b)/i,/^(?:ASC\b)/i,/^(?:ASCII\b)/i,/^(?:ASENSITIVE\b)/i,/^(?:ASSERTION\b)/i,/^(?:ASYMMETRIC\b)/i,/^(?:AT\b)/i,/^(?:ATOMIC\b)/i,/^(?:ATTACH\b)/i,/^(?:ATTRIBUTE\b)/i,/^(?:AUTH\b)/i,/^(?:AUTHORIZATION\b)/i,/^(?:AUTHORIZE\b)/i,/^(?:AUTO\b)/i,/^(?:AVG\b)/i,/^(?:BACK\b)/i,/^(?:BACKUP\b)/i,/^(?:BASE\b)/i,/^(?:BATCH\b)/i,/^(?:BEFORE\b)/i,/^(?:BEGIN\b)/i,/^(?:BETWEEN\b)/i,/^(?:BIGINT\b)/i,/^(?:BINARY\b)/i,/^(?:BIT\b)/i,/^(?:BLOB\b)/i,/^(?:BLOCK\b)/i,/^(?:BOOLEAN\b)/i,/^(?:BOTH\b)/i,/^(?:BREADTH\b)/i,/^(?:BUCKET\b)/i,/^(?:BULK\b)/i,/^(?:BY\b)/i,/^(?:BYTE\b)/i,/^(?:CALL\b)/i,/^(?:CALLED\b)/i,/^(?:CALLING\b)/i,/^(?:CAPACITY\b)/i,/^(?:CASCADE\b)/i,/^(?:CASCADED\b)/i,/^(?:CASE\b)/i,/^(?:CAST\b)/i,/^(?:CATALOG\b)/i,/^(?:CHAR\b)/i,/^(?:CHARACTER\b)/i,/^(?:CHECK\b)/i,/^(?:CLASS\b)/i,/^(?:CLOB\b)/i,/^(?:CLOSE\b)/i,/^(?:CLUSTER\b)/i,/^(?:CLUSTERED\b)/i,/^(?:CLUSTERING\b)/i,/^(?:CLUSTERS\b)/i,/^(?:COALESCE\b)/i,/^(?:COLLATE\b)/i,/^(?:COLLATION\b)/i,/^(?:COLLECTION\b)/i,/^(?:COLUMN\b)/i,/^(?:COLUMNS\b)/i,/^(?:COMBINE\b)/i,/^(?:COMMENT\b)/i,/^(?:COMMIT\b)/i,/^(?:COMPACT\b)/i,/^(?:COMPILE\b)/i,/^(?:COMPRESS\b)/i,/^(?:CONDITION\b)/i,/^(?:CONFLICT\b)/i,/^(?:CONNECT\b)/i,/^(?:CONNECTION\b)/i,/^(?:CONSISTENCY\b)/i,/^(?:CONSISTENT\b)/i,/^(?:CONSTRAINT\b)/i,/^(?:CONSTRAINTS\b)/i,/^(?:CONSTRUCTOR\b)/i,/^(?:CONSUMED\b)/i,/^(?:CONTINUE\b)/i,/^(?:CONVERT\b)/i,/^(?:COPY\b)/i,/^(?:CORRESPONDING\b)/i,/^(?:COUNT\b)/i,/^(?:COUNTER\b)/i,/^(?:CREATE\b)/i,/^(?:CROSS\b)/i,/^(?:CUBE\b)/i,/^(?:CURRENT\b)/i,/^(?:CURSOR\b)/i,/^(?:CYCLE\b)/i,/^(?:DATA\b)/i,/^(?:DATABASE\b)/i,/^(?:DATE\b)/i,/^(?:DATETIME\b)/i,/^(?:DAY\b)/i,/^(?:DEALLOCATE\b)/i,/^(?:DEC\b)/i,/^(?:DECIMAL\b)/i,/^(?:DECLARE\b)/i,/^(?:DEFAULT\b)/i,/^(?:DEFERRABLE\b)/i,/^(?:DEFERRED\b)/i,/^(?:DEFINE\b)/i,/^(?:DEFINED\b)/i,/^(?:DEFINITION\b)/i,/^(?:DELETE\b)/i,/^(?:DELIMITED\b)/i,/^(?:DEPTH\b)/i,/^(?:DEREF\b)/i,/^(?:DESC\b)/i,/^(?:DESCRIBE\b)/i,/^(?:DESCRIPTOR\b)/i,/^(?:DETACH\b)/i,/^(?:DETERMINISTIC\b)/i,/^(?:DIAGNOSTICS\b)/i,/^(?:DIRECTORIES\b)/i,/^(?:DISABLE\b)/i,/^(?:DISCONNECT\b)/i,/^(?:DISTINCT\b)/i,/^(?:DISTRIBUTE\b)/i,/^(?:DO\b)/i,/^(?:DOMAIN\b)/i,/^(?:DOUBLE\b)/i,/^(?:DROP\b)/i,/^(?:DUMP\b)/i,/^(?:DURATION\b)/i,/^(?:DYNAMIC\b)/i,/^(?:EACH\b)/i,/^(?:ELEMENT\b)/i,/^(?:ELSE\b)/i,/^(?:ELSEIF\b)/i,/^(?:EMPTY\b)/i,/^(?:ENABLE\b)/i,/^(?:END\b)/i,/^(?:EQUAL\b)/i,/^(?:EQUALS\b)/i,/^(?:ERROR\b)/i,/^(?:ESCAPE\b)/i,/^(?:ESCAPED\b)/i,/^(?:EVAL\b)/i,/^(?:EVALUATE\b)/i,/^(?:EXCEEDED\b)/i,/^(?:EXCEPT\b)/i,/^(?:EXCEPTION\b)/i,/^(?:EXCEPTIONS\b)/i,/^(?:EXCLUSIVE\b)/i,/^(?:EXEC\b)/i,/^(?:EXECUTE\b)/i,/^(?:EXISTS\b)/i,/^(?:EXIT\b)/i,/^(?:EXPLAIN\b)/i,/^(?:EXPLODE\b)/i,/^(?:EXPORT\b)/i,/^(?:EXPRESSION\b)/i,/^(?:EXTENDED\b)/i,/^(?:EXTERNAL\b)/i,/^(?:EXTRACT\b)/i,/^(?:FAIL\b)/i,/^(?:FALSE\b)/i,/^(?:FAMILY\b)/i,/^(?:FETCH\b)/i,/^(?:FIELDS\b)/i,/^(?:FILE\b)/i,/^(?:FILTER\b)/i,/^(?:FILTERING\b)/i,/^(?:FINAL\b)/i,/^(?:FINISH\b)/i,/^(?:FIRST\b)/i,/^(?:FIXED\b)/i,/^(?:FLATTERN\b)/i,/^(?:FLOAT\b)/i,/^(?:FOR\b)/i,/^(?:FORCE\b)/i,/^(?:FOREIGN\b)/i,/^(?:FORMAT\b)/i,/^(?:FORWARD\b)/i,/^(?:FOUND\b)/i,/^(?:FREE\b)/i,/^(?:FROM\b)/i,/^(?:FULL\b)/i,/^(?:FUNCTION\b)/i,/^(?:FUNCTIONS\b)/i,/^(?:GENERAL\b)/i,/^(?:GENERATE\b)/i,/^(?:GET\b)/i,/^(?:GLOB\b)/i,/^(?:GLOBAL\b)/i,/^(?:GO\b)/i,/^(?:GOTO\b)/i,/^(?:GRANT\b)/i,/^(?:GREATER\b)/i,/^(?:GROUP\b)/i,/^(?:GROUPING\b)/i,/^(?:HANDLER\b)/i,/^(?:HASH\b)/i,/^(?:HAVE\b)/i,/^(?:HAVING\b)/i,/^(?:HEAP\b)/i,/^(?:HIDDEN\b)/i,/^(?:HOLD\b)/i,/^(?:HOUR\b)/i,/^(?:IDENTIFIED\b)/i,/^(?:IDENTITY\b)/i,/^(?:IF\b)/i,/^(?:IGNORE\b)/i,/^(?:IMMEDIATE\b)/i,/^(?:IMPORT\b)/i,/^(?:IN\b)/i,/^(?:INCLUDING\b)/i,/^(?:INCLUSIVE\b)/i,/^(?:INCREMENT\b)/i,/^(?:INCREMENTAL\b)/i,/^(?:INDEX\b)/i,/^(?:INDEXED\b)/i,/^(?:INDEXES\b)/i,/^(?:INDICATOR\b)/i,/^(?:INFINITE\b)/i,/^(?:INITIALLY\b)/i,/^(?:INLINE\b)/i,/^(?:INNER\b)/i,/^(?:INNTER\b)/i,/^(?:INOUT\b)/i,/^(?:INPUT\b)/i,/^(?:INSENSITIVE\b)/i,/^(?:INSERT\b)/i,/^(?:INSTEAD\b)/i,/^(?:INT\b)/i,/^(?:INTEGER\b)/i,/^(?:INTERSECT\b)/i,/^(?:INTERVAL\b)/i,/^(?:INTO\b)/i,/^(?:INVALIDATE\b)/i,/^(?:IS\b)/i,/^(?:ISOLATION\b)/i,/^(?:ITEM\b)/i,/^(?:ITEMS\b)/i,/^(?:ITERATE\b)/i,/^(?:JOIN\b)/i,/^(?:KEY\b)/i,/^(?:KEYS\b)/i,/^(?:LAG\b)/i,/^(?:LANGUAGE\b)/i,/^(?:LARGE\b)/i,/^(?:LAST\b)/i,/^(?:LATERAL\b)/i,/^(?:LEAD\b)/i,/^(?:LEADING\b)/i,/^(?:LEAVE\b)/i,/^(?:LEFT\b)/i,/^(?:LENGTH\b)/i,/^(?:LESS\b)/i,/^(?:LEVEL\b)/i,/^(?:LIKE\b)/i,/^(?:LIMIT\b)/i,/^(?:LIMITED\b)/i,/^(?:LINES\b)/i,/^(?:LIST\b)/i,/^(?:LOAD\b)/i,/^(?:LOCAL\b)/i,/^(?:LOCALTIME\b)/i,/^(?:LOCALTIMESTAMP\b)/i,/^(?:LOCATION\b)/i,/^(?:LOCATOR\b)/i,/^(?:LOCK\b)/i,/^(?:LOCKS\b)/i,/^(?:LOG\b)/i,/^(?:LOGED\b)/i,/^(?:LONG\b)/i,/^(?:LOOP\b)/i,/^(?:LOWER\b)/i,/^(?:MAP\b)/i,/^(?:MATCH\b)/i,/^(?:MATERIALIZED\b)/i,/^(?:MAX\b)/i,/^(?:MAXLEN\b)/i,/^(?:MEMBER\b)/i,/^(?:MERGE\b)/i,/^(?:METHOD\b)/i,/^(?:METRICS\b)/i,/^(?:MIN\b)/i,/^(?:MINUS\b)/i,/^(?:MINUTE\b)/i,/^(?:MISSING\b)/i,/^(?:MOD\b)/i,/^(?:MODE\b)/i,/^(?:MODIFIES\b)/i,/^(?:MODIFY\b)/i,/^(?:MODULE\b)/i,/^(?:MONTH\b)/i,/^(?:MULTI\b)/i,/^(?:MULTISET\b)/i,/^(?:NAME\b)/i,/^(?:NAMES\b)/i,/^(?:NATIONAL\b)/i,/^(?:NATURAL\b)/i,/^(?:NCHAR\b)/i,/^(?:NCLOB\b)/i,/^(?:NEW\b)/i,/^(?:NEXT\b)/i,/^(?:NO\b)/i,/^(?:NONE\b)/i,/^(?:NOT\b)/i,/^(?:NULL\b)/i,/^(?:NULLIF\b)/i,/^(?:NUMBER\b)/i,/^(?:NUMERIC\b)/i,/^(?:OBJECT\b)/i,/^(?:OF\b)/i,/^(?:OFFLINE\b)/i,/^(?:OFFSET\b)/i,/^(?:OLD\b)/i,/^(?:ON\b)/i,/^(?:ONLINE\b)/i,/^(?:ONLY\b)/i,/^(?:OPAQUE\b)/i,/^(?:OPEN\b)/i,/^(?:OPERATOR\b)/i,/^(?:OPTION\b)/i,/^(?:OR\b)/i,/^(?:ORDER\b)/i,/^(?:ORDINALITY\b)/i,/^(?:OTHER\b)/i,/^(?:OTHERS\b)/i,/^(?:OUT\b)/i,/^(?:OUTER\b)/i,/^(?:OUTPUT\b)/i,/^(?:OVER\b)/i,/^(?:OVERLAPS\b)/i,/^(?:OVERRIDE\b)/i,/^(?:OWNER\b)/i,/^(?:PAD\b)/i,/^(?:PARALLEL\b)/i,/^(?:PARAMETER\b)/i,/^(?:PARAMETERS\b)/i,/^(?:PARTIAL\b)/i,/^(?:PARTITION\b)/i,/^(?:PARTITIONED\b)/i,/^(?:PARTITIONS\b)/i,/^(?:PATH\b)/i,/^(?:PERCENT\b)/i,/^(?:PERCENTILE\b)/i,/^(?:PERMISSION\b)/i,/^(?:PERMISSIONS\b)/i,/^(?:PIPE\b)/i,/^(?:PIPELINED\b)/i,/^(?:PLAN\b)/i,/^(?:POOL\b)/i,/^(?:POSITION\b)/i,/^(?:PRECISION\b)/i,/^(?:PREPARE\b)/i,/^(?:PRESERVE\b)/i,/^(?:PRIMARY\b)/i,/^(?:PRIOR\b)/i,/^(?:PRIVATE\b)/i,/^(?:PRIVILEGES\b)/i,/^(?:PROCEDURE\b)/i,/^(?:PROCESSED\b)/i,/^(?:PROJECT\b)/i,/^(?:PROJECTION\b)/i,/^(?:PROPERTY\b)/i,/^(?:PROVISIONING\b)/i,/^(?:PUBLIC\b)/i,/^(?:PUT\b)/i,/^(?:QUERY\b)/i,/^(?:QUIT\b)/i,/^(?:QUORUM\b)/i,/^(?:RAISE\b)/i,/^(?:RANDOM\b)/i,/^(?:RANGE\b)/i,/^(?:RANK\b)/i,/^(?:RAW\b)/i,/^(?:READ\b)/i,/^(?:READS\b)/i,/^(?:REAL\b)/i,/^(?:REBUILD\b)/i,/^(?:RECORD\b)/i,/^(?:RECURSIVE\b)/i,/^(?:REDUCE\b)/i,/^(?:REF\b)/i,/^(?:REFERENCE\b)/i,/^(?:REFERENCES\b)/i,/^(?:REFERENCING\b)/i,/^(?:REGEXP\b)/i,/^(?:REGION\b)/i,/^(?:REINDEX\b)/i,/^(?:RELATIVE\b)/i,/^(?:RELEASE\b)/i,/^(?:REMAINDER\b)/i,/^(?:RENAME\b)/i,/^(?:REPEAT\b)/i,/^(?:REPLACE\b)/i,/^(?:REQUEST\b)/i,/^(?:RESET\b)/i,/^(?:RESIGNAL\b)/i,/^(?:RESOURCE\b)/i,/^(?:RESPONSE\b)/i,/^(?:RESTORE\b)/i,/^(?:RESTRICT\b)/i,/^(?:RESULT\b)/i,/^(?:RETURN\b)/i,/^(?:RETURNING\b)/i,/^(?:RETURNS\b)/i,/^(?:REVERSE\b)/i,/^(?:REVOKE\b)/i,/^(?:RIGHT\b)/i,/^(?:ROLE\b)/i,/^(?:ROLES\b)/i,/^(?:ROLLBACK\b)/i,/^(?:ROLLUP\b)/i,/^(?:ROUTINE\b)/i,/^(?:ROW\b)/i,/^(?:ROWS\b)/i,/^(?:RULE\b)/i,/^(?:RULES\b)/i,/^(?:SAMPLE\b)/i,/^(?:SATISFIES\b)/i,/^(?:SAVE\b)/i,/^(?:SAVEPOINT\b)/i,/^(?:SCAN\b)/i,/^(?:SCHEMA\b)/i,/^(?:SCOPE\b)/i,/^(?:SCROLL\b)/i,/^(?:SEARCH\b)/i,/^(?:SECOND\b)/i,/^(?:SECTION\b)/i,/^(?:SEGMENT\b)/i,/^(?:SEGMENTS\b)/i,/^(?:SELECT\b)/i,/^(?:SELF\b)/i,/^(?:SEMI\b)/i,/^(?:SENSITIVE\b)/i,/^(?:SEPARATE\b)/i,/^(?:SEQUENCE\b)/i,/^(?:SERIALIZABLE\b)/i,/^(?:SESSION\b)/i,/^(?:SET\b)/i,/^(?:SETS\b)/i,/^(?:SHARD\b)/i,/^(?:SHARE\b)/i,/^(?:SHARED\b)/i,/^(?:SHORT\b)/i,/^(?:SHOW\b)/i,/^(?:SIGNAL\b)/i,/^(?:SIMILAR\b)/i,/^(?:SIZE\b)/i,/^(?:SKEWED\b)/i,/^(?:SMALLINT\b)/i,/^(?:SNAPSHOT\b)/i,/^(?:SOME\b)/i,/^(?:SOURCE\b)/i,/^(?:SPACE\b)/i,/^(?:SPACES\b)/i,/^(?:SPARSE\b)/i,/^(?:SPECIFIC\b)/i,/^(?:SPECIFICTYPE\b)/i,/^(?:SPLIT\b)/i,/^(?:SQL\b)/i,/^(?:SQLCODE\b)/i,/^(?:SQLERROR\b)/i,/^(?:SQLEXCEPTION\b)/i,/^(?:SQLSTATE\b)/i,/^(?:SQLWARNING\b)/i,/^(?:START\b)/i,/^(?:STATE\b)/i,/^(?:STATIC\b)/i,/^(?:STATUS\b)/i,/^(?:STORAGE\b)/i,/^(?:STORE\b)/i,/^(?:STORED\b)/i,/^(?:STREAM\b)/i,/^(?:STRING\b)/i,/^(?:STRUCT\b)/i,/^(?:STYLE\b)/i,/^(?:SUB\b)/i,/^(?:SUBMULTISET\b)/i,/^(?:SUBPARTITION\b)/i,/^(?:SUBSTRING\b)/i,/^(?:SUBTYPE\b)/i,/^(?:SUM\b)/i,/^(?:SUPER\b)/i,/^(?:SYMMETRIC\b)/i,/^(?:SYNONYM\b)/i,/^(?:SYSTEM\b)/i,/^(?:TABLE\b)/i,/^(?:TABLESAMPLE\b)/i,/^(?:TEMP\b)/i,/^(?:TEMPORARY\b)/i,/^(?:TERMINATED\b)/i,/^(?:TEXT\b)/i,/^(?:THAN\b)/i,/^(?:THEN\b)/i,/^(?:THROUGHPUT\b)/i,/^(?:TIME\b)/i,/^(?:TIMESTAMP\b)/i,/^(?:TIMEZONE\b)/i,/^(?:TINYINT\b)/i,/^(?:TO\b)/i,/^(?:TOKEN\b)/i,/^(?:TOTAL\b)/i,/^(?:TOUCH\b)/i,/^(?:TRAILING\b)/i,/^(?:TRANSACTION\b)/i,/^(?:TRANSFORM\b)/i,/^(?:TRANSLATE\b)/i,/^(?:TRANSLATION\b)/i,/^(?:TREAT\b)/i,/^(?:TRIGGER\b)/i,/^(?:TRIM\b)/i,/^(?:TRUE\b)/i,/^(?:TRUNCATE\b)/i,/^(?:TTL\b)/i,/^(?:TUPLE\b)/i,/^(?:TYPE\b)/i,/^(?:UNDER\b)/i,/^(?:UNDO\b)/i,/^(?:UNION\b)/i,/^(?:UNIQUE\b)/i,/^(?:UNIT\b)/i,/^(?:UNKNOWN\b)/i,/^(?:UNLOGGED\b)/i,/^(?:UNNEST\b)/i,/^(?:UNPROCESSED\b)/i,/^(?:UNSIGNED\b)/i,/^(?:UNTIL\b)/i,/^(?:UPDATE\b)/i,/^(?:UPPER\b)/i,/^(?:URL\b)/i,/^(?:USAGE\b)/i,/^(?:USE\b)/i,/^(?:USER\b)/i,/^(?:USERS\b)/i,/^(?:USING\b)/i,/^(?:UUID\b)/i,/^(?:VACUUM\b)/i,/^(?:VALUE\b)/i,/^(?:VALUED\b)/i,/^(?:VALUES\b)/i,/^(?:VARCHAR\b)/i,/^(?:VARIABLE\b)/i,/^(?:VARIANCE\b)/i,/^(?:VARINT\b)/i,/^(?:VARYING\b)/i,/^(?:VIEW\b)/i,/^(?:VIEWS\b)/i,/^(?:VIRTUAL\b)/i,/^(?:VOID\b)/i,/^(?:WAIT\b)/i,/^(?:WHEN\b)/i,/^(?:WHENEVER\b)/i,/^(?:WHERE\b)/i,/^(?:WHILE\b)/i,/^(?:WINDOW\b)/i,/^(?:WITH\b)/i,/^(?:WITHIN\b)/i,/^(?:WITHOUT\b)/i,/^(?:WORK\b)/i,/^(?:WRAPPED\b)/i,/^(?:WRITE\b)/i,/^(?:YEAR\b)/i,/^(?:ZONE\b)/i,/^(?:[-]?(\d*[.])?\d+[eE]\d+)/i,/^(?:[-]?(\d*[.])?\d+)/i,/^(?:~)/i,/^(?:\+=)/i,/^(?:\+)/i,/^(?:-)/i,/^(?:\*)/i,/^(?:\/)/i,/^(?:%)/i,/^(?:>>)/i,/^(?:<<)/i,/^(?:<>)/i,/^(?:!=)/i,/^(?:>=)/i,/^(?:>)/i,/^(?:<=)/i,/^(?:<)/i,/^(?:=)/i,/^(?:&)/i,/^(?:\|)/i,/^(?:\()/i,/^(?:\))/i,/^(?:\{)/i,/^(?:\})/i,/^(?:\[)/i,/^(?:\])/i,/^(?:\.)/i,/^(?:,)/i,/^(?::)/i,/^(?:;)/i,/^(?:\$)/i,/^(?:\?)/i,/^(?:\^)/i,/^(?:[a-zA-Z_][a-zA-Z_0-9]*)/i,/^(?:$)/i,/^(?:.)/i],
  conditions: {"INITIAL":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742],"inclusive":true}}
  });
  return lexer;
  })();
  parser.lexer = lexer;
  function Parser () {
    this.yy = {};
  }
  Parser.prototype = parser;parser.Parser = Parser;
  return new Parser;
  })();
  
  
  if (typeof require !== 'undefined' && typeof exports !== 'undefined') {
  exports.parser = sqlparser;
  exports.Parser = sqlparser.Parser;
  exports.parse = function () { return sqlparser.parse.apply(sqlparser, arguments); };
  exports.main = function commonjsMain(args) {
      if (!args[1]) {
          console.log('Usage: '+args[0]+' FILE');
          process.exit(1);
      }
      var source = require('fs').readFileSync(require('path').normalize(args[1]), "utf8");
      return exports.parser.parse(source);
  };
  if (typeof module !== 'undefined' && require.main === module) {
    exports.main(process.argv.slice(1));
  }
  }