class_name Parser

var line: int
var opChars: String
var identChars: String
var opPriority: Variant
var opRightAssoc: Variant
var preprocesorValues: Variant = haxe_ds_StringMap.new()
var allowJSON: bool
var allowTypes: bool
var allowMetadata: bool
var resumeErrors: bool
var input: String
var readPos: int
var char: int
var ops: Array[bool]
var idents: Array[bool]
var uid: int = 0
var tokens: haxe_ds_GenericStack
var preprocStack: Array[Variant]

func _init() -> void:
	self.line = 1
	self.opChars = "+*/-=!><&|^%~"
	self.identChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"

	var priorities: Array[Variant] = ([(["%"] as Array[Variant]), (["*", "/"] as Array[Variant]), (["+", "-"] as Array[Variant]), (["<<", ">>", ">>>"] as Array[Variant]), (["|", "&", "^"] as Array[Variant]), (["==", "!=", ">", "<", ">=", "<="] as Array[Variant]), (["..."] as Array[Variant]), (["&&"] as Array[Variant]), (["||"] as Array[Variant]), (["=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "|=", "&=", "^=", "=>"] as Array[Variant]), (["->"] as Array[Variant])] as Array[Variant])

	self.opPriority = haxe_ds_StringMap.new()
	self.opRightAssoc = haxe_ds_StringMap.new()

	var _g: int = 0
	var _g1: int = priorities.size()

	while (_g < _g1):
		var tempNumber
		_g += 1
		tempNumber = _g - 1
		var i: int = tempNumber
		var p: Array[Variant] = (priorities[i] as Array[Variant])
		var _g2: int = 0
		while (_g2 < p.size()):
			var x = p[_g2]
			_g2 += 1
			self.opPriority.__set(x, i)
			if (i == 9):
				self.opRightAssoc.__set(x, true)

	if true:
		var x: String = "!"
		var tempNumber1
		if (x == "++" || x == "--"):
			tempNumber1 = -1
		else:
			tempNumber1 = -2
		self.opPriority.__set(x, tempNumber1)
	if true:
		var x: String = "++"
		var tempNumber2
		if (x == "++" || x == "--"):
			tempNumber2 = -1
		else:
			tempNumber2 = -2
		self.opPriority.__set(x, tempNumber2)
	if true:
		var x: String = "--"
		var tempNumber3
		if (x == "++" || x == "--"):
			tempNumber3 = -1
		else:
			tempNumber3 = -2
		self.opPriority.__set(x, tempNumber3)
	if true:
		var x: String = "~"
		var tempNumber4
		if (x == "++" || x == "--"):
			tempNumber4 = -1
		else:
			tempNumber4 = -2
		self.opPriority.__set(x, tempNumber4)

func error(err: Variant, pmin: int, pmax: int) -> void:
	if (!self.resumeErrors):
		assert(false, str(err))

func invalidChar(c: int) -> void:
	if (!self.resumeErrors):
		assert(false, str({ "_index": 0, "c": c }))

func initParser(origin) -> void:
	self.preprocStack = ([] as Array[Variant])
	self.tokens = haxe_ds_GenericStack.new()
	self.char = -1
	self.ops = []
	self.idents = []
	self.uid = 0

	if true:
		var _g: int = 0
		var _g1: int = self.opChars.length()
		while (_g < _g1):
			var tempNumber
			if true:
				_g += 1
				tempNumber = _g - 1
			var i: int = tempNumber
			var tempIndex
			if true:
				var _this: String = self.opChars
				if (i >= 0 && i < _this.length()):
					tempIndex = _this.unicode_at(i)
				else:
					tempIndex = null
			self.ops[tempIndex] = true
	if true:
		var _g: int = 0
		var _g1: int = self.identChars.length()
		while (_g < _g1):
			var tempNumber1
			if true:
				_g += 1
				tempNumber1 = _g - 1
			var i: int = tempNumber1
			var tempIndex1
			if true:
				var _this: String = self.identChars
				if (i >= 0 && i < _this.length()):
					tempIndex1 = _this.unicode_at(i)
				else:
					tempIndex1 = null
			self.idents[tempIndex1] = true

func parseString(s: String, origin = "hscript") -> Variant:
	self.initParser(origin)
	self.input = s
	self.readPos = 0

	var a: Array[Variant] = []

	while (true):
		var tk = self.token()
		if (tk == { "_index": 0 }):
			break
		var _this: haxe_ds_GenericStack = self.tokens
		_this.head = haxe_ds_GenericCell.new(tk, _this.head)
		self.parseFullExpr(a)

	var tempResult

	if (a.size() == 1):
		tempResult = a[0]
	else:
		tempResult = { "_index": 4, "e": a }

	return tempResult

func unexpected(tk: Variant):
	var err: Variant = { "_index": 1, "s": self.tokenString(tk) }

	if (!self.resumeErrors):
		assert(false, str(err))

	return null

func push(tk: Variant) -> void:
	var _this: haxe_ds_GenericStack = self.tokens

	_this.head = haxe_ds_GenericCell.new(tk, _this.head)

func ensure(tk) -> void:
	var t = self.token()

	if (t != tk):
		self.unexpected(t)

func ensureToken(tk: Variant) -> void:
	var t = self.token()

	if (!Type.enumEq(t, tk)):
		self.unexpected(t)

func maybe(tk: Variant) -> bool:
	var t = self.token()

	if (Type.enumEq(t, tk)):
		return true

	var _this: haxe_ds_GenericStack = self.tokens

	_this.head = haxe_ds_GenericCell.new(t, _this.head)

	return false

func getIdent() -> String:
	var tk = self.token()

	if (tk == null):
		self.unexpected(tk)
		return ""
	else:
		if (tk._index == 2):
			var _g: String = tk.s
			var id: String = _g
			return id
		else:
			self.unexpected(tk)
			return ""

func expr(e: Variant) -> Variant:
	return e

func pmin(e: Variant) -> int:
	return 0

func pmax(e: Variant) -> int:
	return 0

func mk(e: Variant, pmin = null, pmax = null) -> Variant:
	return e

func isBlock(e) -> bool:
	if (e == null):
		return false

	var tempResult

	if true:
		var _g: Variant = e
		match (_g._index):
			2:
				var _g1: String = _g.n
				var _g2 = _g.t
				var _g3 = _g.e
				if true:
					var t = _g2
					var e2 = _g3
					if (e2 != null):
						tempResult = self.isBlock(e2)
					else:
						if (t != null):
							if (t == null):
								tempResult = false
							else:
								if (t._index == 2):
									var _g4: Array[Variant] = t.fields
									tempResult = true
								else:
									tempResult = false
						else:
							tempResult = false
			4:
				var _g2: Array[Variant] = _g.e
				tempResult = true
			6:
				var _g1: String = _g.op
				var _g2: Variant = _g.e1
				var _g3: Variant = _g.e2
				if true:
					var e2: Variant = _g3
					tempResult = self.isBlock(e2)
			7:
				var _g1: String = _g.op
				var _g2: bool = _g.prefix
				var _g3: Variant = _g.e
				if true:
					var prefix: bool = _g2
					var e2: Variant = _g3
					tempResult = !prefix && self.isBlock(e2)
			9:
				var _g1: Variant = _g.cond
				var _g2: Variant = _g.e1
				var _g3 = _g.e2
				if true:
					var e1: Variant = _g2
					var e2 = _g3
					if (e2 != null):
						tempResult = self.isBlock(e2)
					else:
						tempResult = self.isBlock(e1)
			10:
				var _g1: Variant = _g.cond
				var _g2: Variant = _g.e
				if true:
					var e2: Variant = _g2
					tempResult = self.isBlock(e2)
			11:
				var _g1: String = _g.v
				var _g2: Variant = _g.it
				var _g3: Variant = _g.e
				if true:
					var e2: Variant = _g3
					tempResult = self.isBlock(e2)
			14:
				var _g1: Array[Variant] = _g.args
				var _g2: Variant = _g.e
				var _g3 = _g.name
				var _g4 = _g.ret
				if true:
					var e2: Variant = _g2
					tempResult = self.isBlock(e2)
			15:
				var _g2 = _g.e
				if true:
					var e2 = _g2
					tempResult = e2 != null && self.isBlock(e2)
			20:
				var _g1: Variant = _g.e
				var _g2: String = _g.v
				var _g3 = _g.t
				var _g4: Variant = _g.ecatch
				if true:
					var e2: Variant = _g4
					tempResult = self.isBlock(e2)
			21:
				var _g2: Array[Variant] = _g.fl
				tempResult = true
			23:
				var _g1: Variant = _g.e
				var _g2: Array[Variant] = _g.cases
				var _g3 = _g.defaultExpr
				tempResult = true
			24:
				var _g1: Variant = _g.cond
				var _g2: Variant = _g.e
				if true:
					var e2: Variant = _g2
					tempResult = self.isBlock(e2)
			25:
				var _g1: String = _g.name
				var _g2: Array[Variant] = _g.args
				var _g3: Variant = _g.e
				if true:
					var e2: Variant = _g3
					tempResult = self.isBlock(e2)
			_:
				tempResult = false

	return tempResult

func parseFullExpr(exprs: Array[Variant]) -> void:
	var e = self.parseExpr()

	exprs.push_back(e)

	var tk = self.token()

	while true:
		var tempRight
		var _g: Variant = e
		if (_g._index == 2):
			var _g1: String = _g.n
			var _g2 = _g.t
			var _g3 = _g.e
			tempRight = true
		else:
			tempRight = false
		if !(tk == { "_index": 9 } && e != null && tempRight):
			break
		e = self.parseStructure("var")
		exprs.push_back(e)
		tk = self.token()

	if (tk != { "_index": 10 } && tk != { "_index": 0 }):
		if (self.isBlock(e)):
			var _this: haxe_ds_GenericStack = self.tokens
			_this.head = haxe_ds_GenericCell.new(tk, _this.head)
		else:
			self.unexpected(tk)

func parseObject(p1) -> Variant:
	var fl: Array[Variant] = []

	while (true):
		var tk = self.token()
		var id = null
		if (tk == null):
			self.unexpected(tk)
			break
		else:
			match (tk._index):
				1:
					var _g: Variant = tk.c
					var c: Variant = _g
					if (!self.allowJSON):
						self.unexpected(tk)
					if (c._index == 2):
						var _g2: String = c.s
						var s: String = _g2
						id = s
					else:
						self.unexpected(tk)
				2:
					var _g: String = tk.s
					var i: String = _g
					id = i
				7:
					break
				_:
					self.unexpected(tk)
					break
		var t = self.token()
		if (t != { "_index": 14 }):
			self.unexpected(t)
		fl.push_back({
			"name": id,
			"e": self.parseExpr()
		})
		tk = self.token()
		if (tk == null):
			self.unexpected(tk)
		else:
			match (tk._index):
				7:
					break
				9:
					pass
				_:
					self.unexpected(tk)

	return self.parseExprNext({ "_index": 21, "fl": fl })

func parseExpr():
	var tk = self.token()

	if (tk == null):
		return self.unexpected(tk)
	else:
		match (tk._index):
			1:
				var _g: Variant = tk.c
				if true:
					var c: Variant = _g
					return self.parseExprNext({ "_index": 0, "c": c })
			2:
				var _g: String = tk.s
				if true:
					var id: String = _g
					if true:
						var e = self.parseStructure(id)
						if (e == null):
							e = { "_index": 1, "v": id }
						return self.parseExprNext(e)
			3:
				var _g: String = tk.s
				var op: String = _g
				if (op == "-"):
					var start: int = 0
					var e = self.parseExpr()
					if (e == null):
						return self.makeUnop(op, e)
					if true:
						var _g2: Variant = e
						if (_g2._index == 0):
							var _g3: Variant = _g2.c
							match (_g3._index):
								0:
									var _g4: int = _g3.v
									var i: int = _g4
									return { "_index": 0, "c": { "_index": 0, "v": -i } }
								1:
									var _g4: float = _g3.f
									var f: float = _g4
									return { "_index": 0, "c": { "_index": 1, "f": -f } }
								_:
									return self.makeUnop(op, e)
						else:
							return self.makeUnop(op, e)
				var tempLeft
				var this1: Variant = self.opPriority
				tempLeft = this1.__get(op)
				if (tempLeft < 0):
					return self.makeUnop(op, self.parseExpr())
				return self.unexpected(tk)
			4:
				tk = self.token()
				if (tk == { "_index": 5 }):
					if true:
						var tk2: Variant = { "_index": 3, "s": "->" }
						var t = self.token()
						if (!Type.enumEq(t, tk2)):
							self.unexpected(t)
					var eret = self.parseExpr()
					return { "_index": 14, "args": ([] as Array[Variant]), "e": { "_index": 15, "e": eret } }
				if true:
					var _this: haxe_ds_GenericStack = self.tokens
					_this.head = haxe_ds_GenericCell.new(tk, _this.head)
				var e = self.parseExpr()
				tk = self.token()
				if (tk == null):
					pass
				else:
					match (tk._index):
						5:
							return self.parseExprNext({ "_index": 3, "e": e })
						9:
							if true:
								var _g: Variant = e
								if (_g._index == 1):
									var _g2: String = _g.v
									if true:
										var v: String = _g2
										return self.parseLambda(([{
											"name": v
										}] as Array[Variant]), 0)
								else:
									pass
						14:
							var t: Variant = self.parseType()
							tk = self.token()
							if (tk == null):
								pass
							else:
								match (tk._index):
									5:
										return self.parseExprNext({ "_index": 26, "e": e, "t": t })
									9:
										if true:
											var _g: Variant = e
											if (_g._index == 1):
												var _g2: String = _g.v
												if true:
													var v: String = _g2
													return self.parseLambda(([{
														"name": v,
														"t": t
													}] as Array[Variant]), 0)
											else:
												pass
									_:
										pass
						_:
							pass
				return self.unexpected(tk)
			6:
				tk = self.token()
				if (tk == null):
					var _this: haxe_ds_GenericStack = self.tokens
					_this.head = haxe_ds_GenericCell.new(tk, _this.head)
				else:
					match (tk._index):
						1:
							var _g: Variant = tk.c
							if true:
								var c: Variant = _g
								if (self.allowJSON):
									if (c._index == 2):
										var _g2: String = c.s
										if true:
											var tk2 = self.token()
											if true:
												var _this: haxe_ds_GenericStack = self.tokens
												_this.head = haxe_ds_GenericCell.new(tk2, _this.head)
											if true:
												var _this: haxe_ds_GenericStack = self.tokens
												_this.head = haxe_ds_GenericCell.new(tk, _this.head)
											if (tk2 == null):
												pass
											else:
												if (tk2._index == 14):
													return self.parseExprNext(self.parseObject(0))
												else:
													pass
									else:
										var _this: haxe_ds_GenericStack = self.tokens
										_this.head = haxe_ds_GenericCell.new(tk, _this.head)
								else:
									var _this: haxe_ds_GenericStack = self.tokens
									_this.head = haxe_ds_GenericCell.new(tk, _this.head)
						2:
							var _g: String = tk.s
							if true:
								var tk2 = self.token()
								if true:
									var _this: haxe_ds_GenericStack = self.tokens
									_this.head = haxe_ds_GenericCell.new(tk2, _this.head)
								if true:
									var _this: haxe_ds_GenericStack = self.tokens
									_this.head = haxe_ds_GenericCell.new(tk, _this.head)
								if (tk2 == null):
									pass
								else:
									if (tk2._index == 14):
										return self.parseExprNext(self.parseObject(0))
									else:
										pass
						7:
							return self.parseExprNext({ "_index": 21, "fl": ([] as Array[Variant]) })
						_:
							var _this: haxe_ds_GenericStack = self.tokens
							_this.head = haxe_ds_GenericCell.new(tk, _this.head)
				var a: Array[Variant] = []
				while (true):
					self.parseFullExpr(a)
					tk = self.token()
					if (tk == { "_index": 7 } || self.resumeErrors && tk == { "_index": 0 }):
						break
					if true:
						var _this: haxe_ds_GenericStack = self.tokens
						_this.head = haxe_ds_GenericCell.new(tk, _this.head)
				return { "_index": 4, "e": a }
			11:
				var a: Array[Variant] = []
				tk = self.token()
				while (tk != { "_index": 12 } && (!self.resumeErrors || tk != { "_index": 0 })):
					if true:
						var _this: haxe_ds_GenericStack = self.tokens
						_this.head = haxe_ds_GenericCell.new(tk, _this.head)
					a.push_back(self.parseExpr())
					tk = self.token()
					if (tk == { "_index": 9 }):
						tk = self.token()
				if (a.size() == 1 && a[0] != null):
					if true:
						var _g: Variant = a[0]
						match (_g._index):
							10:
								var _g1: Variant = _g.cond
								var _g2: Variant = _g.e
								if true:
									var tempRight
									if true:
										self.uid += 1
										tempRight = self.uid - 1
									var tmp: String = "__a_" + str(tempRight)
									var tempExpr
									if true:
										var e: Variant = { "_index": 4, "e": ([{ "_index": 2, "n": tmp, "t": null, "e": { "_index": 17, "e": ([] as Array[Variant]) } }, self.mapCompr(tmp, a[0]), { "_index": 1, "v": tmp }] as Array[Variant]) }
										tempExpr = e
									var e: Variant = tempExpr
									return self.parseExprNext(e)
							11:
								var _g1: String = _g.v
								var _g2: Variant = _g.it
								var _g3: Variant = _g.e
								if true:
									var tempRight1
									if true:
										self.uid += 1
										tempRight1 = self.uid - 1
									var tmp: String = "__a_" + str(tempRight1)
									var tempExpr1
									if true:
										var e: Variant = { "_index": 4, "e": ([{ "_index": 2, "n": tmp, "t": null, "e": { "_index": 17, "e": ([] as Array[Variant]) } }, self.mapCompr(tmp, a[0]), { "_index": 1, "v": tmp }] as Array[Variant]) }
										tempExpr1 = e
									var e: Variant = tempExpr1
									return self.parseExprNext(e)
							24:
								var _g1: Variant = _g.cond
								var _g2: Variant = _g.e
								if true:
									var tempRight2
									if true:
										self.uid += 1
										tempRight2 = self.uid - 1
									var tmp: String = "__a_" + str(tempRight2)
									var tempExpr2
									if true:
										var e: Variant = { "_index": 4, "e": ([{ "_index": 2, "n": tmp, "t": null, "e": { "_index": 17, "e": ([] as Array[Variant]) } }, self.mapCompr(tmp, a[0]), { "_index": 1, "v": tmp }] as Array[Variant]) }
										tempExpr2 = e
									var e: Variant = tempExpr2
									return self.parseExprNext(e)
							_:
								pass
				return self.parseExprNext({ "_index": 17, "e": a })
			15:
				var _g: String = tk.s
				if true:
					var id: String = _g
					if (self.allowMetadata):
						var args = self.parseMetaArgs()
						var tempResult
						if true:
							var e: Variant = { "_index": 25, "name": id, "args": args, "e": self.parseExpr() }
							tempResult = e
						return tempResult
					else:
						return self.unexpected(tk)
			_:
				return self.unexpected(tk)

func parseLambda(args: Array[Variant], pmin) -> Variant:
	while (true):
		var id: String = self.getIdent()
		var tempMaybeCType
		if (self.maybe({ "_index": 14 })):
			tempMaybeCType = self.parseType()
		else:
			tempMaybeCType = null
		var t = tempMaybeCType
		args.push_back({
			"name": id,
			"t": t
		})
		var tk = self.token()
		if (tk == null):
			self.unexpected(tk)
			break
		else:
			match (tk._index):
				5:
					break
				9:
					pass
				_:
					self.unexpected(tk)
					break

	if true:
		var tk: Variant = { "_index": 3, "s": "->" }
		var t = self.token()
		if (!Type.enumEq(t, tk)):
			self.unexpected(t)

	var eret = self.parseExpr()

	return { "_index": 14, "args": args, "e": { "_index": 15, "e": eret } }

func parseMetaArgs():
	var tk = self.token()

	if (tk != { "_index": 4 }):
		if true:
			var _this: haxe_ds_GenericStack = self.tokens
			_this.head = haxe_ds_GenericCell.new(tk, _this.head)
		return null

	var args: Array[Variant] = ([] as Array[Variant])

	tk = self.token()

	if (tk != { "_index": 5 }):
		if true:
			var _this: haxe_ds_GenericStack = self.tokens
			_this.head = haxe_ds_GenericCell.new(tk, _this.head)
		while (true):
			args.push_back(self.parseExpr())
			if true:
				var _g = self.token()
				if (_g == null):
					var tk2 = _g
					self.unexpected(tk2)
				else:
					match (_g._index):
						5:
							break
						9:
							pass
						_:
							var tk2 = _g
							self.unexpected(tk2)

	return args

func mapCompr(tmp: String, e: Variant):
	if (e == null):
		return null

	var tempExpr

	match (e._index):
		3:
			var _g: Variant = e.e
			if true:
				var e2: Variant = _g
				tempExpr = { "_index": 3, "e": self.mapCompr(tmp, e2) }
		4:
			var _g: Array[Variant] = e.e
			if (_g.size() == 1):
				var _g2: Variant = _g[0]
				if true:
					var e2: Variant = _g2
					tempExpr = { "_index": 4, "e": ([self.mapCompr(tmp, e2)] as Array[Variant]) }
			else:
				tempExpr = { "_index": 8, "e": { "_index": 5, "e": { "_index": 1, "v": tmp }, "f": "push" }, "params": ([e] as Array[Variant]) }
		9:
			var _g: Variant = e.cond
			var _g1: Variant = e.e1
			var _g2 = e.e2
			if true:
				var cond: Variant = _g
				var e1: Variant = _g1
				var e2 = _g2
				if (e2 == null):
					tempExpr = { "_index": 9, "cond": cond, "e1": self.mapCompr(tmp, e1), "e2": null }
				else:
					tempExpr = { "_index": 8, "e": { "_index": 5, "e": { "_index": 1, "v": tmp }, "f": "push" }, "params": ([e] as Array[Variant]) }
		10:
			var _g: Variant = e.cond
			var _g1: Variant = e.e
			if true:
				var cond: Variant = _g
				var e2: Variant = _g1
				tempExpr = { "_index": 10, "cond": cond, "e": self.mapCompr(tmp, e2) }
		11:
			var _g: String = e.v
			var _g1: Variant = e.it
			var _g2: Variant = e.e
			if true:
				var v: String = _g
				var it: Variant = _g1
				var e2: Variant = _g2
				tempExpr = { "_index": 11, "v": v, "it": it, "e": self.mapCompr(tmp, e2) }
		24:
			var _g: Variant = e.cond
			var _g1: Variant = e.e
			if true:
				var cond: Variant = _g
				var e2: Variant = _g1
				tempExpr = { "_index": 24, "cond": cond, "e": self.mapCompr(tmp, e2) }
		_:
			tempExpr = { "_index": 8, "e": { "_index": 5, "e": { "_index": 1, "v": tmp }, "f": "push" }, "params": ([e] as Array[Variant]) }

	return tempExpr

func makeUnop(op: String, e):
	if (e == null && self.resumeErrors):
		return null

	var tempResult

	if true:
		var _g: Variant = e
		match (_g._index):
			6:
				var _g1: String = _g.op
				var _g2: Variant = _g.e1
				var _g3: Variant = _g.e2
				if true:
					var bop: String = _g1
					var e1: Variant = _g2
					var e2: Variant = _g3
					if true:
						var e3: Variant = { "_index": 6, "op": bop, "e1": self.makeUnop(op, e1), "e2": e2 }
						tempResult = e3
			22:
				var _g1: Variant = _g.cond
				var _g2: Variant = _g.e1
				var _g3: Variant = _g.e2
				if true:
					var e1: Variant = _g1
					var e2: Variant = _g2
					var e3: Variant = _g3
					if true:
						var e4: Variant = { "_index": 22, "cond": self.makeUnop(op, e1), "e1": e2, "e2": e3 }
						tempResult = e4
			_:
				tempResult = { "_index": 7, "op": op, "prefix": true, "e": e }

	return tempResult

func makeBinop(op: String, e1: Variant, e) -> Variant:
	if (e == null && self.resumeErrors):
		return { "_index": 6, "op": op, "e1": e1, "e2": e }

	var tempResult

	if true:
		var _g: Variant = e
		match (_g._index):
			6:
				var _g1: String = _g.op
				var _g2: Variant = _g.e1
				var _g3: Variant = _g.e2
				if true:
					var op2: String = _g1
					var e2: Variant = _g2
					var e3: Variant = _g3
					var tempLeft
					if true:
						var this1: Variant = self.opPriority
						tempLeft = this1.__get(op)
					var tempRight
					if true:
						var this1: Variant = self.opPriority
						tempRight = this1.__get(op2)
					var tempBool
					if true:
						var this1: Variant = self.opRightAssoc
						tempBool = this1.exists(op)
					if (tempLeft <= tempRight && !tempBool):
						var e4: Variant = { "_index": 6, "op": op2, "e1": self.makeBinop(op, e1, e2), "e2": e3 }
						tempResult = e4
					else:
						tempResult = { "_index": 6, "op": op, "e1": e1, "e2": e }
			22:
				var _g1: Variant = _g.cond
				var _g2: Variant = _g.e1
				var _g3: Variant = _g.e2
				if true:
					var e2: Variant = _g1
					var e3: Variant = _g2
					var e4: Variant = _g3
					var tempBool1
					if true:
						var this1: Variant = self.opRightAssoc
						tempBool1 = this1.exists(op)
					if (tempBool1):
						tempResult = { "_index": 6, "op": op, "e1": e1, "e2": e }
					else:
						var e5: Variant = { "_index": 22, "cond": self.makeBinop(op, e1, e2), "e1": e3, "e2": e4 }
						tempResult = e5
			_:
				tempResult = { "_index": 6, "op": op, "e1": e1, "e2": e }

	return tempResult

func parseStructure(id: String):
	var tempResult

	match (id):
		"break":
			tempResult = { "_index": 12 }
		"continue":
			tempResult = { "_index": 13 }
		"do":
			var e = self.parseExpr()
			var tk = self.token()
			if (tk == null):
				self.unexpected(tk)
			else:
				if (tk._index == 2):
					var _g: String = tk.s
					if (_g == "while"):
						pass
					else:
						self.unexpected(tk)
				else:
					self.unexpected(tk)
			var econd = self.parseExpr()
			tempResult = { "_index": 24, "cond": econd, "e": e }
		"else":
			tempResult = self.unexpected({ "_index": 2, "s": id })
		"for":
			if true:
				var t = self.token()
				if (t != { "_index": 4 }):
					self.unexpected(t)
			var vname: String = self.getIdent()
			if true:
				var tk: Variant = { "_index": 2, "s": "in" }
				var t = self.token()
				if (!Type.enumEq(t, tk)):
					self.unexpected(t)
			var eiter = self.parseExpr()
			if true:
				var t = self.token()
				if (t != { "_index": 5 }):
					self.unexpected(t)
			var e = self.parseExpr()
			tempResult = { "_index": 11, "v": vname, "it": eiter, "e": e }
		"function":
			var tk = self.token()
			var name = null
			if (tk == null):
				var _this: haxe_ds_GenericStack = self.tokens
				_this.head = haxe_ds_GenericCell.new(tk, _this.head)
			else:
				if (tk._index == 2):
					var _g: String = tk.s
					var id2: String = _g
					name = id2
				else:
					var _this: haxe_ds_GenericStack = self.tokens
					_this.head = haxe_ds_GenericCell.new(tk, _this.head)
			var inf: Variant = self.parseFunctionDecl()
			tempResult = { "_index": 14, "args": inf.get("args"), "e": inf.get("body"), "name": name, "ret": inf.get("ret") }
		"if":
			if true:
				var t = self.token()
				if (t != { "_index": 4 }):
					self.unexpected(t)
			var cond = self.parseExpr()
			if true:
				var t = self.token()
				if (t != { "_index": 5 }):
					self.unexpected(t)
			var e1 = self.parseExpr()
			var e2 = null
			var semic: bool = false
			var tk = self.token()
			if (tk == { "_index": 10 }):
				semic = true
				tk = self.token()
			if (Type.enumEq(tk, { "_index": 2, "s": "else" })):
				e2 = self.parseExpr()
			else:
				if true:
					var _this: haxe_ds_GenericStack = self.tokens
					_this.head = haxe_ds_GenericCell.new(tk, _this.head)
				if (semic):
					var _this: haxe_ds_GenericStack = self.tokens
					_this.head = haxe_ds_GenericCell.new({ "_index": 10 }, _this.head)
			tempResult = { "_index": 9, "cond": cond, "e1": e1, "e2": e2 }
		"inline":
			if (!self.maybe({ "_index": 2, "s": "function" })):
				self.unexpected({ "_index": 2, "s": "inline" })
			return self.parseStructure("function")
		"new":
			var a: Array[String] = []
			a.push_back(self.getIdent())
			while (true):
				var tk = self.token()
				if (tk == null):
					self.unexpected(tk)
					break
				else:
					match (tk._index):
						4:
							break
						8:
							a.push_back(self.getIdent())
						_:
							self.unexpected(tk)
							break
			var args: Array[Variant] = self.parseExprList({ "_index": 5 })
			if true:
				var tempString
				if true:
					var result: String = ""
					var len: int = a.size()
					if true:
						var _g: int = 0
						var _g1: int = len
						while (_g < _g1):
							var tempNumber
							if true:
								_g += 1
								tempNumber = _g - 1
							var i: int = tempNumber
							var tempString1
							if (i == len - 1):
								tempString1 = ""
							else:
								tempString1 = "."
							result += str(a[i]) + (tempString1)
					tempString = result
				var e: Variant = { "_index": 18, "cl": tempString, "params": args }
				tempResult = e
		"return":
			var tk = self.token()
			if true:
				var _this: haxe_ds_GenericStack = self.tokens
				_this.head = haxe_ds_GenericCell.new(tk, _this.head)
			var tempMaybeExpr
			if (tk == { "_index": 10 }):
				tempMaybeExpr = null
			else:
				tempMaybeExpr = self.parseExpr()
			var e = tempMaybeExpr
			tempResult = { "_index": 15, "e": e }
		"switch":
			var e = self.parseExpr()
			var def = null
			var cases: Array[Variant] = ([] as Array[Variant])
			if true:
				var t = self.token()
				if (t != { "_index": 6 }):
					self.unexpected(t)
			while (true):
				var tk = self.token()
				if (tk == null):
					self.unexpected(tk)
					break
				else:
					match (tk._index):
						2:
							var _g: String = tk.s
							match (_g):
								"case":
									var c: Variant = {
										"values": ([] as Array[Variant]),
										"expr": null
									}
									cases.push_back(c)
									while (true):
										var e2 = self.parseExpr()
										c.get("values").push_back(e2)
										tk = self.token()
										if (tk == null):
											self.unexpected(tk)
											break
										else:
											match (tk._index):
												9:
													pass
												14:
													break
												_:
													self.unexpected(tk)
													break
									var exprs: Array[Variant] = ([] as Array[Variant])
									while (true):
										tk = self.token()
										if true:
											var _this: haxe_ds_GenericStack = self.tokens
											_this.head = haxe_ds_GenericCell.new(tk, _this.head)
										if (tk == null):
											self.parseFullExpr(exprs)
										else:
											match (tk._index):
												0:
													if (self.resumeErrors):
														break
													else:
														self.parseFullExpr(exprs)
												2:
													var _g2: String = tk.s
													match (_g2):
														"case", "default":
															break
														_:
															self.parseFullExpr(exprs)
												7:
													break
												_:
													self.parseFullExpr(exprs)
									var tempRight
									if (exprs.size() == 1):
										tempRight = exprs[0]
									else:
										if (exprs.size() == 0):
											tempRight = { "_index": 4, "e": ([] as Array[Variant]) }
										else:
											tempRight = { "_index": 4, "e": exprs }
									c.set("expr", tempRight)
								"default":
									if (def != null):
										self.unexpected(tk)
									if true:
										var t = self.token()
										if (t != { "_index": 14 }):
											self.unexpected(t)
									var exprs: Array[Variant] = ([] as Array[Variant])
									while (true):
										tk = self.token()
										if true:
											var _this: haxe_ds_GenericStack = self.tokens
											_this.head = haxe_ds_GenericCell.new(tk, _this.head)
										if (tk == null):
											self.parseFullExpr(exprs)
										else:
											match (tk._index):
												0:
													if (self.resumeErrors):
														break
													else:
														self.parseFullExpr(exprs)
												2:
													var _g2: String = tk.s
													match (_g2):
														"case", "default":
															break
														_:
															self.parseFullExpr(exprs)
												7:
													break
												_:
													self.parseFullExpr(exprs)
									var tempRight1
									if (exprs.size() == 1):
										tempRight1 = exprs[0]
									else:
										if (exprs.size() == 0):
											tempRight1 = { "_index": 4, "e": ([] as Array[Variant]) }
										else:
											tempRight1 = { "_index": 4, "e": exprs }
									def = tempRight1
								_:
									self.unexpected(tk)
									break
						7:
							break
						_:
							self.unexpected(tk)
							break
			tempResult = { "_index": 23, "e": e, "cases": cases, "defaultExpr": def }
		"throw":
			var e = self.parseExpr()
			tempResult = { "_index": 19, "e": e }
		"try":
			var e = self.parseExpr()
			if true:
				var tk: Variant = { "_index": 2, "s": "catch" }
				var t = self.token()
				if (!Type.enumEq(t, tk)):
					self.unexpected(t)
			if true:
				var t = self.token()
				if (t != { "_index": 4 }):
					self.unexpected(t)
			var vname: String = self.getIdent()
			if true:
				var t = self.token()
				if (t != { "_index": 14 }):
					self.unexpected(t)
			var t = null
			if (self.allowTypes):
				t = self.parseType()
			else:
				var tk: Variant = { "_index": 2, "s": "Dynamic" }
				var t2 = self.token()
				if (!Type.enumEq(t2, tk)):
					self.unexpected(t2)
			var t1 = self.token()
			if (t1 != { "_index": 5 }):
				self.unexpected(t1)
			var ec = self.parseExpr()
			tempResult = { "_index": 20, "e": e, "v": vname, "t": t, "ecatch": ec }
		"var":
			var ident: String = self.getIdent()
			var tk = self.token()
			var t = null
			if (tk == { "_index": 14 } && self.allowTypes):
				t = self.parseType()
				tk = self.token()
			var e = null
			if (Type.enumEq(tk, { "_index": 3, "s": "=" })):
				e = self.parseExpr()
			else:
				var _this: haxe_ds_GenericStack = self.tokens
				_this.head = haxe_ds_GenericCell.new(tk, _this.head)
			tempResult = { "_index": 2, "n": ident, "t": t, "e": e }
		"while":
			var econd = self.parseExpr()
			var e = self.parseExpr()
			tempResult = { "_index": 10, "cond": econd, "e": e }
		_:
			tempResult = null

	return tempResult

func parseExprNext(e1: Variant) -> Variant:
	var tk = self.token()

	if (tk == null):
		if true:
			var _this: haxe_ds_GenericStack = self.tokens
			_this.head = haxe_ds_GenericCell.new(tk, _this.head)
		return e1
	else:
		match (tk._index):
			3:
				var _g: String = tk.s
				var op: String = _g
				if (op == "->"):
					match (e1._index):
						1:
							var _g2: String = e1.v
							if true:
								var i: String = _g2
								if true:
									var eret = self.parseExpr()
									return { "_index": 14, "args": ([{
										"name": i
									}] as Array[Variant]), "e": { "_index": 15, "e": eret } }
						3:
							var _g2: Variant = e1.e
							if true:
								var _hx_tmp
								_hx_tmp = _g2
								if ((_hx_tmp)._index == 1):
									var _g3: String = _hx_tmp.v
									if true:
										var i: String = _g3
										if true:
											var eret = self.parseExpr()
											return { "_index": 14, "args": ([{
												"name": i
											}] as Array[Variant]), "e": { "_index": 15, "e": eret } }
								else:
									pass
						26:
							var _g2: Variant = e1.e
							var _g1: Variant = e1.t
							if true:
								var _hx_tmp
								_hx_tmp = _g2
								if ((_hx_tmp)._index == 1):
									var _g3: String = _hx_tmp.v
									if true:
										var i: String = _g3
										var t: Variant = _g1
										if true:
											var eret = self.parseExpr()
											return { "_index": 14, "args": ([{
												"name": i,
												"t": t
											}] as Array[Variant]), "e": { "_index": 15, "e": eret } }
								else:
									pass
						_:
							pass
					self.unexpected(tk)
				var tempLeft
				var this1: Variant = self.opPriority
				tempLeft = this1.__get(op)
				if (tempLeft == -1):
					var tempBool
					if (e1._index == 3):
						var _g2: Variant = e1.e
						tempBool = true
					else:
						tempBool = false
					if (self.isBlock(e1) || (tempBool)):
						if true:
							var _this: haxe_ds_GenericStack = self.tokens
							_this.head = haxe_ds_GenericCell.new(tk, _this.head)
						return e1
					return self.parseExprNext({ "_index": 7, "op": op, "prefix": false, "e": e1 })
				return self.makeBinop(op, e1, self.parseExpr())
			4:
				var tempExpr
				var e: Variant = { "_index": 8, "e": e1, "params": self.parseExprList({ "_index": 5 }) }
				tempExpr = e
				return self.parseExprNext(tempExpr)
			8:
				var field: String = self.getIdent()
				return self.parseExprNext({ "_index": 5, "e": e1, "f": field })
			11:
				var e2 = self.parseExpr()
				if true:
					var t = self.token()
					if (t != { "_index": 12 }):
						self.unexpected(t)
				return self.parseExprNext({ "_index": 16, "e": e1, "index": e2 })
			13:
				var e2 = self.parseExpr()
				if true:
					var t = self.token()
					if (t != { "_index": 14 }):
						self.unexpected(t)
				var e3 = self.parseExpr()
				return { "_index": 22, "cond": e1, "e1": e2, "e2": e3 }
			_:
				if true:
					var _this: haxe_ds_GenericStack = self.tokens
					_this.head = haxe_ds_GenericCell.new(tk, _this.head)
				return e1

func parseFunctionArgs() -> Array[Variant]:
	var args: Array[Variant] = []
	var tk = self.token()

	if (tk != { "_index": 5 }):
		var done: bool = false
		while (!done):
			var name = null
			var opt: bool = false
			if (tk == null):
				pass
			else:
				if (tk._index == 13):
					opt = true
					tk = self.token()
				else:
					pass
			if (tk == null):
				self.unexpected(tk)
				break
			else:
				if (tk._index == 2):
					var _g: String = tk.s
					var id: String = _g
					name = id
				else:
					self.unexpected(tk)
					break
			var arg: Variant = {
				"name": name
			}
			args.push_back(arg)
			if (opt):
				arg.set("opt", true)
			if (self.allowTypes):
				if (self.maybe({ "_index": 14 })):
					arg.set("t", self.parseType())
				if (self.maybe({ "_index": 3, "s": "=" })):
					arg.set("value", self.parseExpr())
			tk = self.token()
			if (tk == null):
				self.unexpected(tk)
			else:
				match (tk._index):
					5:
						done = true
					9:
						tk = self.token()
					_:
						self.unexpected(tk)

	return args

func parseFunctionDecl() -> Variant:
	var t = self.token()

	if (t != { "_index": 4 }):
		self.unexpected(t)

	var args: Array[Variant] = self.parseFunctionArgs()
	var ret = null

	if (self.allowTypes):
		var tk = self.token()
		if (tk != { "_index": 14 }):
			var _this: haxe_ds_GenericStack = self.tokens
			_this.head = haxe_ds_GenericCell.new(tk, _this.head)
		else:
			ret = self.parseType()

	return {
		"args": args,
		"ret": ret,
		"body": self.parseExpr()
	}

func parsePath() -> Array[String]:
	var path: Array[String] = ([self.getIdent()] as Array[String])

	while (true):
		var t = self.token()
		if (t != { "_index": 8 }):
			var _this: haxe_ds_GenericStack = self.tokens
			_this.head = haxe_ds_GenericCell.new(t, _this.head)
			break
		path.push_back(self.getIdent())

	return path

func parseType() -> Variant:
	var _gthis: Parser = self
	var t = self.token()

	if (t == null):
		return self.unexpected(t)
	else:
		match (t._index):
			2:
				var _g: String = t.s
				if true:
					var v: String = _g
					if true:
						if true:
							var _this: haxe_ds_GenericStack = self.tokens
							_this.head = haxe_ds_GenericCell.new(t, _this.head)
						var path: Array[String] = self.parsePath()
						var params = null
						t = self.token()
						if (t == null):
							var _this: haxe_ds_GenericStack = self.tokens
							_this.head = haxe_ds_GenericCell.new(t, _this.head)
						else:
							if (t._index == 3):
								var _g2: String = t.s
								if true:
									var op: String = _g2
									if (op == "<"):
										params = ([] as Array[Variant])
										while (true):
											params.push_back(self.parseType())
											t = self.token()
											if (t == null):
												pass
											else:
												match (t._index):
													3:
														var _g3: String = t.s
														if true:
															var op2: String = _g3
															if true:
																if (op2 == ">"):
																	break
																var tempMaybeNumber
																if (0 < op2.length()):
																	tempMaybeNumber = op2.unicode_at(0)
																else:
																	tempMaybeNumber = null
																if ((tempMaybeNumber) == 62):
																	if true:
																		var _this: haxe_ds_GenericStack = self.tokens
																		var item: Variant = { "_index": 3, "s": op2.substr(1) }
																		_this.head = haxe_ds_GenericCell.new(item, _this.head)
																	break
													9:
														continue
													_:
														pass
											self.unexpected(t)
											break
									else:
										var _this: haxe_ds_GenericStack = self.tokens
										_this.head = haxe_ds_GenericCell.new(t, _this.head)
							else:
								var _this: haxe_ds_GenericStack = self.tokens
								_this.head = haxe_ds_GenericCell.new(t, _this.head)
						return self.parseTypeNext({ "_index": 0, "path": path, "params": params })
			4:
				var a = self.token()
				var b = self.token()
				if true:
					var _this: haxe_ds_GenericStack = self.tokens
					_this.head = haxe_ds_GenericCell.new(b, _this.head)
				if true:
					var _this: haxe_ds_GenericStack = self.tokens
					_this.head = haxe_ds_GenericCell.new(a, _this.head)
				var withReturn = func(args: Array[Variant]) -> Variant:
					if true:
						var _g = _gthis.token()
						if (_g == null):
							var t2 = _g
							_gthis.unexpected(t2)
						else:
							if (_g._index == 3):
								var _g1: String = _g.s
								if (_g1 == "->"):
									pass
								else:
									var t2 = _g
									_gthis.unexpected(t2)
							else:
								var t2 = _g
								_gthis.unexpected(t2)
					return { "_index": 1, "args": args, "ret": _gthis.parseType() }
				if (a == null):
					var t2: Variant = self.parseType()
					var tempResult
					if true:
						var _g = self.token()
						if (_g == null):
							var t3 = _g
							tempResult = self.unexpected(t3)
						else:
							match (_g._index):
								5:
									tempResult = self.parseTypeNext({ "_index": 3, "t": t2 })
								9:
									var args: Array[Variant] = ([t2] as Array[Variant])
									while (true):
										args.push_back(self.parseType())
										if (!self.maybe({ "_index": 9 })):
											break
									if true:
										var t3 = self.token()
										if (t3 != { "_index": 5 }):
											self.unexpected(t3)
									tempResult = withReturn.call(args)
								_:
									var t3 = _g
									tempResult = self.unexpected(t3)
					return tempResult
				else:
					match (a._index):
						2:
							var _g: String = a.s
							if (b == null):
								var t2: Variant = self.parseType()
								var tempResult1
								if true:
									var _g2 = self.token()
									if (_g2 == null):
										var t3 = _g2
										tempResult1 = self.unexpected(t3)
									else:
										match (_g2._index):
											5:
												tempResult1 = self.parseTypeNext({ "_index": 3, "t": t2 })
											9:
												var args: Array[Variant] = ([t2] as Array[Variant])
												while (true):
													args.push_back(self.parseType())
													if (!self.maybe({ "_index": 9 })):
														break
												if true:
													var t3 = self.token()
													if (t3 != { "_index": 5 }):
														self.unexpected(t3)
												tempResult1 = withReturn.call(args)
											_:
												var t3 = _g2
												tempResult1 = self.unexpected(t3)
								return tempResult1
							else:
								if (b._index == 14):
									var tempArray
									if true:
										var _g2: Array[Variant] = ([] as Array[Variant])
										if true:
											var _g1: int = 0
											var _g3: Array[Variant] = self.parseFunctionArgs()
											while (_g1 < _g3.size()):
												var arg: Variant = _g3[_g1]
												_g1 += 1
												if true:
													var _g4 = arg.get("value")
													if (_g4 == null):
														pass
													else:
														var v = _g4
														if (!self.resumeErrors):
															assert(false, str({ "_index": 9, "msg": "Default values not allowed in function types" }))
												var tempCType
												if (arg.get("opt")):
													tempCType = { "_index": 4, "t": arg.get("t") }
												else:
													tempCType = arg.get("t")
												_g2.push_back({ "_index": 5, "n": arg.get("name"), "t": tempCType })
										tempArray = _g2
									var args: Array[Variant] = tempArray
									return withReturn.call(args)
								else:
									var t2: Variant = self.parseType()
									var tempResult2
									if true:
										var _g2 = self.token()
										if (_g2 == null):
											var t3 = _g2
											tempResult2 = self.unexpected(t3)
										else:
											match (_g2._index):
												5:
													tempResult2 = self.parseTypeNext({ "_index": 3, "t": t2 })
												9:
													var args: Array[Variant] = ([t2] as Array[Variant])
													while (true):
														args.push_back(self.parseType())
														if (!self.maybe({ "_index": 9 })):
															break
													if true:
														var t3 = self.token()
														if (t3 != { "_index": 5 }):
															self.unexpected(t3)
													tempResult2 = withReturn.call(args)
												_:
													var t3 = _g2
													tempResult2 = self.unexpected(t3)
									return tempResult2
						5:
							var tempArray1
							if true:
								var _g: Array[Variant] = ([] as Array[Variant])
								if true:
									var _g1: int = 0
									var _g2: Array[Variant] = self.parseFunctionArgs()
									while (_g1 < _g2.size()):
										var arg: Variant = _g2[_g1]
										_g1 += 1
										if true:
											var _g3 = arg.get("value")
											if (_g3 == null):
												pass
											else:
												var v = _g3
												if (!self.resumeErrors):
													assert(false, str({ "_index": 9, "msg": "Default values not allowed in function types" }))
										var tempCType1
										if (arg.get("opt")):
											tempCType1 = { "_index": 4, "t": arg.get("t") }
										else:
											tempCType1 = arg.get("t")
										_g.push_back({ "_index": 5, "n": arg.get("name"), "t": tempCType1 })
								tempArray1 = _g
							var args: Array[Variant] = tempArray1
							return withReturn.call(args)
						_:
							var t2: Variant = self.parseType()
							var tempResult3
							if true:
								var _g = self.token()
								if (_g == null):
									var t3 = _g
									tempResult3 = self.unexpected(t3)
								else:
									match (_g._index):
										5:
											tempResult3 = self.parseTypeNext({ "_index": 3, "t": t2 })
										9:
											var args: Array[Variant] = ([t2] as Array[Variant])
											while (true):
												args.push_back(self.parseType())
												if (!self.maybe({ "_index": 9 })):
													break
											if true:
												var t3 = self.token()
												if (t3 != { "_index": 5 }):
													self.unexpected(t3)
											tempResult3 = withReturn.call(args)
										_:
											var t3 = _g
											tempResult3 = self.unexpected(t3)
							return tempResult3
			6:
				var fields: Array[Variant] = ([] as Array[Variant])
				var meta = null
				while (true):
					t = self.token()
					if (t == null):
						self.unexpected(t)
						break
					else:
						match (t._index):
							2:
								var _g: String = t.s
								if (_g == "var"):
									var name: String = self.getIdent()
									if true:
										var t2 = self.token()
										if (t2 != { "_index": 14 }):
											self.unexpected(t2)
									fields.push_back({
										"name": name,
										"t": self.parseType(),
										"meta": meta
									})
									meta = null
									if true:
										var t2 = self.token()
										if (t2 != { "_index": 10 }):
											self.unexpected(t2)
								else:
									var name: String = _g
									var t1 = self.token()
									if (t1 != { "_index": 14 }):
										self.unexpected(t1)
									fields.push_back({
										"name": name,
										"t": self.parseType(),
										"meta": meta
									})
									t = self.token()
									if (t == null):
										self.unexpected(t)
									else:
										match (t._index):
											7:
												break
											9:
												pass
											_:
												self.unexpected(t)
							7:
								break
							15:
								var _g: String = t.s
								if true:
									var name: String = _g
									if true:
										if (meta == null):
											meta = ([] as Array[Variant])
										meta.push_back({
											"name": name,
											"params": self.parseMetaArgs()
										})
							_:
								self.unexpected(t)
								break
				return self.parseTypeNext({ "_index": 2, "fields": fields })
			_:
				return self.unexpected(t)

	return null

func parseTypeNext(t: Variant) -> Variant:
	var tk = self.token()

	if (tk == null):
		if true:
			var _this: haxe_ds_GenericStack = self.tokens
			_this.head = haxe_ds_GenericCell.new(tk, _this.head)
		return t
	else:
		if (tk._index == 3):
			var _g: String = tk.s
			var op: String = _g
			if (op != "->"):
				if true:
					var _this: haxe_ds_GenericStack = self.tokens
					_this.head = haxe_ds_GenericCell.new(tk, _this.head)
				return t
		else:
			if true:
				var _this: haxe_ds_GenericStack = self.tokens
				_this.head = haxe_ds_GenericCell.new(tk, _this.head)
			return t

	var t2: Variant = self.parseType()

	if (t2._index == 1):
		var _g: Array[Variant] = t2.args
		var _g1: Variant = t2.ret
		var args: Array[Variant] = _g
		args.push_front(t)
		return t2
	else:
		return { "_index": 1, "args": ([t] as Array[Variant]), "ret": t2 }

func parseExprList(etk) -> Array[Variant]:
	var args: Array[Variant] = []
	var tk = self.token()

	if (tk == etk):
		return args

	var _this: haxe_ds_GenericStack = self.tokens

	_this.head = haxe_ds_GenericCell.new(tk, _this.head)

	while (true):
		args.push_back(self.parseExpr())
		tk = self.token()
		if (tk == null):
			if (tk == etk):
				break
			self.unexpected(tk)
			break
		else:
			if (tk._index == 9):
				pass
			else:
				if (tk == etk):
					break
				self.unexpected(tk)
				break

	return args

func parseModule(content: String, origin = "hscript") -> Array[Variant]:
	self.initParser(origin)
	self.input = content
	self.readPos = 0
	self.allowTypes = true
	self.allowMetadata = true

	var decls: Array[Variant] = ([] as Array[Variant])

	while (true):
		var tk = self.token()
		if (tk == { "_index": 0 }):
			break
		var _this: haxe_ds_GenericStack = self.tokens
		_this.head = haxe_ds_GenericCell.new(tk, _this.head)
		decls.push_back(self.parseModuleDecl())

	return decls

func parseMetadata() -> Array[Variant]:
	var meta: Array[Variant] = ([] as Array[Variant])

	while (true):
		var tk = self.token()
		if (tk == null):
			if true:
				var _this: haxe_ds_GenericStack = self.tokens
				_this.head = haxe_ds_GenericCell.new(tk, _this.head)
			break
		else:
			if (tk._index == 15):
				var _g: String = tk.s
				var name: String = _g
				meta.push_back({
					"name": name,
					"params": self.parseMetaArgs()
				})
			else:
				if true:
					var _this: haxe_ds_GenericStack = self.tokens
					_this.head = haxe_ds_GenericCell.new(tk, _this.head)
				break

	return meta

func parseParams() -> Variant:
	if (self.maybe({ "_index": 3, "s": "<" })):
		if (!self.resumeErrors):
			assert(false, str({ "_index": 7, "op": "Unsupported class type parameters" }))

	return {
	}

func parseModuleDecl() -> Variant:
	var meta: Array[Variant] = self.parseMetadata()
	var ident: String = self.getIdent()
	var isPrivate: bool = false
	var isExtern: bool = false

	while (true):
		match (ident):
			"extern":
				isExtern = true
			"private":
				isPrivate = true
			_:
				break
		ident = self.getIdent()

	match (ident):
		"class":
			var name: String = self.getIdent()
			var params: Variant = self.parseParams()
			var extend = null
			var implement: Array[Variant] = ([] as Array[Variant])
			while (true):
				var t = self.token()
				if (t == null):
					if true:
						var _this: haxe_ds_GenericStack = self.tokens
						_this.head = haxe_ds_GenericCell.new(t, _this.head)
					break
				else:
					if (t._index == 2):
						var _g: String = t.s
						match (_g):
							"extends":
								extend = self.parseType()
							"implements":
								implement.push_back(self.parseType())
							_:
								if true:
									var _this: haxe_ds_GenericStack = self.tokens
									_this.head = haxe_ds_GenericCell.new(t, _this.head)
								break
					else:
						if true:
							var _this: haxe_ds_GenericStack = self.tokens
							_this.head = haxe_ds_GenericCell.new(t, _this.head)
						break
			var fields: Array[Variant] = ([] as Array[Variant])
			if true:
				var t = self.token()
				if (t != { "_index": 6 }):
					self.unexpected(t)
			while (!self.maybe({ "_index": 7 })):
				fields.push_back(self.parseField())
			return { "_index": 2, "c": {
				"name": name,
				"meta": meta,
				"params": params,
				"extend": extend,
				"implement": implement,
				"fields": fields,
				"isPrivate": isPrivate,
				"isExtern": isExtern
			} }
		"import":
			var path: Array[String] = ([self.getIdent()] as Array[String])
			var star: bool = false
			while (true):
				var t = self.token()
				if (t != { "_index": 8 }):
					if true:
						var _this: haxe_ds_GenericStack = self.tokens
						_this.head = haxe_ds_GenericCell.new(t, _this.head)
					break
				t = self.token()
				if (t == null):
					self.unexpected(t)
				else:
					match (t._index):
						2:
							var _g: String = t.s
							var id: String = _g
							path.push_back(id)
						3:
							var _g: String = t.s
							if (_g == "*"):
								star = true
							else:
								self.unexpected(t)
						_:
							self.unexpected(t)
			if true:
				var t = self.token()
				if (t != { "_index": 10 }):
					self.unexpected(t)
			return { "_index": 1, "path": path, "everything": star }
		"package":
			var path: Array[String] = self.parsePath()
			if true:
				var t = self.token()
				if (t != { "_index": 10 }):
					self.unexpected(t)
			return { "_index": 0, "path": path }
		"typedef":
			var name: String = self.getIdent()
			var params: Variant = self.parseParams()
			if true:
				var tk: Variant = { "_index": 3, "s": "=" }
				var t = self.token()
				if (!Type.enumEq(t, tk)):
					self.unexpected(t)
			var t: Variant = self.parseType()
			return { "_index": 3, "c": {
				"name": name,
				"meta": meta,
				"params": params,
				"isPrivate": isPrivate,
				"t": t
			} }
		_:
			self.unexpected({ "_index": 2, "s": ident })

	return null

func parseField() -> Variant:
	var meta: Array[Variant] = self.parseMetadata()
	var access: Array[FieldAccess.FieldAccess] = ([] as Array[FieldAccess.FieldAccess])

	while (true):
		var id: String = self.getIdent()
		match (id):
			"function":
				var name: String = self.getIdent()
				var inf: Variant = self.parseFunctionDecl()
				return {
					"name": name,
					"meta": meta,
					"access": access,
					"kind": { "_index": 0, "f": {
					"args": inf.get("args"),
					"expr": inf.get("body"),
					"ret": inf.get("ret")
				} }
				}
			"inline":
				access.push_back(FieldAccess.FieldAccess.AInline)
			"macro":
				access.push_back(FieldAccess.FieldAccess.AMacro)
			"override":
				access.push_back(FieldAccess.FieldAccess.AOverride)
			"private":
				access.push_back(FieldAccess.FieldAccess.APrivate)
			"public":
				access.push_back(FieldAccess.FieldAccess.APublic)
			"static":
				access.push_back(FieldAccess.FieldAccess.AStatic)
			"var":
				var name: String = self.getIdent()
				var __get = null
				var __set = null
				if (self.maybe({ "_index": 4 })):
					__get = self.getIdent()
					if true:
						var t = self.token()
						if (t != { "_index": 9 }):
							self.unexpected(t)
					__set = self.getIdent()
					if true:
						var t = self.token()
						if (t != { "_index": 5 }):
							self.unexpected(t)
				var tempMaybeCType
				if (self.maybe({ "_index": 14 })):
					tempMaybeCType = self.parseType()
				else:
					tempMaybeCType = null
				var type = tempMaybeCType
				var tempMaybeExpr
				if (self.maybe({ "_index": 3, "s": "=" })):
					tempMaybeExpr = self.parseExpr()
				else:
					tempMaybeExpr = null
				var expr = tempMaybeExpr
				if (expr != null):
					if (self.isBlock(expr)):
						self.maybe({ "_index": 10 })
					else:
						var t = self.token()
						if (t != { "_index": 10 }):
							self.unexpected(t)
				else:
					var tempBool
					if (type == null):
						tempBool = false
					else:
						if (type._index == 2):
							var _g: Array[Variant] = type.fields
							tempBool = true
						else:
							tempBool = false
					if (type != null && (tempBool)):
						self.maybe({ "_index": 10 })
					else:
						var t = self.token()
						if (t != { "_index": 10 }):
							self.unexpected(t)
				return {
					"name": name,
					"meta": meta,
					"access": access,
					"kind": { "_index": 1, "v": {
					"get": __get,
					"set": __set,
					"type": type,
					"expr": expr
				} }
				}
			_:
				self.unexpected({ "_index": 2, "s": id })
				break

	return null

func readChar() -> int:
	var s: String = self.input

	self.readPos += 1

	var tempNumber: int = self.readPos - 1
	var index: int = tempNumber
	var tempResult: int = s.unicode_at.call(index)

	return tempResult

func readString(until: int) -> String:
	var c: int = 0
	var b_b: String = ""
	var esc: bool = false
	var old: int = self.line
	var s: String = self.input

	while (true):
		var tempNumber
		if true:
			var s2: String = self.input
			var tempNumber1
			if true:
				self.readPos += 1
				tempNumber1 = self.readPos - 1
			var index: int = tempNumber1
			tempNumber = s2.unicode_at.call(index)
		var c2: int = tempNumber
		if (esc):
			esc = false
			match (c2):
				47:
					if (self.allowJSON):
						b_b += char(c2)
					else:
						self.invalidChar(c2)
				34, 39, 92:
					b_b += char(c2)
				110:
					b_b += "\n"
				114:
					b_b += "\r"
				116:
					b_b += "\t"
				117:
					if (!self.allowJSON):
						self.invalidChar(c2)
					var k: int = 0
					var _g: int = 0
					while (_g < 4):
						var tempNumber2
						_g += 1
						tempNumber2 = _g - 1
						var i: int = tempNumber2
						k <<= 4
						var tempNumber3
						if true:
							var s2: String = self.input
							var tempNumber4
							if true:
								self.readPos += 1
								tempNumber4 = self.readPos - 1
							var index: int = tempNumber4
							tempNumber3 = s2.unicode_at.call(index)
						var char2: int = tempNumber3
						match (char2):
							48, 49, 50, 51, 52, 53, 54, 55, 56, 57:
								k += char2 - 48
							65, 66, 67, 68, 69, 70:
								k += char2 - 55
							97, 98, 99, 100, 101, 102:
								k += char2 - 87
							_:
								self.invalidChar(char2)
					b_b += char(k)
				_:
					self.invalidChar(c2)
		else:
			if (c2 == 92):
				esc = true
			else:
				if (c2 == until):
					break
				else:
					if (c2 == 10):
						self.line += 1
					b_b += char(c2)

	return b_b

func token():
	if (self.tokens.head != null):
		var tempResult
		if true:
			var _this: haxe_ds_GenericStack = self.tokens
			var k: haxe_ds_GenericCell = _this.head
			if (k == null):
				tempResult = null
			else:
				_this.head = k.next
				tempResult = k.elt
		return tempResult

	var char2

	if (self.char < 0):
		var tempRight
		if true:
			var s: String = self.input
			var tempNumber
			if true:
				self.readPos += 1
				tempNumber = self.readPos - 1
			var index: int = tempNumber
			tempRight = s.unicode_at.call(index)
		char2 = tempRight
	else:
		char2 = self.char
		self.char = -1

	while (true):
		match (char2):
			0:
				return { "_index": 0 }
			10:
				self.line += 1
			9, 13, 32:
				pass
			34, 39:
				return { "_index": 1, "c": { "_index": 2, "s": self.readString(char2) } }
			35:
				var tempRight1
				if true:
					var s: String = self.input
					var tempNumber1
					if true:
						self.readPos += 1
						tempNumber1 = self.readPos - 1
					var index: int = tempNumber1
					tempRight1 = s.unicode_at.call(index)
				char2 = tempRight1
				if (self.idents[char2]):
					var id: String = char(char2)
					while (true):
						var tempRight2
						if true:
							var s: String = self.input
							var tempNumber2
							if true:
								self.readPos += 1
								tempNumber2 = self.readPos - 1
							var index: int = tempNumber2
							tempRight2 = s.unicode_at.call(index)
						char2 = tempRight2
						if (!self.idents[char2]):
							self.char = char2
							return self.preprocess(id)
						id += char(char2)
				self.invalidChar(char2)
			40:
				return { "_index": 4 }
			41:
				return { "_index": 5 }
			44:
				return { "_index": 9 }
			46:
				var tempRight3
				if true:
					var s: String = self.input
					var tempNumber3
					if true:
						self.readPos += 1
						tempNumber3 = self.readPos - 1
					var index: int = tempNumber3
					tempRight3 = s.unicode_at.call(index)
				char2 = tempRight3
				match (char2):
					46:
						var tempRight4
						if true:
							var s: String = self.input
							var tempNumber4
							if true:
								self.readPos += 1
								tempNumber4 = self.readPos - 1
							var index: int = tempNumber4
							tempRight4 = s.unicode_at.call(index)
						char2 = tempRight4
						if (char2 != 46):
							self.invalidChar(char2)
						return { "_index": 3, "s": "..." }
					48, 49, 50, 51, 52, 53, 54, 55, 56, 57:
						var n: int = char2 - 48
						var _exp: int = 1
						while (true):
							var tempRight5
							if true:
								var s: String = self.input
								var tempNumber5
								if true:
									self.readPos += 1
									tempNumber5 = self.readPos - 1
								var index: int = tempNumber5
								tempRight5 = s.unicode_at.call(index)
							char2 = tempRight5
							_exp *= 10
							match (char2):
								48, 49, 50, 51, 52, 53, 54, 55, 56, 57:
									n = n * 10 + (char2 - 48)
								_:
									self.char = char2
									return { "_index": 1, "c": { "_index": 1, "f": n / _exp } }
					_:
						self.char = char2
						return { "_index": 8 }
			48, 49, 50, 51, 52, 53, 54, 55, 56, 57:
				var n: float = (char2 - 48) * 1.0
				var _exp: float = 0.
				while (true):
					var tempRight6
					if true:
						var s: String = self.input
						var tempNumber6
						if true:
							self.readPos += 1
							tempNumber6 = self.readPos - 1
						var index: int = tempNumber6
						tempRight6 = s.unicode_at.call(index)
					char2 = tempRight6
					_exp *= 10
					match (char2):
						46:
							if (_exp > 0):
								var tempLeft
								if true:
									var s: String = self.input
									var tempNumber7
									if true:
										self.readPos += 1
										tempNumber7 = self.readPos - 1
									var index: int = tempNumber7
									tempLeft = s.unicode_at.call(index)
								if (_exp == 10 && tempLeft == 46):
									if true:
										var tk: Variant = { "_index": 3, "s": "..." }
										if true:
											var _this: haxe_ds_GenericStack = self.tokens
											_this.head = haxe_ds_GenericCell.new(tk, _this.head)
									var i: int = int(n)
									var tempConst
									if (i == n):
										tempConst = { "_index": 0, "v": i }
									else:
										tempConst = { "_index": 1, "f": n }
									return { "_index": 1, "c": tempConst }
								self.invalidChar(char2)
							_exp = 1.
						48, 49, 50, 51, 52, 53, 54, 55, 56, 57:
							n = n * 10 + (char2 - 48)
						69, 101:
							var tk = self.token()
							var _pow = null
							if (tk == null):
								var _this: haxe_ds_GenericStack = self.tokens
								_this.head = haxe_ds_GenericCell.new(tk, _this.head)
							else:
								match (tk._index):
									1:
										var _g: Variant = tk.c
										if (_g._index == 0):
											var _g2: int = _g.v
											if true:
												var e: int = _g2
												_pow = e
										else:
											var _this: haxe_ds_GenericStack = self.tokens
											_this.head = haxe_ds_GenericCell.new(tk, _this.head)
									3:
										var _g: String = tk.s
										if (_g == "-"):
											tk = self.token()
											if (tk == null):
												var _this: haxe_ds_GenericStack = self.tokens
												_this.head = haxe_ds_GenericCell.new(tk, _this.head)
											else:
												if (tk._index == 1):
													var _g2: Variant = tk.c
													if (_g2._index == 0):
														var _g3: int = _g2.v
														if true:
															var e: int = _g3
															_pow = -e
													else:
														var _this: haxe_ds_GenericStack = self.tokens
														_this.head = haxe_ds_GenericCell.new(tk, _this.head)
												else:
													var _this: haxe_ds_GenericStack = self.tokens
													_this.head = haxe_ds_GenericCell.new(tk, _this.head)
										else:
											var _this: haxe_ds_GenericStack = self.tokens
											_this.head = haxe_ds_GenericCell.new(tk, _this.head)
									_:
										var _this: haxe_ds_GenericStack = self.tokens
										_this.head = haxe_ds_GenericCell.new(tk, _this.head)
							if (_pow == null):
								self.invalidChar(char2)
							return { "_index": 1, "c": { "_index": 1, "f": pow(10, _pow) / _exp * n * 10 } }
						120:
							if (n > 0 || _exp > 0):
								self.invalidChar(char2)
							var n2: int = 0
							while (true):
								var tempRight7
								if true:
									var s: String = self.input
									var tempNumber8
									if true:
										self.readPos += 1
										tempNumber8 = self.readPos - 1
									var index: int = tempNumber8
									tempRight7 = s.unicode_at.call(index)
								char2 = tempRight7
								match (char2):
									48, 49, 50, 51, 52, 53, 54, 55, 56, 57:
										n2 = (n2 << 4) + char2 - 48
									65, 66, 67, 68, 69, 70:
										n2 = (n2 << 4) + (char2 - 55)
									97, 98, 99, 100, 101, 102:
										n2 = (n2 << 4) + (char2 - 87)
									_:
										self.char = char2
										return { "_index": 1, "c": { "_index": 0, "v": n2 } }
						_:
							self.char = char2
							var i: int = int(n)
							var tempConst1
							if (_exp > 0):
								tempConst1 = { "_index": 1, "f": n * 10 / _exp }
							else:
								if (i == n):
									tempConst1 = { "_index": 0, "v": i }
								else:
									tempConst1 = { "_index": 1, "f": n }
							return { "_index": 1, "c": tempConst1 }
			58:
				return { "_index": 14 }
			59:
				return { "_index": 10 }
			61:
				var tempRight8
				if true:
					var s: String = self.input
					var tempNumber9
					if true:
						self.readPos += 1
						tempNumber9 = self.readPos - 1
					var index: int = tempNumber9
					tempRight8 = s.unicode_at.call(index)
				char2 = tempRight8
				if (char2 == 61):
					return { "_index": 3, "s": "==" }
				else:
					if (char2 == 62):
						return { "_index": 3, "s": "=>" }
				self.char = char2
				return { "_index": 3, "s": "=" }
			63:
				return { "_index": 13 }
			64:
				var tempRight9
				if true:
					var s: String = self.input
					var tempNumber10
					if true:
						self.readPos += 1
						tempNumber10 = self.readPos - 1
					var index: int = tempNumber10
					tempRight9 = s.unicode_at.call(index)
				char2 = tempRight9
				if (self.idents[char2] || char2 == 58):
					var id: String = char(char2)
					while (true):
						var tempRight10
						if true:
							var s: String = self.input
							var tempNumber11
							if true:
								self.readPos += 1
								tempNumber11 = self.readPos - 1
							var index: int = tempNumber11
							tempRight10 = s.unicode_at.call(index)
						char2 = tempRight10
						if (!self.idents[char2]):
							self.char = char2
							return { "_index": 15, "s": id }
						id += char(char2)
				self.invalidChar(char2)
			91:
				return { "_index": 11 }
			93:
				return { "_index": 12 }
			123:
				return { "_index": 6 }
			125:
				return { "_index": 7 }
			_:
				if (self.ops[char2]):
					var op: String = char(char2)
					while (true):
						var tempRight11
						if true:
							var s: String = self.input
							var tempNumber12
							if true:
								self.readPos += 1
								tempNumber12 = self.readPos - 1
							var index: int = tempNumber12
							tempRight11 = s.unicode_at.call(index)
						char2 = tempRight11
						if (!self.ops[char2]):
							self.char = char2
							return { "_index": 3, "s": op }
						var pop: String = op
						op += char(char2)
						var tempBool
						if true:
							var this1: Variant = self.opPriority
							tempBool = this1.exists(op)
						var tempRight12
						if true:
							var this1: Variant = self.opPriority
							tempRight12 = this1.exists(pop)
						if (!tempBool && tempRight12):
							if (op == "//" || op == "/*"):
								return self.tokenComment(op, char2)
							self.char = char2
							return { "_index": 3, "s": pop }
				if (self.idents[char2]):
					var id: String = char(char2)
					while (true):
						var tempRight13
						if true:
							var s: String = self.input
							var tempNumber13
							if true:
								self.readPos += 1
								tempNumber13 = self.readPos - 1
							var index: int = tempNumber13
							tempRight13 = s.unicode_at.call(index)
						char2 = tempRight13
						if (!self.idents[char2]):
							self.char = char2
							return { "_index": 2, "s": id }
						id += char(char2)
				self.invalidChar(char2)
		var tempRight14
		if true:
			var s: String = self.input
			var tempNumber14
			if true:
				self.readPos += 1
				tempNumber14 = self.readPos - 1
			var index: int = tempNumber14
			tempRight14 = s.unicode_at.call(index)
		char2 = tempRight14

	return null

func preprocValue(id: String):
	var this1: Variant = self.preprocesorValues
	var tempResult = this1.__get(id)

	return tempResult

func parsePreproCond() -> Variant:
	var tk = self.token()
	var tempResult

	if (tk == null):
		tempResult = self.unexpected(tk)
	else:
		match (tk._index):
			2:
				var _g: String = tk.s
				var id: String = _g
				tempResult = { "_index": 1, "v": id }
			3:
				var _g: String = tk.s
				if (_g == "!"):
					var e: Variant = { "_index": 7, "op": "!", "prefix": true, "e": self.parsePreproCond() }
					tempResult = e
				else:
					tempResult = self.unexpected(tk)
			4:
				var _this: haxe_ds_GenericStack = self.tokens
				_this.head = haxe_ds_GenericCell.new({ "_index": 4 }, _this.head)
				tempResult = self.parseExpr()
			_:
				tempResult = self.unexpected(tk)

	return tempResult

func evalPreproCond(e: Variant) -> bool:
	match (e._index):
		1:
			var _g: String = e.v
			var id: String = _g
			return self.preprocValue(id) != null
		3:
			var _g: Variant = e.e
			if true:
				var e2: Variant = _g
				return self.evalPreproCond(e2)
		6:
			var _g: String = e.op
			var _g1: Variant = e.e1
			var _g2: Variant = e.e2
			match (_g):
				"&&":
					var e1: Variant = _g1
					var e2: Variant = _g2
					return self.evalPreproCond(e1) && self.evalPreproCond(e2)
				"||":
					var e1: Variant = _g1
					var e2: Variant = _g2
					return self.evalPreproCond(e1) || self.evalPreproCond(e2)
				_:
					if true:
						var err: Variant = { "_index": 4, "msg": "Can't eval " + Type.enumConstructor(e) }
						var pmin: int = self.readPos
						var pmax: int = self.readPos
						if (!self.resumeErrors):
							assert(false, str(err))
					return false
		7:
			var _g: String = e.op
			var _g1: bool = e.prefix
			var _g2: Variant = e.e
			if (_g == "!"):
				var e2: Variant = _g2
				return !self.evalPreproCond(e2)
			else:
				if true:
					var err: Variant = { "_index": 4, "msg": "Can't eval " + Type.enumConstructor(e) }
					var pmin: int = self.readPos
					var pmax: int = self.readPos
					if (!self.resumeErrors):
						assert(false, str(err))
				return false
		_:
			if true:
				var err: Variant = { "_index": 4, "msg": "Can't eval " + Type.enumConstructor(e) }
				var pmin: int = self.readPos
				var pmax: int = self.readPos
				if (!self.resumeErrors):
					assert(false, str(err))
			return false

	return false

func preprocess(id: String) -> Variant:
	match (id):
		"else", "elseif":
			if (self.preprocStack.size() > 0):
				if (self.preprocStack[self.preprocStack.size() - 1].get("r")):
					self.preprocStack[self.preprocStack.size() - 1].set("r", false)
					self.skipTokens()
					return self.token()
				else:
					if (id == "else"):
						self.preprocStack.pop_back()
						self.preprocStack.push_back({
							"r": true
						})
						return self.token()
					else:
						self.preprocStack.pop_back()
						return self.preprocess("if")
			else:
				return { "_index": 16, "s": id }
		"end":
			if (self.preprocStack.size() > 0):
				self.preprocStack.pop_back()
				return self.token()
			else:
				return { "_index": 16, "s": id }
		"if":
			var e: Variant = self.parsePreproCond()
			if (self.evalPreproCond(e)):
				self.preprocStack.push_back({
					"r": true
				})
				return self.token()
			self.preprocStack.push_back({
				"r": false
			})
			self.skipTokens()
			return self.token()
		_:
			return { "_index": 16, "s": id }

func skipTokens() -> void:
	var spos: int = self.preprocStack.size() - 1
	var obj: Variant = self.preprocStack[spos]
	var pos: int = self.readPos

	while (true):
		var tk = self.token()
		if (tk == { "_index": 0 }):
			if (!self.resumeErrors):
				assert(false, str({ "_index": 4, "msg": "Unclosed" }))
		if (self.preprocStack[spos] != obj):
			var _this: haxe_ds_GenericStack = self.tokens
			_this.head = haxe_ds_GenericCell.new(tk, _this.head)
			break

func tokenComment(op: String, char2: int):
	var tempMaybeNumber

	if (1 < op.length()):
		tempMaybeNumber = op.unicode_at(1)
	else:
		tempMaybeNumber = null

	var c = tempMaybeNumber
	var s: String = self.input

	if (c == 47):
		while (char2 != 13 && char2 != 10):
			var tempRight
			if true:
				var s2: String = self.input
				var tempNumber
				if true:
					self.readPos += 1
					tempNumber = self.readPos - 1
				var index: int = tempNumber
				tempRight = s2.unicode_at.call(index)
			char2 = tempRight
		self.char = char2
		return self.token()
	if (c == 42):
		var old: int = self.line
		if (op == "/**/"):
			self.char = char2
			return self.token()
		while (true):
			while (char2 != 42):
				if (char2 == 10):
					self.line += 1
				var tempRight1
				if true:
					var s2: String = self.input
					var tempNumber1
					if true:
						self.readPos += 1
						tempNumber1 = self.readPos - 1
					var index: int = tempNumber1
					tempRight1 = s2.unicode_at.call(index)
				char2 = tempRight1
			var tempRight2
			if true:
				var s2: String = self.input
				var tempNumber2
				if true:
					self.readPos += 1
					tempNumber2 = self.readPos - 1
				var index: int = tempNumber2
				tempRight2 = s2.unicode_at.call(index)
			char2 = tempRight2
			if (char2 == 47):
				break
		return self.token()

	self.char = char2

	return { "_index": 3, "s": op }

func constString(c: Variant) -> String:
	var tempResult

	match (c._index):
		0:
			var _g: int = c.v
			var v: int = _g
			tempResult = str(v)
		1:
			var _g: float = c.f
			var f: float = _g
			tempResult = str(f)
		2:
			var _g: String = c.s
			var s: String = _g
			tempResult = s

	return tempResult

func tokenString(t: Variant) -> String:
	var tempResult

	match (t._index):
		0:
			tempResult = "<eof>"
		1:
			var _g: Variant = t.c
			var c: Variant = _g
			tempResult = self.constString(c)
		2:
			var _g: String = t.s
			if true:
				var s: String = _g
				tempResult = s
		3:
			var _g: String = t.s
			if true:
				var s: String = _g
				tempResult = s
		4:
			tempResult = "("
		5:
			tempResult = ")"
		6:
			tempResult = "{"
		7:
			tempResult = "}"
		8:
			tempResult = "."
		9:
			tempResult = ","
		10:
			tempResult = ";"
		11:
			tempResult = "["
		12:
			tempResult = "]"
		13:
			tempResult = "?"
		14:
			tempResult = ":"
		15:
			var _g: String = t.s
			if true:
				var id: String = _g
				tempResult = "@" + id
		16:
			var _g: String = t.s
			if true:
				var id: String = _g
				tempResult = "#" + id

	return tempResult