// This is a bundle the JDK class code is the main part that
// I (quinton-ashley) made. That section starts on line 40.
(function () {
	function r(e, n, t) {
		function o(i, f) {
			if (!n[i]) {
				if (!e[i]) {
					var c = 'function' == typeof require && require;
					if (!f && c) return c(i, !0);
					if (u) return u(i, !0);
					var a = new Error("Cannot find module '" + i + "'");
					throw ((a.code = 'MODULE_NOT_FOUND'), a);
				}
				var p = (n[i] = {
					exports: {}
				});
				e[i][0].call(
					p.exports,
					function (r) {
						var n = e[i][1][r];
						return o(n || r);
					},
					p,
					p.exports,
					r,
					e,
					n,
					t
				);
			}
			return n[i].exports;
		}
		for (var u = 'function' == typeof require && require, i = 0; i < t.length; i++) o(t[i]);
		return o;
	}
	return r;
})()(
	{
		1: [
			function (require, module, exports) {
				const log = console.log;

				/* Java to JavaScript transpiler */
				const java_to_javascript = require('java-to-javascript');

				/* JDK implementation in modern JavaScript */
				class JDK {
					constructor() {}

					async init(root) {
						this.root = root || './jdk';
						this.java = {};
						let pkgs = ['com', 'io', 'lang', 'org', 'security', 'time', 'util'];
						for (let pkg of pkgs) {
							this.java[pkg] = {};
						}
						this.imports = {};

						/**
						 * The 'java.lang' package is imported automatically because this package
						 * provides classes that are fundamental to the Java programming language.
						 * Since classes like String already exist in JS, so I just extended them,
						 * no need to import.
						 */
						try {
							let names = [
								'Character',
								'Double',
								'Exception',
								'Float',
								'Integer',
								'Long',
								'Short',
								'String',
								'StringBuilder',
								'System',
								'Thread'
							];
							let lang = [];
							for (let name of names) {
								lang.push('java.lang.' + name);
							}
							await this.import(lang);
						} catch (ror) {
							console.error(ror);
							return;
						}

						// make java.lang classes global
						for (let name in this.java.lang) {
							if (name == 'String') continue;
							window[name] = this.java.lang[name];
						}

						System.in.reset();
						System.out.reset();

						// stub main
						this.main = () => {
							console.error('No main method found in loaded classes!');
						};
					}

					run(jvmArgs) {
						this.main(jvmArgs);
					}

					getClass(classPath) {
						let _class = this;

						for (let part of classPath) {
							_class = _class[part];
							if (!_class) return;
						}
						return _class;
					}

					async import(classNames) {
						if (!classNames) return;
						if (typeof classNames == 'string') {
							classNames = [classNames];
						}

						let classes = [];
						for (let className of classNames) {
							// log('importing ' + className);
							let imp = this.imports[className];
							if (!imp) {
								imp = this.imports[className] = {};
								imp.load = null;
								imp.classPath = className.split('.');

								let src = this.root;
								for (let part of imp.classPath) {
									src += '/' + part;
								}
								src += '.js';

								const loadJS = () => {
									return new Promise((resolve, reject) => {
										const script = document.createElement('script');
										document.body.appendChild(script);
										script.async = true;
										script.onload = resolve;
										script.onerror = reject;
										script.src = src;
									});
								};
								await loadJS();
							}
							if (!imp.ready) await imp.load();
							classes.push(this.getClass(imp.classPath));
						}
						if (classNames.length == 1) classes = classes[0];
						return classes;
					}

					async transpile(file) {
						if (!this.java) {
							console.error(
								'java2js error: JDK not initialized! You must call `await jdk.init()` before using `jdk.load()`'
							);
						}
						// bodge fix to avoid getting the index of a commented out class
						// (only works with normal comments)
						let classLine = file.indexOf('\npublic class');
						if (classLine < 0) {
							classLine = file.indexOf('public class');
						} else {
							classLine += 1;
						}
						let imports = file.slice(0, classLine);
						imports = imports.match(/(?<=^import )[^;]*/gm) || [];

						let className = file.slice(classLine + 13, file.indexOf('{', classLine + 13));

						// workaround hack for converting triple quotes to a normal string
						file = file.replace(/"""([^"]*)"""/gm, (match, p1) => {
							return '(' + p1.replace(/(  |\t){0,3}(.*)(\r*\n|$)/gm, '"$2\\n"+').slice(0, -1) + ')';
						});

						let arrToString = '';

						// hacky support for Array literals
						file = file.replace(/new\s*\w*\s*\[\s*\]\s*\{([^}]*)}/gm, 'Array.of($1)');

						// 2D arrays
						file = file.replace(/new\s*\w*(\s*\[\s*\])*\s*\{([^}]*)\}/gm, (match, p1, p2) => {
							return 'Array.of(' + p2.replace(/\{([^\}]*)\}/gm, 'Array.of($1)') + ')';
						});

						// Array with defined length
						file = file.replace(/new\s*\w*\s*\[\s*(\d)+\s*\]\s*/gm, 'new Array($1)');

						// workaround hack for converting lambda expressions to Runnables
						let lambdaRegex = /\(\)\s*\->\s*\{(([^\{\}]*\{[^\}]*\})*[^\}]*)\}/g;

						// can't even do this... bruh
						// file = file.replace(lambdaRegex, (match, in0) => {
						// 	// log(in0);
						// 	if (lambdaRegex.test(in0)) {
						// 		in0 = in0.replace(lambdaRegex, (match, in1) => {
						// 			return 'new Runnable() {\\n@Override\\npublic void run() {' + in1 + '}\\n}';
						// 		});
						// 	}
						// 	return 'new Runnable() {\\n@Override\\npublic void run() {' + in0 + '}\\n}';
						// });

						// TODO fix this by adding real support for lambda
						file = file.replace(lambdaRegex, (match, in0) => {
							// log(in0);
							if (lambdaRegex.test(in0)) {
								in0 = in0.replace(lambdaRegex, (match, in1) => {
									in1.replaceAll('\n', '\\n');
									return 'new Runnable("' + in1 + '")';
								});
							}
							in0 = in0.replaceAll('\n', '\\n');
							return 'new Runnable("' + in0 + '")';
						});

						let packageName = (file.match(/package\s+([^;]+)/gm) || [])[1] || 'default';

						let trans;

						let workerPath = this.root.split('/').slice(0, -1).join('/') + '/transpile_worker.js';
						try {
							let worker = new Worker(workerPath);
							worker.postMessage(file);
							await new Promise((resolve, reject) => {
								worker.onmessage = (e) => {
									trans = e.data;
									resolve();
								};
							});
						} catch (ror) {
							console.warn(
								'Due to a likely CORS error, java2js was unable to transpile with multithreaded worker: ' + workerPath
							);
							trans = java_to_javascript(file);
						}
						// log(trans);

						// TODO fix this by adding real support for lambda
						trans = trans.replace(/new\s*Runnable\('([^]*)'\)/gm, (match, p1) => {
							return '() => {' + p1.replaceAll('\\n', '\n') + '}';
						});

						trans.replace(/catch \(\w*/gm, 'catch (');

						trans = trans.replace(/(\([^\(\)]*\) =>)/gm, 'async $1');

						let prefix = `(jdk.imports['${packageName}.${className}'] = {}).load = async () => {\n\n`;

						// handle Java class imports
						for (let i = 0; i < imports.length; i++) {
							let imp = imports[i];
							// skip static imports for now
							if (imp.includes('static')) continue;
							let impPath = imp.split('.');
							let impName = impPath[impPath.length - 1];
							if (impName == '*') {
								prefix += `await jdk.import('${imp}');\n`;
							} else {
								prefix += `let ${impName} = await jdk.import('${imp}');\n`;
							}
						}
						prefix += '\n';

						let suffix = '\n';
						suffix += `window.${className} = ${className};\n`;
						suffix += `console.log("loaded ${className}.java");\n`;
						suffix += '};';

						trans = prefix + trans + suffix;

						const script = document.createElement('script');
						script.innerHTML = trans;
						document.body.appendChild(script);

						try {
							await jdk.imports[`${packageName}.${className}`].load();
						} catch (ror) {
							console.error('Failed to load class!\n' + trans);
							System.err.println('ERROR: Failed to load class');
							return;
						}

						return trans;
					}
				}
				window.jdk = new JDK();
			},
			{
				'java-to-javascript': 2
			}
		],
		2: [
			function (require, module, exports) {
				/* beautify ignore:start */
				(function (global, factory) {
					typeof exports === 'object' && typeof module !== 'undefined'
						? (module.exports = factory())
						: typeof define === 'function' && define.amd
						? define(factory)
						: ((global = global || self), (global.javaToJavascript = factory()));
				})(this, function () {
					function unwrapExports(x) {
						return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x.default : x;
					}

					function createCommonjsModule(fn, module) {
						return (module = { exports: {} }), fn(module, module.exports), module.exports;
					}

					var beautify = createCommonjsModule(function (module, exports) {
						/* AUTO-GENERATED. DO NOT MODIFY. */
						/*

	  The MIT License (MIT)

	  Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.

	  Permission is hereby granted, free of charge, to any person
	  obtaining a copy of this software and associated documentation files
	  (the "Software"), to deal in the Software without restriction,
	  including without limitation the rights to use, copy, modify, merge,
	  publish, distribute, sublicense, and/or sell copies of the Software,
	  and to permit persons to whom the Software is furnished to do so,
	  subject to the following conditions:

	  The above copyright notice and this permission notice shall be
	  included in all copies or substantial portions of the Software.

	  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	  SOFTWARE.

	 JS Beautifier
	---------------


	  Written by Einar Lielmanis, <einar@beautifier.io>
	      https://beautifier.io/

	  Originally converted to javascript by Vital, <vital76@gmail.com>
	  "End braces on own line" added by Chris J. Shull, <chrisjshull@gmail.com>
	  Parsing improvements for brace-less statements by Liam Newman <bitwiseman@beautifier.io>


	  Usage:
	    js_beautify(js_source_text);
	    js_beautify(js_source_text, options);

	  The options are:
	    indent_size (default 4)          - indentation size,
	    indent_char (default space)      - character to indent with,
	    preserve_newlines (default true) - whether existing line breaks should be preserved,
	    max_preserve_newlines (default unlimited) - maximum number of line breaks to be preserved in one chunk,

	    jslint_happy (default false) - if true, then jslint-stricter mode is enforced.

	            jslint_happy        !jslint_happy
	            ---------------------------------
	            function ()         function()

	            switch () {         switch() {
	            case 1:               case 1:
	              break;                break;
	            }                   }

	    space_after_anon_function (default false) - should the space before an anonymous function's parens be added, "function()" vs "function ()",
	          NOTE: This option is overriden by jslint_happy (i.e. if jslint_happy is true, space_after_anon_function is true by design)

	    brace_style (default "collapse") - "collapse" | "expand" | "end-expand" | "none" | any of the former + ",preserve-inline"
	            put braces on the same line as control statements (default), or put braces on own line (Allman / ANSI style), or just put end braces on own line, or attempt to keep them where they are.
	            preserve-inline will try to preserve inline blocks of curly braces

	    space_before_conditional (default true) - should the space before conditional statement be added, "if(true)" vs "if (true)",

	    unescape_strings (default false) - should printable characters in strings encoded in \xNN notation be unescaped, "example" vs "\x65\x78\x61\x6d\x70\x6c\x65"

	    wrap_line_length (default unlimited) - lines should wrap at next opportunity after this number of characters.
	          NOTE: This is not a hard limit. Lines will continue until a point where a newline would
	                be preserved if it were present.

	    end_with_newline (default false)  - end output with a newline


	    e.g

	    js_beautify(js_source_text, {
	      'indent_size': 1,
	      'indent_char': '\t'
	    });

	*/

						(function () {
							/* GENERATED_BUILD_OUTPUT */
							var legacy_beautify_js = /******/ (function (modules) {
								// webpackBootstrap
								/******/ // The module cache
								/******/ var installedModules = {};
								/******/
								/******/ // The require function
								/******/ function __webpack_require__(moduleId) {
									/******/
									/******/ // Check if module is in cache
									/******/ if (installedModules[moduleId]) {
										/******/ return installedModules[moduleId].exports;
										/******/
									}
									/******/ // Create a new module (and put it into the cache)
									/******/ var module = (installedModules[moduleId] = {
										/******/ i: moduleId,
										/******/ l: false,
										/******/ exports: {}
										/******/
									});
									/******/
									/******/ // Execute the module function
									/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
									/******/
									/******/ // Flag the module as loaded
									/******/ module.l = true;
									/******/
									/******/ // Return the exports of the module
									/******/ return module.exports;
									/******/
								}
								/******/
								/******/
								/******/ // expose the modules object (__webpack_modules__)
								/******/ __webpack_require__.m = modules;
								/******/
								/******/ // expose the module cache
								/******/ __webpack_require__.c = installedModules;
								/******/
								/******/ // define getter function for harmony exports
								/******/ __webpack_require__.d = function (exports, name, getter) {
									/******/ if (!__webpack_require__.o(exports, name)) {
										/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
										/******/
									}
									/******/
								};
								/******/
								/******/ // define __esModule on exports
								/******/ __webpack_require__.r = function (exports) {
									/******/ if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
										/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
										/******/
									}
									/******/ Object.defineProperty(exports, '__esModule', { value: true });
									/******/
								};
								/******/
								/******/ // create a fake namespace object
								/******/ // mode & 1: value is a module id, require it
								/******/ // mode & 2: merge all properties of value into the ns
								/******/ // mode & 4: return value when already ns object
								/******/ // mode & 8|1: behave like require
								/******/ __webpack_require__.t = function (value, mode) {
									/******/ if (mode & 1) value = __webpack_require__(value);
									/******/ if (mode & 8) return value;
									/******/ if (mode & 4 && typeof value === 'object' && value && value.__esModule) return value;
									/******/ var ns = Object.create(null);
									/******/ __webpack_require__.r(ns);
									/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
									/******/ if (mode & 2 && typeof value != 'string')
										for (var key in value)
											__webpack_require__.d(
												ns,
												key,
												function (key) {
													return value[key];
												}.bind(null, key)
											);
									/******/ return ns;
									/******/
								};
								/******/
								/******/ // getDefaultExport function for compatibility with non-harmony modules
								/******/ __webpack_require__.n = function (module) {
									/******/ var getter =
										module && module.__esModule
											? /******/ function getDefault() {
													return module['default'];
											  }
											: /******/ function getModuleExports() {
													return module;
											  };
									/******/ __webpack_require__.d(getter, 'a', getter);
									/******/ return getter;
									/******/
								};
								/******/
								/******/ // Object.prototype.hasOwnProperty.call
								/******/ __webpack_require__.o = function (object, property) {
									return Object.prototype.hasOwnProperty.call(object, property);
								};
								/******/
								/******/ // __webpack_public_path__
								/******/ __webpack_require__.p = '';
								/******/
								/******/
								/******/ // Load entry module and return exports
								/******/ return __webpack_require__((__webpack_require__.s = 0));
								/******/
							})(
								/************************************************************************/
								/******/ [
									/* 0 */
									/***/ function (module, exports, __webpack_require__) {
										var Beautifier = __webpack_require__(1).Beautifier,
											Options = __webpack_require__(5).Options;

										function js_beautify(js_source_text, options) {
											var beautifier = new Beautifier(js_source_text, options);
											return beautifier.beautify();
										}

										module.exports = js_beautify;
										module.exports.defaultOptions = function () {
											return new Options();
										};

										/***/
									},
									/* 1 */
									/***/ function (module, exports, __webpack_require__) {
										var Output = __webpack_require__(2).Output;
										var Token = __webpack_require__(3).Token;
										var acorn = __webpack_require__(4);
										var Options = __webpack_require__(5).Options;
										var Tokenizer = __webpack_require__(7).Tokenizer;
										var line_starters = __webpack_require__(7).line_starters;
										var positionable_operators = __webpack_require__(7).positionable_operators;
										var TOKEN = __webpack_require__(7).TOKEN;

										function remove_redundant_indentation(output, frame) {
											// This implementation is effective but has some issues:
											//     - can cause line wrap to happen too soon due to indent removal
											//           after wrap points are calculated
											// These issues are minor compared to ugly indentation.

											if (
												frame.multiline_frame ||
												frame.mode === MODE.ForInitializer ||
												frame.mode === MODE.Conditional
											) {
												return;
											}

											// remove one indent from each line inside this section
											output.remove_indent(frame.start_line_index);
										}

										function in_array(what, arr) {
											return arr.indexOf(what) !== -1;
										}

										function ltrim(s) {
											return s.replace(/^\s+/g, '');
										}

										function generateMapFromStrings(list) {
											var result = {};
											for (var x = 0; x < list.length; x++) {
												// make the mapped names underscored instead of dash
												result[list[x].replace(/-/g, '_')] = list[x];
											}
											return result;
										}

										function reserved_word(token, word) {
											return token && token.type === TOKEN.RESERVED && token.text === word;
										}

										function reserved_array(token, words) {
											return token && token.type === TOKEN.RESERVED && in_array(token.text, words);
										}
										// Unsure of what they mean, but they work. Worth cleaning up in future.
										var special_words = [
											'case',
											'return',
											'do',
											'if',
											'throw',
											'else',
											'await',
											'break',
											'continue',
											'async'
										];

										var validPositionValues = ['before-newline', 'after-newline', 'preserve-newline'];

										// Generate map from array
										var OPERATOR_POSITION = generateMapFromStrings(validPositionValues);

										var OPERATOR_POSITION_BEFORE_OR_PRESERVE = [
											OPERATOR_POSITION.before_newline,
											OPERATOR_POSITION.preserve_newline
										];

										var MODE = {
											BlockStatement: 'BlockStatement', // 'BLOCK'
											Statement: 'Statement', // 'STATEMENT'
											ObjectLiteral: 'ObjectLiteral', // 'OBJECT',
											ArrayLiteral: 'ArrayLiteral', //'[EXPRESSION]',
											ForInitializer: 'ForInitializer', //'(FOR-EXPRESSION)',
											Conditional: 'Conditional', //'(COND-EXPRESSION)',
											Expression: 'Expression' //'(EXPRESSION)'
										};

										// we could use just string.split, but
										// IE doesn't like returning empty strings
										function split_linebreaks(s) {
											//return s.split(/\x0d\x0a|\x0a/);

											s = s.replace(acorn.allLineBreaks, '\n');
											var out = [],
												idx = s.indexOf('\n');
											while (idx !== -1) {
												out.push(s.substring(0, idx));
												s = s.substring(idx + 1);
												idx = s.indexOf('\n');
											}
											if (s.length) {
												out.push(s);
											}
											return out;
										}

										function is_array(mode) {
											return mode === MODE.ArrayLiteral;
										}

										function is_expression(mode) {
											return in_array(mode, [MODE.Expression, MODE.ForInitializer, MODE.Conditional]);
										}

										function all_lines_start_with(lines, c) {
											for (var i = 0; i < lines.length; i++) {
												var line = lines[i].trim();
												if (line.charAt(0) !== c) {
													return false;
												}
											}
											return true;
										}

										function each_line_matches_indent(lines, indent) {
											var i = 0,
												len = lines.length,
												line;
											for (; i < len; i++) {
												line = lines[i];
												// allow empty lines to pass through
												if (line && line.indexOf(indent) !== 0) {
													return false;
												}
											}
											return true;
										}

										function Beautifier(source_text, options) {
											options = options || {};
											this._source_text = source_text || '';

											this._output = null;
											this._tokens = null;
											this._last_last_text = null;
											this._flags = null;
											this._previous_flags = null;

											this._flag_store = null;
											this._options = new Options(options);
										}

										Beautifier.prototype.create_flags = function (flags_base, mode) {
											var next_indent_level = 0;
											if (flags_base) {
												next_indent_level = flags_base.indentation_level;
												if (!this._output.just_added_newline() && flags_base.line_indent_level > next_indent_level) {
													next_indent_level = flags_base.line_indent_level;
												}
											}

											var next_flags = {
												mode: mode,
												parent: flags_base,
												last_token: flags_base ? flags_base.last_token : new Token(TOKEN.START_BLOCK, ''), // last token text
												last_word: flags_base ? flags_base.last_word : '', // last TOKEN.WORD passed
												declaration_statement: false,
												declaration_assignment: false,
												multiline_frame: false,
												inline_frame: false,
												if_block: false,
												else_block: false,
												do_block: false,
												do_while: false,
												import_block: false,
												in_case_statement: false, // switch(..){ INSIDE HERE }
												in_case: false, // we're on the exact line with "case 0:"
												case_body: false, // the indented case-action block
												indentation_level: next_indent_level,
												line_indent_level: flags_base ? flags_base.line_indent_level : next_indent_level,
												start_line_index: this._output.get_line_number(),
												ternary_depth: 0
											};
											return next_flags;
										};

										Beautifier.prototype._reset = function (source_text) {
											var baseIndentString = source_text.match(/^[\t ]*/)[0];

											this._last_last_text = ''; // pre-last token text
											this._output = new Output(this._options, baseIndentString);

											// If testing the ignore directive, start with output disable set to true
											this._output.raw = this._options.test_output_raw;

											// Stack of parsing/formatting states, including MODE.
											// We tokenize, parse, and output in an almost purely a forward-only stream of token input
											// and formatted output.  This makes the beautifier less accurate than full parsers
											// but also far more tolerant of syntax errors.
											//
											// For example, the default mode is MODE.BlockStatement. If we see a '{' we push a new frame of type
											// MODE.BlockStatement on the the stack, even though it could be object literal.  If we later
											// encounter a ":", we'll switch to to MODE.ObjectLiteral.  If we then see a ";",
											// most full parsers would die, but the beautifier gracefully falls back to
											// MODE.BlockStatement and continues on.
											this._flag_store = [];
											this.set_mode(MODE.BlockStatement);
											var tokenizer = new Tokenizer(source_text, this._options);
											this._tokens = tokenizer.tokenize();
											return source_text;
										};

										Beautifier.prototype.beautify = function () {
											// if disabled, return the input unchanged.
											if (this._options.disabled) {
												return this._source_text;
											}

											var sweet_code;
											var source_text = this._reset(this._source_text);

											var eol = this._options.eol;
											if (this._options.eol === 'auto') {
												eol = '\n';
												if (source_text && acorn.lineBreak.test(source_text || '')) {
													eol = source_text.match(acorn.lineBreak)[0];
												}
											}

											var current_token = this._tokens.next();
											while (current_token) {
												this.handle_token(current_token);

												this._last_last_text = this._flags.last_token.text;
												this._flags.last_token = current_token;

												current_token = this._tokens.next();
											}

											sweet_code = this._output.get_code(eol);

											return sweet_code;
										};

										Beautifier.prototype.handle_token = function (current_token, preserve_statement_flags) {
											if (current_token.type === TOKEN.START_EXPR) {
												this.handle_start_expr(current_token);
											} else if (current_token.type === TOKEN.END_EXPR) {
												this.handle_end_expr(current_token);
											} else if (current_token.type === TOKEN.START_BLOCK) {
												this.handle_start_block(current_token);
											} else if (current_token.type === TOKEN.END_BLOCK) {
												this.handle_end_block(current_token);
											} else if (current_token.type === TOKEN.WORD) {
												this.handle_word(current_token);
											} else if (current_token.type === TOKEN.RESERVED) {
												this.handle_word(current_token);
											} else if (current_token.type === TOKEN.SEMICOLON) {
												this.handle_semicolon(current_token);
											} else if (current_token.type === TOKEN.STRING) {
												this.handle_string(current_token);
											} else if (current_token.type === TOKEN.EQUALS) {
												this.handle_equals(current_token);
											} else if (current_token.type === TOKEN.OPERATOR) {
												this.handle_operator(current_token);
											} else if (current_token.type === TOKEN.COMMA) {
												this.handle_comma(current_token);
											} else if (current_token.type === TOKEN.BLOCK_COMMENT) {
												this.handle_block_comment(current_token, preserve_statement_flags);
											} else if (current_token.type === TOKEN.COMMENT) {
												this.handle_comment(current_token, preserve_statement_flags);
											} else if (current_token.type === TOKEN.DOT) {
												this.handle_dot(current_token);
											} else if (current_token.type === TOKEN.EOF) {
												this.handle_eof(current_token);
											} else if (current_token.type === TOKEN.UNKNOWN) {
												this.handle_unknown(current_token, preserve_statement_flags);
											} else {
												this.handle_unknown(current_token, preserve_statement_flags);
											}
										};

										Beautifier.prototype.handle_whitespace_and_comments = function (
											current_token,
											preserve_statement_flags
										) {
											var newlines = current_token.newlines;
											var keep_whitespace = this._options.keep_array_indentation && is_array(this._flags.mode);

											if (current_token.comments_before) {
												var comment_token = current_token.comments_before.next();
												while (comment_token) {
													// The cleanest handling of inline comments is to treat them as though they aren't there.
													// Just continue formatting and the behavior should be logical.
													// Also ignore unknown tokens.  Again, this should result in better behavior.
													this.handle_whitespace_and_comments(comment_token, preserve_statement_flags);
													this.handle_token(comment_token, preserve_statement_flags);
													comment_token = current_token.comments_before.next();
												}
											}

											if (keep_whitespace) {
												for (var i = 0; i < newlines; i += 1) {
													this.print_newline(i > 0, preserve_statement_flags);
												}
											} else {
												if (this._options.max_preserve_newlines && newlines > this._options.max_preserve_newlines) {
													newlines = this._options.max_preserve_newlines;
												}

												if (this._options.preserve_newlines) {
													if (newlines > 1) {
														this.print_newline(false, preserve_statement_flags);
														for (var j = 1; j < newlines; j += 1) {
															this.print_newline(true, preserve_statement_flags);
														}
													}
												}
											}
										};

										var newline_restricted_tokens = ['async', 'break', 'continue', 'return', 'throw', 'yield'];

										Beautifier.prototype.allow_wrap_or_preserved_newline = function (current_token, force_linewrap) {
											force_linewrap = force_linewrap === undefined ? false : force_linewrap;

											// Never wrap the first token on a line
											if (this._output.just_added_newline()) {
												return;
											}

											var shouldPreserveOrForce =
												(this._options.preserve_newlines && current_token.newlines) || force_linewrap;
											var operatorLogicApplies =
												in_array(this._flags.last_token.text, positionable_operators) ||
												in_array(current_token.text, positionable_operators);

											if (operatorLogicApplies) {
												var shouldPrintOperatorNewline =
													(in_array(this._flags.last_token.text, positionable_operators) &&
														in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)) ||
													in_array(current_token.text, positionable_operators);
												shouldPreserveOrForce = shouldPreserveOrForce && shouldPrintOperatorNewline;
											}

											if (shouldPreserveOrForce) {
												this.print_newline(false, true);
											} else if (this._options.wrap_line_length) {
												if (reserved_array(this._flags.last_token, newline_restricted_tokens)) {
													// These tokens should never have a newline inserted
													// between them and the following expression.
													return;
												}
												var proposed_line_length =
													this._output.current_line.get_character_count() +
													current_token.text.length +
													(this._output.space_before_token ? 1 : 0);
												if (proposed_line_length >= this._options.wrap_line_length) {
													this.print_newline(false, true);
												}
											}
										};

										Beautifier.prototype.print_newline = function (force_newline, preserve_statement_flags) {
											if (!preserve_statement_flags) {
												if (
													this._flags.last_token.text !== ';' &&
													this._flags.last_token.text !== ',' &&
													this._flags.last_token.text !== '=' &&
													(this._flags.last_token.type !== TOKEN.OPERATOR ||
														this._flags.last_token.text === '--' ||
														this._flags.last_token.text === '++')
												) {
													var next_token = this._tokens.peek();
													while (
														this._flags.mode === MODE.Statement &&
														!(this._flags.if_block && reserved_word(next_token, 'else')) &&
														!this._flags.do_block
													) {
														this.restore_mode();
													}
												}
											}

											if (this._output.add_new_line(force_newline)) {
												this._flags.multiline_frame = true;
											}
										};

										Beautifier.prototype.print_token_line_indentation = function (current_token) {
											if (this._output.just_added_newline()) {
												if (
													this._options.keep_array_indentation &&
													is_array(this._flags.mode) &&
													current_token.newlines
												) {
													this._output.current_line.push(current_token.whitespace_before);
													this._output.space_before_token = false;
												} else if (this._output.set_indent(this._flags.indentation_level)) {
													this._flags.line_indent_level = this._flags.indentation_level;
												}
											}
										};

										Beautifier.prototype.print_token = function (current_token, printable_token) {
											if (this._output.raw) {
												this._output.add_raw_token(current_token);
												return;
											}

											if (
												this._options.comma_first &&
												current_token.previous &&
												current_token.previous.type === TOKEN.COMMA &&
												this._output.just_added_newline()
											) {
												if (this._output.previous_line.last() === ',') {
													var popped = this._output.previous_line.pop();
													// if the comma was already at the start of the line,
													// pull back onto that line and reprint the indentation
													if (this._output.previous_line.is_empty()) {
														this._output.previous_line.push(popped);
														this._output.trim(true);
														this._output.current_line.pop();
														this._output.trim();
													}

													// add the comma in front of the next token
													this.print_token_line_indentation(current_token);
													this._output.add_token(',');
													this._output.space_before_token = true;
												}
											}

											printable_token = printable_token || current_token.text;
											this.print_token_line_indentation(current_token);
											this._output.add_token(printable_token);
										};

										Beautifier.prototype.indent = function () {
											this._flags.indentation_level += 1;
										};

										Beautifier.prototype.deindent = function () {
											if (
												this._flags.indentation_level > 0 &&
												(!this._flags.parent || this._flags.indentation_level > this._flags.parent.indentation_level)
											) {
												this._flags.indentation_level -= 1;
											}
										};

										Beautifier.prototype.set_mode = function (mode) {
											if (this._flags) {
												this._flag_store.push(this._flags);
												this._previous_flags = this._flags;
											} else {
												this._previous_flags = this.create_flags(null, mode);
											}

											this._flags = this.create_flags(this._previous_flags, mode);
										};

										Beautifier.prototype.restore_mode = function () {
											if (this._flag_store.length > 0) {
												this._previous_flags = this._flags;
												this._flags = this._flag_store.pop();
												if (this._previous_flags.mode === MODE.Statement) {
													remove_redundant_indentation(this._output, this._previous_flags);
												}
											}
										};

										Beautifier.prototype.start_of_object_property = function () {
											return (
												this._flags.parent.mode === MODE.ObjectLiteral &&
												this._flags.mode === MODE.Statement &&
												((this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) ||
													reserved_array(this._flags.last_token, ['get', 'set']))
											);
										};

										Beautifier.prototype.start_of_statement = function (current_token) {
											var start = false;
											start =
												start ||
												(reserved_array(this._flags.last_token, ['var', 'let', 'const']) &&
													current_token.type === TOKEN.WORD);
											start = start || reserved_word(this._flags.last_token, 'do');
											start =
												start ||
												(!(this._flags.parent.mode === MODE.ObjectLiteral && this._flags.mode === MODE.Statement) &&
													reserved_array(this._flags.last_token, newline_restricted_tokens) &&
													!current_token.newlines);
											start =
												start ||
												(reserved_word(this._flags.last_token, 'else') &&
													!(reserved_word(current_token, 'if') && !current_token.comments_before));
											start =
												start ||
												(this._flags.last_token.type === TOKEN.END_EXPR &&
													(this._previous_flags.mode === MODE.ForInitializer ||
														this._previous_flags.mode === MODE.Conditional));
											start =
												start ||
												(this._flags.last_token.type === TOKEN.WORD &&
													this._flags.mode === MODE.BlockStatement &&
													!this._flags.in_case &&
													!(current_token.text === '--' || current_token.text === '++') &&
													this._last_last_text !== 'function' &&
													current_token.type !== TOKEN.WORD &&
													current_token.type !== TOKEN.RESERVED);
											start =
												start ||
												(this._flags.mode === MODE.ObjectLiteral &&
													((this._flags.last_token.text === ':' && this._flags.ternary_depth === 0) ||
														reserved_array(this._flags.last_token, ['get', 'set'])));

											if (start) {
												this.set_mode(MODE.Statement);
												this.indent();

												this.handle_whitespace_and_comments(current_token, true);

												// Issue #276:
												// If starting a new statement with [if, for, while, do], push to a new line.
												// if (a) if (b) if(c) d(); else e(); else f();
												if (!this.start_of_object_property()) {
													this.allow_wrap_or_preserved_newline(
														current_token,
														reserved_array(current_token, ['do', 'for', 'if', 'while'])
													);
												}
												return true;
											}
											return false;
										};

										Beautifier.prototype.handle_start_expr = function (current_token) {
											// The conditional starts the statement if appropriate.
											if (!this.start_of_statement(current_token)) {
												this.handle_whitespace_and_comments(current_token);
											}

											var next_mode = MODE.Expression;
											if (current_token.text === '[') {
												if (this._flags.last_token.type === TOKEN.WORD || this._flags.last_token.text === ')') {
													// this is array index specifier, break immediately
													// a[x], fn()[x]
													if (reserved_array(this._flags.last_token, line_starters)) {
														this._output.space_before_token = true;
													}
													this.set_mode(next_mode);
													this.print_token(current_token);
													this.indent();
													if (this._options.space_in_paren) {
														this._output.space_before_token = true;
													}
													return;
												}

												next_mode = MODE.ArrayLiteral;
												if (is_array(this._flags.mode)) {
													if (
														this._flags.last_token.text === '[' ||
														(this._flags.last_token.text === ',' &&
															(this._last_last_text === ']' || this._last_last_text === '}'))
													) {
														// ], [ goes to new line
														// }, [ goes to new line
														if (!this._options.keep_array_indentation) {
															this.print_newline();
														}
													}
												}

												if (
													!in_array(this._flags.last_token.type, [
														TOKEN.START_EXPR,
														TOKEN.END_EXPR,
														TOKEN.WORD,
														TOKEN.OPERATOR
													])
												) {
													this._output.space_before_token = true;
												}
											} else {
												if (this._flags.last_token.type === TOKEN.RESERVED) {
													if (this._flags.last_token.text === 'for') {
														this._output.space_before_token = this._options.space_before_conditional;
														next_mode = MODE.ForInitializer;
													} else if (in_array(this._flags.last_token.text, ['if', 'while'])) {
														this._output.space_before_token = this._options.space_before_conditional;
														next_mode = MODE.Conditional;
													} else if (in_array(this._flags.last_word, ['await', 'async'])) {
														// Should be a space between await and an IIFE, or async and an arrow function
														this._output.space_before_token = true;
													} else if (
														this._flags.last_token.text === 'import' &&
														current_token.whitespace_before === ''
													) {
														this._output.space_before_token = false;
													} else if (
														in_array(this._flags.last_token.text, line_starters) ||
														this._flags.last_token.text === 'catch'
													) {
														this._output.space_before_token = true;
													}
												} else if (
													this._flags.last_token.type === TOKEN.EQUALS ||
													this._flags.last_token.type === TOKEN.OPERATOR
												) {
													// Support of this kind of newline preservation.
													// a = (b &&
													//     (c || d));
													if (!this.start_of_object_property()) {
														this.allow_wrap_or_preserved_newline(current_token);
													}
												} else if (this._flags.last_token.type === TOKEN.WORD) {
													this._output.space_before_token = false;

													// function name() vs function name ()
													// function* name() vs function* name ()
													// async name() vs async name ()
													// In ES6, you can also define the method properties of an object
													// var obj = {a: function() {}}
													// It can be abbreviated
													// var obj = {a() {}}
													// var obj = { a() {}} vs var obj = { a () {}}
													// var obj = { * a() {}} vs var obj = { * a () {}}
													var peek_back_two = this._tokens.peek(-3);
													if (this._options.space_after_named_function && peek_back_two) {
														// peek starts at next character so -1 is current token
														var peek_back_three = this._tokens.peek(-4);
														if (
															reserved_array(peek_back_two, ['async', 'function']) ||
															(peek_back_two.text === '*' && reserved_array(peek_back_three, ['async', 'function']))
														) {
															this._output.space_before_token = true;
														} else if (this._flags.mode === MODE.ObjectLiteral) {
															if (
																peek_back_two.text === '{' ||
																peek_back_two.text === ',' ||
																(peek_back_two.text === '*' &&
																	(peek_back_three.text === '{' || peek_back_three.text === ','))
															) {
																this._output.space_before_token = true;
															}
														}
													}
												} else {
													// Support preserving wrapped arrow function expressions
													// a.b('c',
													//     () => d.e
													// )
													this.allow_wrap_or_preserved_newline(current_token);
												}

												// function() vs function ()
												// yield*() vs yield* ()
												// function*() vs function* ()
												if (
													(this._flags.last_token.type === TOKEN.RESERVED &&
														(this._flags.last_word === 'function' || this._flags.last_word === 'typeof')) ||
													(this._flags.last_token.text === '*' &&
														(in_array(this._last_last_text, ['function', 'yield']) ||
															(this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ',']))))
												) {
													this._output.space_before_token = this._options.space_after_anon_function;
												}
											}

											if (this._flags.last_token.text === ';' || this._flags.last_token.type === TOKEN.START_BLOCK) {
												this.print_newline();
											} else if (
												this._flags.last_token.type === TOKEN.END_EXPR ||
												this._flags.last_token.type === TOKEN.START_EXPR ||
												this._flags.last_token.type === TOKEN.END_BLOCK ||
												this._flags.last_token.text === '.' ||
												this._flags.last_token.type === TOKEN.COMMA
											) {
												// do nothing on (( and )( and ][ and ]( and .(
												// TODO: Consider whether forcing this is required.  Review failing tests when removed.
												this.allow_wrap_or_preserved_newline(current_token, current_token.newlines);
											}

											this.set_mode(next_mode);
											this.print_token(current_token);
											if (this._options.space_in_paren) {
												this._output.space_before_token = true;
											}

											// In all cases, if we newline while inside an expression it should be indented.
											this.indent();
										};

										Beautifier.prototype.handle_end_expr = function (current_token) {
											// statements inside expressions are not valid syntax, but...
											// statements must all be closed when their container closes
											while (this._flags.mode === MODE.Statement) {
												this.restore_mode();
											}

											this.handle_whitespace_and_comments(current_token);

											if (this._flags.multiline_frame) {
												this.allow_wrap_or_preserved_newline(
													current_token,
													current_token.text === ']' &&
														is_array(this._flags.mode) &&
														!this._options.keep_array_indentation
												);
											}

											if (this._options.space_in_paren) {
												if (this._flags.last_token.type === TOKEN.START_EXPR && !this._options.space_in_empty_paren) {
													// () [] no inner space in empty parens like these, ever, ref #320
													this._output.trim();
													this._output.space_before_token = false;
												} else {
													this._output.space_before_token = true;
												}
											}
											if (current_token.text === ']' && this._options.keep_array_indentation) {
												this.print_token(current_token);
												this.restore_mode();
											} else {
												this.restore_mode();
												this.print_token(current_token);
											}
											remove_redundant_indentation(this._output, this._previous_flags);

											// do {} while () // no statement required after
											if (this._flags.do_while && this._previous_flags.mode === MODE.Conditional) {
												this._previous_flags.mode = MODE.Expression;
												this._flags.do_block = false;
												this._flags.do_while = false;
											}
										};

										Beautifier.prototype.handle_start_block = function (current_token) {
											this.handle_whitespace_and_comments(current_token);

											// Check if this is should be treated as a ObjectLiteral
											var next_token = this._tokens.peek();
											var second_token = this._tokens.peek(1);
											if (this._flags.last_word === 'switch' && this._flags.last_token.type === TOKEN.END_EXPR) {
												this.set_mode(MODE.BlockStatement);
												this._flags.in_case_statement = true;
											} else if (
												second_token &&
												((in_array(second_token.text, [':', ',']) &&
													in_array(next_token.type, [TOKEN.STRING, TOKEN.WORD, TOKEN.RESERVED])) ||
													(in_array(next_token.text, ['get', 'set', '...']) &&
														in_array(second_token.type, [TOKEN.WORD, TOKEN.RESERVED])))
											) {
												// We don't support TypeScript,but we didn't break it for a very long time.
												// We'll try to keep not breaking it.
												if (!in_array(this._last_last_text, ['class', 'interface'])) {
													this.set_mode(MODE.ObjectLiteral);
												} else {
													this.set_mode(MODE.BlockStatement);
												}
											} else if (
												this._flags.last_token.type === TOKEN.OPERATOR &&
												this._flags.last_token.text === '=>'
											) {
												// arrow function: (param1, paramN) => { statements }
												this.set_mode(MODE.BlockStatement);
											} else if (
												in_array(this._flags.last_token.type, [
													TOKEN.EQUALS,
													TOKEN.START_EXPR,
													TOKEN.COMMA,
													TOKEN.OPERATOR
												]) ||
												reserved_array(this._flags.last_token, ['return', 'throw', 'import', 'default'])
											) {
												// Detecting shorthand function syntax is difficult by scanning forward,
												//     so check the surrounding context.
												// If the block is being returned, imported, export default, passed as arg,
												//     assigned with = or assigned in a nested object, treat as an ObjectLiteral.
												this.set_mode(MODE.ObjectLiteral);
											} else {
												this.set_mode(MODE.BlockStatement);
											}

											var empty_braces = !next_token.comments_before && next_token.text === '}';
											var empty_anonymous_function =
												empty_braces &&
												this._flags.last_word === 'function' &&
												this._flags.last_token.type === TOKEN.END_EXPR;

											if (this._options.brace_preserve_inline) {
												// check for inline, set inline_frame if so
												// search forward for a newline wanted inside this block
												var index = 0;
												var check_token = null;
												this._flags.inline_frame = true;
												do {
													index += 1;
													check_token = this._tokens.peek(index - 1);
													if (check_token.newlines) {
														this._flags.inline_frame = false;
														break;
													}
												} while (
													check_token.type !== TOKEN.EOF &&
													!(check_token.type === TOKEN.END_BLOCK && check_token.opened === current_token)
												);
											}

											if (
												(this._options.brace_style === 'expand' ||
													(this._options.brace_style === 'none' && current_token.newlines)) &&
												!this._flags.inline_frame
											) {
												if (
													this._flags.last_token.type !== TOKEN.OPERATOR &&
													(empty_anonymous_function ||
														this._flags.last_token.type === TOKEN.EQUALS ||
														(reserved_array(this._flags.last_token, special_words) &&
															this._flags.last_token.text !== 'else'))
												) {
													this._output.space_before_token = true;
												} else {
													this.print_newline(false, true);
												}
											} else {
												// collapse || inline_frame
												if (
													is_array(this._previous_flags.mode) &&
													(this._flags.last_token.type === TOKEN.START_EXPR ||
														this._flags.last_token.type === TOKEN.COMMA)
												) {
													if (this._flags.last_token.type === TOKEN.COMMA || this._options.space_in_paren) {
														this._output.space_before_token = true;
													}

													if (
														this._flags.last_token.type === TOKEN.COMMA ||
														(this._flags.last_token.type === TOKEN.START_EXPR && this._flags.inline_frame)
													) {
														this.allow_wrap_or_preserved_newline(current_token);
														this._previous_flags.multiline_frame =
															this._previous_flags.multiline_frame || this._flags.multiline_frame;
														this._flags.multiline_frame = false;
													}
												}
												if (
													this._flags.last_token.type !== TOKEN.OPERATOR &&
													this._flags.last_token.type !== TOKEN.START_EXPR
												) {
													if (this._flags.last_token.type === TOKEN.START_BLOCK && !this._flags.inline_frame) {
														this.print_newline();
													} else {
														this._output.space_before_token = true;
													}
												}
											}
											this.print_token(current_token);
											this.indent();

											// Except for specific cases, open braces are followed by a new line.
											if (!empty_braces && !(this._options.brace_preserve_inline && this._flags.inline_frame)) {
												this.print_newline();
											}
										};

										Beautifier.prototype.handle_end_block = function (current_token) {
											// statements must all be closed when their container closes
											this.handle_whitespace_and_comments(current_token);

											while (this._flags.mode === MODE.Statement) {
												this.restore_mode();
											}

											var empty_braces = this._flags.last_token.type === TOKEN.START_BLOCK;

											if (this._flags.inline_frame && !empty_braces) {
												// try inline_frame (only set if this._options.braces-preserve-inline) first
												this._output.space_before_token = true;
											} else if (this._options.brace_style === 'expand') {
												if (!empty_braces) {
													this.print_newline();
												}
											} else {
												// skip {}
												if (!empty_braces) {
													if (is_array(this._flags.mode) && this._options.keep_array_indentation) {
														// we REALLY need a newline here, but newliner would skip that
														this._options.keep_array_indentation = false;
														this.print_newline();
														this._options.keep_array_indentation = true;
													} else {
														this.print_newline();
													}
												}
											}
											this.restore_mode();
											this.print_token(current_token);
										};

										Beautifier.prototype.handle_word = function (current_token) {
											if (current_token.type === TOKEN.RESERVED) {
												if (in_array(current_token.text, ['set', 'get']) && this._flags.mode !== MODE.ObjectLiteral) {
													current_token.type = TOKEN.WORD;
												} else if (current_token.text === 'import' && this._tokens.peek().text === '(') {
													current_token.type = TOKEN.WORD;
												} else if (in_array(current_token.text, ['as', 'from']) && !this._flags.import_block) {
													current_token.type = TOKEN.WORD;
												} else if (this._flags.mode === MODE.ObjectLiteral) {
													var next_token = this._tokens.peek();
													if (next_token.text === ':') {
														current_token.type = TOKEN.WORD;
													}
												}
											}

											if (this.start_of_statement(current_token)) {
												// The conditional starts the statement if appropriate.
												if (
													reserved_array(this._flags.last_token, ['var', 'let', 'const']) &&
													current_token.type === TOKEN.WORD
												) {
													this._flags.declaration_statement = true;
												}
											} else if (
												current_token.newlines &&
												!is_expression(this._flags.mode) &&
												(this._flags.last_token.type !== TOKEN.OPERATOR ||
													this._flags.last_token.text === '--' ||
													this._flags.last_token.text === '++') &&
												this._flags.last_token.type !== TOKEN.EQUALS &&
												(this._options.preserve_newlines ||
													!reserved_array(this._flags.last_token, ['var', 'let', 'const', 'set', 'get']))
											) {
												this.handle_whitespace_and_comments(current_token);
												this.print_newline();
											} else {
												this.handle_whitespace_and_comments(current_token);
											}

											if (this._flags.do_block && !this._flags.do_while) {
												if (reserved_word(current_token, 'while')) {
													// do {} ## while ()
													this._output.space_before_token = true;
													this.print_token(current_token);
													this._output.space_before_token = true;
													this._flags.do_while = true;
													return;
												} else {
													// do {} should always have while as the next word.
													// if we don't see the expected while, recover
													this.print_newline();
													this._flags.do_block = false;
												}
											}

											// if may be followed by else, or not
											// Bare/inline ifs are tricky
											// Need to unwind the modes correctly: if (a) if (b) c(); else d(); else e();
											if (this._flags.if_block) {
												if (!this._flags.else_block && reserved_word(current_token, 'else')) {
													this._flags.else_block = true;
												} else {
													while (this._flags.mode === MODE.Statement) {
														this.restore_mode();
													}
													this._flags.if_block = false;
													this._flags.else_block = false;
												}
											}

											if (this._flags.in_case_statement && reserved_array(current_token, ['case', 'default'])) {
												this.print_newline();
												if (this._flags.case_body || this._options.jslint_happy) {
													// switch cases following one another
													this.deindent();
													this._flags.case_body = false;
												}
												this.print_token(current_token);
												this._flags.in_case = true;
												return;
											}

											if (
												this._flags.last_token.type === TOKEN.COMMA ||
												this._flags.last_token.type === TOKEN.START_EXPR ||
												this._flags.last_token.type === TOKEN.EQUALS ||
												this._flags.last_token.type === TOKEN.OPERATOR
											) {
												if (!this.start_of_object_property()) {
													this.allow_wrap_or_preserved_newline(current_token);
												}
											}

											if (reserved_word(current_token, 'function')) {
												if (
													in_array(this._flags.last_token.text, ['}', ';']) ||
													(this._output.just_added_newline() &&
														!(
															in_array(this._flags.last_token.text, ['(', '[', '{', ':', '=', ',']) ||
															this._flags.last_token.type === TOKEN.OPERATOR
														))
												) {
													// make sure there is a nice clean space of at least one blank line
													// before a new function definition
													if (!this._output.just_added_blankline() && !current_token.comments_before) {
														this.print_newline();
														this.print_newline(true);
													}
												}
												if (
													this._flags.last_token.type === TOKEN.RESERVED ||
													this._flags.last_token.type === TOKEN.WORD
												) {
													if (
														reserved_array(this._flags.last_token, ['get', 'set', 'new', 'export']) ||
														reserved_array(this._flags.last_token, newline_restricted_tokens)
													) {
														this._output.space_before_token = true;
													} else if (
														reserved_word(this._flags.last_token, 'default') &&
														this._last_last_text === 'export'
													) {
														this._output.space_before_token = true;
													} else if (this._flags.last_token.text === 'declare') {
														// accomodates Typescript declare function formatting
														this._output.space_before_token = true;
													} else {
														this.print_newline();
													}
												} else if (
													this._flags.last_token.type === TOKEN.OPERATOR ||
													this._flags.last_token.text === '='
												) {
													// foo = function
													this._output.space_before_token = true;
												} else if (
													!this._flags.multiline_frame &&
													(is_expression(this._flags.mode) || is_array(this._flags.mode))
												);
												else {
													this.print_newline();
												}

												this.print_token(current_token);
												this._flags.last_word = current_token.text;
												return;
											}

											var prefix = 'NONE';

											if (this._flags.last_token.type === TOKEN.END_BLOCK) {
												if (this._previous_flags.inline_frame) {
													prefix = 'SPACE';
												} else if (!reserved_array(current_token, ['else', 'catch', 'finally', 'from'])) {
													prefix = 'NEWLINE';
												} else {
													if (
														this._options.brace_style === 'expand' ||
														this._options.brace_style === 'end-expand' ||
														(this._options.brace_style === 'none' && current_token.newlines)
													) {
														prefix = 'NEWLINE';
													} else {
														prefix = 'SPACE';
														this._output.space_before_token = true;
													}
												}
											} else if (
												this._flags.last_token.type === TOKEN.SEMICOLON &&
												this._flags.mode === MODE.BlockStatement
											) {
												// TODO: Should this be for STATEMENT as well?
												prefix = 'NEWLINE';
											} else if (this._flags.last_token.type === TOKEN.SEMICOLON && is_expression(this._flags.mode)) {
												prefix = 'SPACE';
											} else if (this._flags.last_token.type === TOKEN.STRING) {
												prefix = 'NEWLINE';
											} else if (
												this._flags.last_token.type === TOKEN.RESERVED ||
												this._flags.last_token.type === TOKEN.WORD ||
												(this._flags.last_token.text === '*' &&
													(in_array(this._last_last_text, ['function', 'yield']) ||
														(this._flags.mode === MODE.ObjectLiteral && in_array(this._last_last_text, ['{', ',']))))
											) {
												prefix = 'SPACE';
											} else if (this._flags.last_token.type === TOKEN.START_BLOCK) {
												if (this._flags.inline_frame) {
													prefix = 'SPACE';
												} else {
													prefix = 'NEWLINE';
												}
											} else if (this._flags.last_token.type === TOKEN.END_EXPR) {
												this._output.space_before_token = true;
												prefix = 'NEWLINE';
											}

											if (reserved_array(current_token, line_starters) && this._flags.last_token.text !== ')') {
												if (
													this._flags.inline_frame ||
													this._flags.last_token.text === 'else' ||
													this._flags.last_token.text === 'export'
												) {
													prefix = 'SPACE';
												} else {
													prefix = 'NEWLINE';
												}
											}

											if (reserved_array(current_token, ['else', 'catch', 'finally'])) {
												if (
													(!(
														this._flags.last_token.type === TOKEN.END_BLOCK &&
														this._previous_flags.mode === MODE.BlockStatement
													) ||
														this._options.brace_style === 'expand' ||
														this._options.brace_style === 'end-expand' ||
														(this._options.brace_style === 'none' && current_token.newlines)) &&
													!this._flags.inline_frame
												) {
													this.print_newline();
												} else {
													this._output.trim(true);
													var line = this._output.current_line;
													// If we trimmed and there's something other than a close block before us
													// put a newline back in.  Handles '} // comment' scenario.
													if (line.last() !== '}') {
														this.print_newline();
													}
													this._output.space_before_token = true;
												}
											} else if (prefix === 'NEWLINE') {
												if (reserved_array(this._flags.last_token, special_words)) {
													// no newline between 'return nnn'
													this._output.space_before_token = true;
												} else if (
													this._flags.last_token.text === 'declare' &&
													reserved_array(current_token, ['var', 'let', 'const'])
												) {
													// accomodates Typescript declare formatting
													this._output.space_before_token = true;
												} else if (this._flags.last_token.type !== TOKEN.END_EXPR) {
													if (
														(this._flags.last_token.type !== TOKEN.START_EXPR ||
															!reserved_array(current_token, ['var', 'let', 'const'])) &&
														this._flags.last_token.text !== ':'
													) {
														// no need to force newline on 'var': for (var x = 0...)
														if (reserved_word(current_token, 'if') && reserved_word(current_token.previous, 'else')) {
															// no newline for } else if {
															this._output.space_before_token = true;
														} else {
															this.print_newline();
														}
													}
												} else if (
													reserved_array(current_token, line_starters) &&
													this._flags.last_token.text !== ')'
												) {
													this.print_newline();
												}
											} else if (
												this._flags.multiline_frame &&
												is_array(this._flags.mode) &&
												this._flags.last_token.text === ',' &&
												this._last_last_text === '}'
											) {
												this.print_newline(); // }, in lists get a newline treatment
											} else if (prefix === 'SPACE') {
												this._output.space_before_token = true;
											}
											if (
												current_token.previous &&
												(current_token.previous.type === TOKEN.WORD || current_token.previous.type === TOKEN.RESERVED)
											) {
												this._output.space_before_token = true;
											}
											this.print_token(current_token);
											this._flags.last_word = current_token.text;

											if (current_token.type === TOKEN.RESERVED) {
												if (current_token.text === 'do') {
													this._flags.do_block = true;
												} else if (current_token.text === 'if') {
													this._flags.if_block = true;
												} else if (current_token.text === 'import') {
													this._flags.import_block = true;
												} else if (this._flags.import_block && reserved_word(current_token, 'from')) {
													this._flags.import_block = false;
												}
											}
										};

										Beautifier.prototype.handle_semicolon = function (current_token) {
											if (this.start_of_statement(current_token)) {
												// The conditional starts the statement if appropriate.
												// Semicolon can be the start (and end) of a statement
												this._output.space_before_token = false;
											} else {
												this.handle_whitespace_and_comments(current_token);
											}

											var next_token = this._tokens.peek();
											while (
												this._flags.mode === MODE.Statement &&
												!(this._flags.if_block && reserved_word(next_token, 'else')) &&
												!this._flags.do_block
											) {
												this.restore_mode();
											}

											// hacky but effective for the moment
											if (this._flags.import_block) {
												this._flags.import_block = false;
											}
											this.print_token(current_token);
										};

										Beautifier.prototype.handle_string = function (current_token) {
											if (this.start_of_statement(current_token)) {
												// The conditional starts the statement if appropriate.
												// One difference - strings want at least a space before
												this._output.space_before_token = true;
											} else {
												this.handle_whitespace_and_comments(current_token);
												if (
													this._flags.last_token.type === TOKEN.RESERVED ||
													this._flags.last_token.type === TOKEN.WORD ||
													this._flags.inline_frame
												) {
													this._output.space_before_token = true;
												} else if (
													this._flags.last_token.type === TOKEN.COMMA ||
													this._flags.last_token.type === TOKEN.START_EXPR ||
													this._flags.last_token.type === TOKEN.EQUALS ||
													this._flags.last_token.type === TOKEN.OPERATOR
												) {
													if (!this.start_of_object_property()) {
														this.allow_wrap_or_preserved_newline(current_token);
													}
												} else {
													this.print_newline();
												}
											}
											this.print_token(current_token);
										};

										Beautifier.prototype.handle_equals = function (current_token) {
											if (this.start_of_statement(current_token));
											else {
												this.handle_whitespace_and_comments(current_token);
											}

											if (this._flags.declaration_statement) {
												// just got an '=' in a var-line, different formatting/line-breaking, etc will now be done
												this._flags.declaration_assignment = true;
											}
											this._output.space_before_token = true;
											this.print_token(current_token);
											this._output.space_before_token = true;
										};

										Beautifier.prototype.handle_comma = function (current_token) {
											this.handle_whitespace_and_comments(current_token, true);

											this.print_token(current_token);
											this._output.space_before_token = true;
											if (this._flags.declaration_statement) {
												if (is_expression(this._flags.parent.mode)) {
													// do not break on comma, for(var a = 1, b = 2)
													this._flags.declaration_assignment = false;
												}

												if (this._flags.declaration_assignment) {
													this._flags.declaration_assignment = false;
													this.print_newline(false, true);
												} else if (this._options.comma_first) {
													// for comma-first, we want to allow a newline before the comma
													// to turn into a newline after the comma, which we will fixup later
													this.allow_wrap_or_preserved_newline(current_token);
												}
											} else if (
												this._flags.mode === MODE.ObjectLiteral ||
												(this._flags.mode === MODE.Statement && this._flags.parent.mode === MODE.ObjectLiteral)
											) {
												if (this._flags.mode === MODE.Statement) {
													this.restore_mode();
												}

												if (!this._flags.inline_frame) {
													this.print_newline();
												}
											} else if (this._options.comma_first) {
												// EXPR or DO_BLOCK
												// for comma-first, we want to allow a newline before the comma
												// to turn into a newline after the comma, which we will fixup later
												this.allow_wrap_or_preserved_newline(current_token);
											}
										};

										Beautifier.prototype.handle_operator = function (current_token) {
											var isGeneratorAsterisk =
												current_token.text === '*' &&
												(reserved_array(this._flags.last_token, ['function', 'yield']) ||
													in_array(this._flags.last_token.type, [
														TOKEN.START_BLOCK,
														TOKEN.COMMA,
														TOKEN.END_BLOCK,
														TOKEN.SEMICOLON
													]));
											var isUnary =
												in_array(current_token.text, ['-', '+']) &&
												(in_array(this._flags.last_token.type, [
													TOKEN.START_BLOCK,
													TOKEN.START_EXPR,
													TOKEN.EQUALS,
													TOKEN.OPERATOR
												]) ||
													in_array(this._flags.last_token.text, line_starters) ||
													this._flags.last_token.text === ',');

											if (this.start_of_statement(current_token));
											else {
												var preserve_statement_flags = !isGeneratorAsterisk;
												this.handle_whitespace_and_comments(current_token, preserve_statement_flags);
											}

											if (reserved_array(this._flags.last_token, special_words)) {
												// "return" had a special handling in TK_WORD. Now we need to return the favor
												this._output.space_before_token = true;
												this.print_token(current_token);
												return;
											}

											// hack for actionscript's import .*;
											if (current_token.text === '*' && this._flags.last_token.type === TOKEN.DOT) {
												this.print_token(current_token);
												return;
											}

											if (current_token.text === '::') {
												// no spaces around exotic namespacing syntax operator
												this.print_token(current_token);
												return;
											}

											// Allow line wrapping between operators when operator_position is
											//   set to before or preserve
											if (
												this._flags.last_token.type === TOKEN.OPERATOR &&
												in_array(this._options.operator_position, OPERATOR_POSITION_BEFORE_OR_PRESERVE)
											) {
												this.allow_wrap_or_preserved_newline(current_token);
											}

											if (current_token.text === ':' && this._flags.in_case) {
												this._flags.case_body = true;
												this.indent();
												this.print_token(current_token);
												this.print_newline();
												this._flags.in_case = false;
												return;
											}

											var space_before = true;
											var space_after = true;
											var in_ternary = false;
											if (current_token.text === ':') {
												if (this._flags.ternary_depth === 0) {
													// Colon is invalid javascript outside of ternary and object, but do our best to guess what was meant.
													space_before = false;
												} else {
													this._flags.ternary_depth -= 1;
													in_ternary = true;
												}
											} else if (current_token.text === '?') {
												this._flags.ternary_depth += 1;
											}

											// let's handle the operator_position option prior to any conflicting logic
											if (
												!isUnary &&
												!isGeneratorAsterisk &&
												this._options.preserve_newlines &&
												in_array(current_token.text, positionable_operators)
											) {
												var isColon = current_token.text === ':';
												var isTernaryColon = isColon && in_ternary;
												var isOtherColon = isColon && !in_ternary;

												switch (this._options.operator_position) {
													case OPERATOR_POSITION.before_newline:
														// if the current token is : and it's not a ternary statement then we set space_before to false
														this._output.space_before_token = !isOtherColon;

														this.print_token(current_token);

														if (!isColon || isTernaryColon) {
															this.allow_wrap_or_preserved_newline(current_token);
														}

														this._output.space_before_token = true;
														return;

													case OPERATOR_POSITION.after_newline:
														// if the current token is anything but colon, or (via deduction) it's a colon and in a ternary statement,
														//   then print a newline.

														this._output.space_before_token = true;

														if (!isColon || isTernaryColon) {
															if (this._tokens.peek().newlines) {
																this.print_newline(false, true);
															} else {
																this.allow_wrap_or_preserved_newline(current_token);
															}
														} else {
															this._output.space_before_token = false;
														}

														this.print_token(current_token);

														this._output.space_before_token = true;
														return;

													case OPERATOR_POSITION.preserve_newline:
														if (!isOtherColon) {
															this.allow_wrap_or_preserved_newline(current_token);
														}

														// if we just added a newline, or the current token is : and it's not a ternary statement,
														//   then we set space_before to false
														space_before = !(this._output.just_added_newline() || isOtherColon);

														this._output.space_before_token = space_before;
														this.print_token(current_token);
														this._output.space_before_token = true;
														return;
												}
											}

											if (isGeneratorAsterisk) {
												this.allow_wrap_or_preserved_newline(current_token);
												space_before = false;
												var next_token = this._tokens.peek();
												space_after = next_token && in_array(next_token.type, [TOKEN.WORD, TOKEN.RESERVED]);
											} else if (current_token.text === '...') {
												this.allow_wrap_or_preserved_newline(current_token);
												space_before = this._flags.last_token.type === TOKEN.START_BLOCK;
												space_after = false;
											} else if (in_array(current_token.text, ['--', '++', '!', '~']) || isUnary) {
												// unary operators (and binary +/- pretending to be unary) special cases
												if (
													this._flags.last_token.type === TOKEN.COMMA ||
													this._flags.last_token.type === TOKEN.START_EXPR
												) {
													this.allow_wrap_or_preserved_newline(current_token);
												}

												space_before = false;
												space_after = false;

												// http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1
												// if there is a newline between -- or ++ and anything else we should preserve it.
												if (current_token.newlines && (current_token.text === '--' || current_token.text === '++')) {
													this.print_newline(false, true);
												}

												if (this._flags.last_token.text === ';' && is_expression(this._flags.mode)) {
													// for (;; ++i)
													//        ^^^
													space_before = true;
												}

												if (this._flags.last_token.type === TOKEN.RESERVED) {
													space_before = true;
												} else if (this._flags.last_token.type === TOKEN.END_EXPR) {
													space_before = !(
														this._flags.last_token.text === ']' &&
														(current_token.text === '--' || current_token.text === '++')
													);
												} else if (this._flags.last_token.type === TOKEN.OPERATOR) {
													// a++ + ++b;
													// a - -b
													space_before =
														in_array(current_token.text, ['--', '-', '++', '+']) &&
														in_array(this._flags.last_token.text, ['--', '-', '++', '+']);
													// + and - are not unary when preceeded by -- or ++ operator
													// a-- + b
													// a * +b
													// a - -b
													if (
														in_array(current_token.text, ['+', '-']) &&
														in_array(this._flags.last_token.text, ['--', '++'])
													) {
														space_after = true;
													}
												}

												if (
													((this._flags.mode === MODE.BlockStatement && !this._flags.inline_frame) ||
														this._flags.mode === MODE.Statement) &&
													(this._flags.last_token.text === '{' || this._flags.last_token.text === ';')
												) {
													// { foo; --i }
													// foo(); --bar;
													this.print_newline();
												}
											}

											this._output.space_before_token = this._output.space_before_token || space_before;
											this.print_token(current_token);
											this._output.space_before_token = space_after;
										};

										Beautifier.prototype.handle_block_comment = function (current_token, preserve_statement_flags) {
											if (this._output.raw) {
												this._output.add_raw_token(current_token);
												if (current_token.directives && current_token.directives.preserve === 'end') {
													// If we're testing the raw output behavior, do not allow a directive to turn it off.
													this._output.raw = this._options.test_output_raw;
												}
												return;
											}

											if (current_token.directives) {
												this.print_newline(false, preserve_statement_flags);
												this.print_token(current_token);
												if (current_token.directives.preserve === 'start') {
													this._output.raw = true;
												}
												this.print_newline(false, true);
												return;
											}

											// inline block
											if (!acorn.newline.test(current_token.text) && !current_token.newlines) {
												this._output.space_before_token = true;
												this.print_token(current_token);
												this._output.space_before_token = true;
												return;
											}

											var lines = split_linebreaks(current_token.text);
											var j; // iterator for this case
											var javadoc = false;
											var starless = false;
											var lastIndent = current_token.whitespace_before;
											var lastIndentLength = lastIndent.length;

											// block comment starts with a new line
											this.print_newline(false, preserve_statement_flags);
											if (lines.length > 1) {
												javadoc = all_lines_start_with(lines.slice(1), '*');
												starless = each_line_matches_indent(lines.slice(1), lastIndent);
											}

											// first line always indented
											this.print_token(current_token, lines[0]);
											for (j = 1; j < lines.length; j++) {
												this.print_newline(false, true);
												if (javadoc) {
													// javadoc: reformat and re-indent
													this.print_token(current_token, ' ' + ltrim(lines[j]));
												} else if (starless && lines[j].length > lastIndentLength) {
													// starless: re-indent non-empty content, avoiding trim
													this.print_token(current_token, lines[j].substring(lastIndentLength));
												} else {
													// normal comments output raw
													this._output.add_token(lines[j]);
												}
											}

											// for comments of more than one line, make sure there's a new line after
											this.print_newline(false, preserve_statement_flags);
										};

										Beautifier.prototype.handle_comment = function (current_token, preserve_statement_flags) {
											if (current_token.newlines) {
												this.print_newline(false, preserve_statement_flags);
											} else {
												this._output.trim(true);
											}

											this._output.space_before_token = true;
											this.print_token(current_token);
											this.print_newline(false, preserve_statement_flags);
										};

										Beautifier.prototype.handle_dot = function (current_token) {
											if (this.start_of_statement(current_token));
											else {
												this.handle_whitespace_and_comments(current_token, true);
											}

											if (reserved_array(this._flags.last_token, special_words)) {
												this._output.space_before_token = false;
											} else {
												// allow preserved newlines before dots in general
												// force newlines on dots after close paren when break_chained - for bar().baz()
												this.allow_wrap_or_preserved_newline(
													current_token,
													this._flags.last_token.text === ')' && this._options.break_chained_methods
												);
											}

											// Only unindent chained method dot if this dot starts a new line.
											// Otherwise the automatic extra indentation removal will handle the over indent
											if (this._options.unindent_chained_methods && this._output.just_added_newline()) {
												this.deindent();
											}

											this.print_token(current_token);
										};

										Beautifier.prototype.handle_unknown = function (current_token, preserve_statement_flags) {
											this.print_token(current_token);

											if (current_token.text[current_token.text.length - 1] === '\n') {
												this.print_newline(false, preserve_statement_flags);
											}
										};

										Beautifier.prototype.handle_eof = function (current_token) {
											// Unwind any open statements
											while (this._flags.mode === MODE.Statement) {
												this.restore_mode();
											}
											this.handle_whitespace_and_comments(current_token);
										};

										module.exports.Beautifier = Beautifier;

										/***/
									},
									/* 2 */
									/***/ function (module, exports, __webpack_require__) {
										function OutputLine(parent) {
											this.__parent = parent;
											this.__character_count = 0;
											// use indent_count as a marker for this.__lines that have preserved indentation
											this.__indent_count = -1;
											this.__alignment_count = 0;

											this.__items = [];
										}

										OutputLine.prototype.item = function (index) {
											if (index < 0) {
												return this.__items[this.__items.length + index];
											} else {
												return this.__items[index];
											}
										};

										OutputLine.prototype.has_match = function (pattern) {
											for (
												var lastCheckedOutput = this.__items.length - 1;
												lastCheckedOutput >= 0;
												lastCheckedOutput--
											) {
												if (this.__items[lastCheckedOutput].match(pattern)) {
													return true;
												}
											}
											return false;
										};

										OutputLine.prototype.set_indent = function (indent, alignment) {
											this.__indent_count = indent || 0;
											this.__alignment_count = alignment || 0;
											this.__character_count =
												this.__parent.baseIndentLength +
												this.__alignment_count +
												this.__indent_count * this.__parent.indent_length;
										};

										OutputLine.prototype.get_character_count = function () {
											return this.__character_count;
										};

										OutputLine.prototype.is_empty = function () {
											return this.__items.length === 0;
										};

										OutputLine.prototype.last = function () {
											if (!this.is_empty()) {
												return this.__items[this.__items.length - 1];
											} else {
												return null;
											}
										};

										OutputLine.prototype.push = function (item) {
											this.__items.push(item);
											this.__character_count += item.length;
										};

										OutputLine.prototype.push_raw = function (item) {
											this.push(item);
											var last_newline_index = item.lastIndexOf('\n');
											if (last_newline_index !== -1) {
												this.__character_count = item.length - last_newline_index;
											}
										};

										OutputLine.prototype.pop = function () {
											var item = null;
											if (!this.is_empty()) {
												item = this.__items.pop();
												this.__character_count -= item.length;
											}
											return item;
										};

										OutputLine.prototype.remove_indent = function () {
											if (this.__indent_count > 0) {
												this.__indent_count -= 1;
												this.__character_count -= this.__parent.indent_length;
											}
										};

										OutputLine.prototype.trim = function () {
											while (this.last() === ' ') {
												this.__items.pop();
												this.__character_count -= 1;
											}
										};

										OutputLine.prototype.toString = function () {
											var result = '';
											if (!this.is_empty()) {
												if (this.__indent_count >= 0) {
													result = this.__parent.get_indent_string(this.__indent_count);
												}
												if (this.__alignment_count >= 0) {
													result += this.__parent.get_alignment_string(this.__alignment_count);
												}
												result += this.__items.join('');
											}
											return result;
										};

										function IndentCache(base_string, level_string) {
											this.__cache = [base_string];
											this.__level_string = level_string;
										}

										IndentCache.prototype.__ensure_cache = function (level) {
											while (level >= this.__cache.length) {
												this.__cache.push(this.__cache[this.__cache.length - 1] + this.__level_string);
											}
										};

										IndentCache.prototype.get_level_string = function (level) {
											this.__ensure_cache(level);
											return this.__cache[level];
										};

										function Output(options, baseIndentString) {
											var indent_string = options.indent_char;
											if (options.indent_size > 1) {
												indent_string = new Array(options.indent_size + 1).join(options.indent_char);
											}

											// Set to null to continue support for auto detection of base indent level.
											baseIndentString = baseIndentString || '';
											if (options.indent_level > 0) {
												baseIndentString = new Array(options.indent_level + 1).join(indent_string);
											}

											this.__indent_cache = new IndentCache(baseIndentString, indent_string);
											this.__alignment_cache = new IndentCache('', ' ');
											this.baseIndentLength = baseIndentString.length;
											this.indent_length = indent_string.length;
											this.raw = false;
											this._end_with_newline = options.end_with_newline;

											this.__lines = [];
											this.previous_line = null;
											this.current_line = null;
											this.space_before_token = false;
											// initialize
											this.__add_outputline();
										}

										Output.prototype.__add_outputline = function () {
											this.previous_line = this.current_line;
											this.current_line = new OutputLine(this);
											this.__lines.push(this.current_line);
										};

										Output.prototype.get_line_number = function () {
											return this.__lines.length;
										};

										Output.prototype.get_indent_string = function (level) {
											return this.__indent_cache.get_level_string(level);
										};

										Output.prototype.get_alignment_string = function (level) {
											return this.__alignment_cache.get_level_string(level);
										};

										Output.prototype.is_empty = function () {
											return !this.previous_line && this.current_line.is_empty();
										};

										Output.prototype.add_new_line = function (force_newline) {
											// never newline at the start of file
											// otherwise, newline only if we didn't just add one or we're forced
											if (this.is_empty() || (!force_newline && this.just_added_newline())) {
												return false;
											}

											// if raw output is enabled, don't print additional newlines,
											// but still return True as though you had
											if (!this.raw) {
												this.__add_outputline();
											}
											return true;
										};

										Output.prototype.get_code = function (eol) {
											var sweet_code = this.__lines.join('\n').replace(/[\r\n\t ]+$/, '');

											if (this._end_with_newline) {
												sweet_code += '\n';
											}

											if (eol !== '\n') {
												sweet_code = sweet_code.replace(/[\n]/g, eol);
											}

											return sweet_code;
										};

										Output.prototype.set_indent = function (indent, alignment) {
											indent = indent || 0;
											alignment = alignment || 0;

											// Never indent your first output indent at the start of the file
											if (this.__lines.length > 1) {
												this.current_line.set_indent(indent, alignment);
												return true;
											}
											this.current_line.set_indent();
											return false;
										};

										Output.prototype.add_raw_token = function (token) {
											for (var x = 0; x < token.newlines; x++) {
												this.__add_outputline();
											}
											this.current_line.push(token.whitespace_before);
											this.current_line.push_raw(token.text);
											this.space_before_token = false;
										};

										Output.prototype.add_token = function (printable_token) {
											this.add_space_before_token();
											this.current_line.push(printable_token);
										};

										Output.prototype.add_space_before_token = function () {
											if (this.space_before_token && !this.just_added_newline()) {
												this.current_line.push(' ');
											}
											this.space_before_token = false;
										};

										Output.prototype.remove_indent = function (index) {
											var output_length = this.__lines.length;
											while (index < output_length) {
												this.__lines[index].remove_indent();
												index++;
											}
										};

										Output.prototype.trim = function (eat_newlines) {
											eat_newlines = eat_newlines === undefined ? false : eat_newlines;

											this.current_line.trim(this.indent_string, this.baseIndentString);

											while (eat_newlines && this.__lines.length > 1 && this.current_line.is_empty()) {
												this.__lines.pop();
												this.current_line = this.__lines[this.__lines.length - 1];
												this.current_line.trim();
											}

											this.previous_line = this.__lines.length > 1 ? this.__lines[this.__lines.length - 2] : null;
										};

										Output.prototype.just_added_newline = function () {
											return this.current_line.is_empty();
										};

										Output.prototype.just_added_blankline = function () {
											return this.is_empty() || (this.current_line.is_empty() && this.previous_line.is_empty());
										};

										Output.prototype.ensure_empty_line_above = function (starts_with, ends_with) {
											var index = this.__lines.length - 2;
											while (index >= 0) {
												var potentialEmptyLine = this.__lines[index];
												if (potentialEmptyLine.is_empty()) {
													break;
												} else if (
													potentialEmptyLine.item(0).indexOf(starts_with) !== 0 &&
													potentialEmptyLine.item(-1) !== ends_with
												) {
													this.__lines.splice(index + 1, 0, new OutputLine(this));
													this.previous_line = this.__lines[this.__lines.length - 2];
													break;
												}
												index--;
											}
										};

										module.exports.Output = Output;

										/***/
									},
									/* 3 */
									/***/ function (module, exports, __webpack_require__) {
										function Token(type, text, newlines, whitespace_before) {
											this.type = type;
											this.text = text;

											// comments_before are
											// comments that have a new line before them
											// and may or may not have a newline after
											// this is a set of comments before
											this.comments_before = null; /* inline comment*/

											// this.comments_after =  new TokenStream(); // no new line before and newline after
											this.newlines = newlines || 0;
											this.whitespace_before = whitespace_before || '';
											this.parent = null;
											this.next = null;
											this.previous = null;
											this.opened = null;
											this.closed = null;
											this.directives = null;
										}

										module.exports.Token = Token;

										/***/
									},
									/* 4 */
									/***/ function (module, exports, __webpack_require__) {
										// Parts of this section of code is taken from acorn.
										//
										// Acorn was written by Marijn Haverbeke and released under an MIT
										// license. The Unicode regexps (for identifiers and whitespace) were
										// taken from [Esprima](http://esprima.org) by Ariya Hidayat.
										//
										// Git repositories for Acorn are available at
										//
										//     http://marijnhaverbeke.nl/git/acorn
										//     https://github.com/marijnh/acorn.git

										// ## Character categories

										// acorn used char codes to squeeze the last bit of performance out
										// Beautifier is okay without that, so we're using regex
										// permit $ (36) and @ (64). @ is used in ES7 decorators.
										// 65 through 91 are uppercase letters.
										// permit _ (95).
										// 97 through 123 are lowercase letters.
										var baseASCIIidentifierStartChars = '\x24\x40\x41-\x5a\x5f\x61-\x7a';

										// inside an identifier @ is not allowed but 0-9 are.
										var baseASCIIidentifierChars = '\x24\x30-\x39\x41-\x5a\x5f\x61-\x7a';

										// Big ugly regular expressions that match characters in the
										// whitespace, identifier, and identifier-start categories. These
										// are only applied when a character is found to actually have a
										// code point above 128.
										var nonASCIIidentifierStartChars =
											'\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc';
										var nonASCIIidentifierChars =
											'\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u0620-\u0649\u0672-\u06d3\u06e7-\u06e8\u06fb-\u06fc\u0730-\u074a\u0800-\u0814\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u0857\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09d7\u09df-\u09e0\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5f-\u0b60\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2-\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d46-\u0d48\u0d57\u0d62-\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e34-\u0e3a\u0e40-\u0e45\u0e50-\u0e59\u0eb4-\u0eb9\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f41-\u0f47\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1029\u1040-\u1049\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u170e-\u1710\u1720-\u1730\u1740-\u1750\u1772\u1773\u1780-\u17b2\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1920-\u192b\u1930-\u193b\u1951-\u196d\u19b0-\u19c0\u19c8-\u19c9\u19d0-\u19d9\u1a00-\u1a15\u1a20-\u1a53\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b46-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1bb0-\u1bb9\u1be6-\u1bf3\u1c00-\u1c22\u1c40-\u1c49\u1c5b-\u1c7d\u1cd0-\u1cd2\u1d00-\u1dbe\u1e01-\u1f15\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2d81-\u2d96\u2de0-\u2dff\u3021-\u3028\u3099\u309a\ua640-\ua66d\ua674-\ua67d\ua69f\ua6f0-\ua6f1\ua7f8-\ua800\ua806\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8f3-\ua8f7\ua900-\ua909\ua926-\ua92d\ua930-\ua945\ua980-\ua983\ua9b3-\ua9c0\uaa00-\uaa27\uaa40-\uaa41\uaa4c-\uaa4d\uaa50-\uaa59\uaa7b\uaae0-\uaae9\uaaf2-\uaaf3\uabc0-\uabe1\uabec\uabed\uabf0-\uabf9\ufb20-\ufb28\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f';
										//var nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
										//var nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");

										var identifierStart = '[' + baseASCIIidentifierStartChars + nonASCIIidentifierStartChars + ']';
										var identifierChars =
											'[' + baseASCIIidentifierChars + nonASCIIidentifierStartChars + nonASCIIidentifierChars + ']*';

										exports.identifier = new RegExp(identifierStart + identifierChars, 'g');

										// Whether a single character denotes a newline.

										exports.newline = /[\n\r\u2028\u2029]/;

										// Matches a whole line break (where CRLF is considered a single
										// line break). Used to count lines.

										// in javascript, these two differ
										// in python they are the same, different methods are called on them
										exports.lineBreak = new RegExp('\r\n|' + exports.newline.source);
										exports.allLineBreaks = new RegExp(exports.lineBreak.source, 'g');

										/***/
									},
									/* 5 */
									/***/ function (module, exports, __webpack_require__) {
										var BaseOptions = __webpack_require__(6).Options;

										var validPositionValues = ['before-newline', 'after-newline', 'preserve-newline'];

										function Options(options) {
											BaseOptions.call(this, options, 'js');

											// compatibility, re
											var raw_brace_style = this.raw_options.brace_style || null;
											if (raw_brace_style === 'expand-strict') {
												//graceful handling of deprecated option
												this.raw_options.brace_style = 'expand';
											} else if (raw_brace_style === 'collapse-preserve-inline') {
												//graceful handling of deprecated option
												this.raw_options.brace_style = 'collapse,preserve-inline';
											} else if (this.raw_options.braces_on_own_line !== undefined) {
												//graceful handling of deprecated option
												this.raw_options.brace_style = this.raw_options.braces_on_own_line ? 'expand' : 'collapse';
												// } else if (!raw_brace_style) { //Nothing exists to set it
												//   raw_brace_style = "collapse";
											}

											//preserve-inline in delimited string will trigger brace_preserve_inline, everything
											//else is considered a brace_style and the last one only will have an effect

											var brace_style_split = this._get_selection_list('brace_style', [
												'collapse',
												'expand',
												'end-expand',
												'none',
												'preserve-inline'
											]);

											this.brace_preserve_inline = false; //Defaults in case one or other was not specified in meta-option
											this.brace_style = 'collapse';

											for (var bs = 0; bs < brace_style_split.length; bs++) {
												if (brace_style_split[bs] === 'preserve-inline') {
													this.brace_preserve_inline = true;
												} else {
													this.brace_style = brace_style_split[bs];
												}
											}

											this.unindent_chained_methods = this._get_boolean('unindent_chained_methods');
											this.break_chained_methods = this._get_boolean('break_chained_methods');
											this.space_in_paren = this._get_boolean('space_in_paren');
											this.space_in_empty_paren = this._get_boolean('space_in_empty_paren');
											this.jslint_happy = this._get_boolean('jslint_happy');
											this.space_after_anon_function = this._get_boolean('space_after_anon_function');
											this.space_after_named_function = this._get_boolean('space_after_named_function');
											this.keep_array_indentation = this._get_boolean('keep_array_indentation');
											this.space_before_conditional = this._get_boolean('space_before_conditional', true);
											this.unescape_strings = this._get_boolean('unescape_strings');
											this.e4x = this._get_boolean('e4x');
											this.comma_first = this._get_boolean('comma_first');
											this.operator_position = this._get_selection('operator_position', validPositionValues);

											// For testing of beautify preserve:start directive
											this.test_output_raw = this._get_boolean('test_output_raw');

											// force this._options.space_after_anon_function to true if this._options.jslint_happy
											if (this.jslint_happy) {
												this.space_after_anon_function = true;
											}
										}
										Options.prototype = new BaseOptions();

										module.exports.Options = Options;

										/***/
									},
									/* 6 */
									/***/ function (module, exports, __webpack_require__) {
										function Options(options, merge_child_field) {
											this.raw_options = _mergeOpts(options, merge_child_field);

											// Support passing the source text back with no change
											this.disabled = this._get_boolean('disabled');

											this.eol = this._get_characters('eol', 'auto');
											this.end_with_newline = this._get_boolean('end_with_newline');
											this.indent_size = this._get_number('indent_size', 4);
											this.indent_char = this._get_characters('indent_char', ' ');
											this.indent_level = this._get_number('indent_level');

											this.preserve_newlines = this._get_boolean('preserve_newlines', true);
											this.max_preserve_newlines = this._get_number('max_preserve_newlines', 32786);
											if (!this.preserve_newlines) {
												this.max_preserve_newlines = 0;
											}

											this.indent_with_tabs = this._get_boolean('indent_with_tabs');
											if (this.indent_with_tabs) {
												this.indent_char = '\t';
												this.indent_size = 1;
											}

											// Backwards compat with 1.3.x
											this.wrap_line_length = this._get_number('wrap_line_length', this._get_number('max_char'));
										}

										Options.prototype._get_array = function (name, default_value) {
											var option_value = this.raw_options[name];
											var result = default_value || [];
											if (typeof option_value === 'object') {
												if (option_value !== null && typeof option_value.concat === 'function') {
													result = option_value.concat();
												}
											} else if (typeof option_value === 'string') {
												result = option_value.split(/[^a-zA-Z0-9_\/\-]+/);
											}
											return result;
										};

										Options.prototype._get_boolean = function (name, default_value) {
											var option_value = this.raw_options[name];
											var result = option_value === undefined ? !!default_value : !!option_value;
											return result;
										};

										Options.prototype._get_characters = function (name, default_value) {
											var option_value = this.raw_options[name];
											var result = default_value || '';
											if (typeof option_value === 'string') {
												result = option_value.replace(/\\r/, '\r').replace(/\\n/, '\n').replace(/\\t/, '\t');
											}
											return result;
										};

										Options.prototype._get_number = function (name, default_value) {
											var option_value = this.raw_options[name];
											default_value = parseInt(default_value, 10);
											if (isNaN(default_value)) {
												default_value = 0;
											}
											var result = parseInt(option_value, 10);
											if (isNaN(result)) {
												result = default_value;
											}
											return result;
										};

										Options.prototype._get_selection = function (name, selection_list, default_value) {
											var result = this._get_selection_list(name, selection_list, default_value);
											if (result.length !== 1) {
												throw new Error(
													"Invalid Option Value: The option '" +
														name +
														"' can only be one of the following values:\n" +
														selection_list +
														"\nYou passed in: '" +
														this.raw_options[name] +
														"'"
												);
											}

											return result[0];
										};

										Options.prototype._get_selection_list = function (name, selection_list, default_value) {
											if (!selection_list || selection_list.length === 0) {
												throw new Error('Selection list cannot be empty.');
											}

											default_value = default_value || [selection_list[0]];
											if (!this._is_valid_selection(default_value, selection_list)) {
												throw new Error('Invalid Default Value!');
											}

											var result = this._get_array(name, default_value);
											if (!this._is_valid_selection(result, selection_list)) {
												throw new Error(
													"Invalid Option Value: The option '" +
														name +
														"' can contain only the following values:\n" +
														selection_list +
														"\nYou passed in: '" +
														this.raw_options[name] +
														"'"
												);
											}

											return result;
										};

										Options.prototype._is_valid_selection = function (result, selection_list) {
											return (
												result.length &&
												selection_list.length &&
												!result.some(function (item) {
													return selection_list.indexOf(item) === -1;
												})
											);
										};

										// merges child options up with the parent options object
										// Example: obj = {a: 1, b: {a: 2}}
										//          mergeOpts(obj, 'b')
										//
										//          Returns: {a: 2}
										function _mergeOpts(allOptions, childFieldName) {
											var finalOpts = {};
											allOptions = _normalizeOpts(allOptions);
											var name;

											for (name in allOptions) {
												if (name !== childFieldName) {
													finalOpts[name] = allOptions[name];
												}
											}

											//merge in the per type settings for the childFieldName
											if (childFieldName && allOptions[childFieldName]) {
												for (name in allOptions[childFieldName]) {
													finalOpts[name] = allOptions[childFieldName][name];
												}
											}
											return finalOpts;
										}

										function _normalizeOpts(options) {
											var convertedOpts = {};
											var key;

											for (key in options) {
												var newKey = key.replace(/-/g, '_');
												convertedOpts[newKey] = options[key];
											}
											return convertedOpts;
										}

										module.exports.Options = Options;
										module.exports.normalizeOpts = _normalizeOpts;
										module.exports.mergeOpts = _mergeOpts;

										/***/
									},
									/* 7 */
									/***/ function (module, exports, __webpack_require__) {
										var InputScanner = __webpack_require__(8).InputScanner;
										var BaseTokenizer = __webpack_require__(9).Tokenizer;
										var BASETOKEN = __webpack_require__(9).TOKEN;
										var Directives = __webpack_require__(11).Directives;
										var acorn = __webpack_require__(4);

										function in_array(what, arr) {
											return arr.indexOf(what) !== -1;
										}

										var TOKEN = {
											START_EXPR: 'TK_START_EXPR',
											END_EXPR: 'TK_END_EXPR',
											START_BLOCK: 'TK_START_BLOCK',
											END_BLOCK: 'TK_END_BLOCK',
											WORD: 'TK_WORD',
											RESERVED: 'TK_RESERVED',
											SEMICOLON: 'TK_SEMICOLON',
											STRING: 'TK_STRING',
											EQUALS: 'TK_EQUALS',
											OPERATOR: 'TK_OPERATOR',
											COMMA: 'TK_COMMA',
											BLOCK_COMMENT: 'TK_BLOCK_COMMENT',
											COMMENT: 'TK_COMMENT',
											DOT: 'TK_DOT',
											UNKNOWN: 'TK_UNKNOWN',
											START: BASETOKEN.START,
											RAW: BASETOKEN.RAW,
											EOF: BASETOKEN.EOF
										};

										var directives_core = new Directives(/\/\*/, /\*\//);

										var number_pattern =
											/0[xX][0123456789abcdefABCDEF]*|0[oO][01234567]*|0[bB][01]*|\d+n|(?:\.\d+|\d+\.?\d*)(?:[eE][+-]?\d+)?/g;

										var digit = /[0-9]/;

										// Dot "." must be distinguished from "..." and decimal
										var dot_pattern = /[^\d\.]/;

										var positionable_operators = (
											'>>> === !== ' +
											'<< && >= ** != == <= >> || ' +
											'< / - + > : & % ? ^ | *'
										).split(' ');

										// IMPORTANT: this must be sorted longest to shortest or tokenizing many not work.
										// Also, you must update possitionable operators separately from punct
										var punct =
											'>>>= ' +
											'... >>= <<= === >>> !== **= ' +
											'=> ^= :: /= << <= == && -= >= >> != -- += ** || ++ %= &= *= |= ' +
											'= ! ? > < : / ^ - + * & % ~ |';

										punct = punct.replace(/[-[\]{}()*+?.,\\^$|#]/g, '\\$&');
										punct = punct.replace(/ /g, '|');

										var punct_pattern = new RegExp(punct, 'g');
										var shebang_pattern = /#![^\n\r\u2028\u2029]*(?:\r\n|[\n\r\u2028\u2029])?/g;
										var include_pattern = /#include[^\n\r\u2028\u2029]*(?:\r\n|[\n\r\u2028\u2029])?/g;

										// words which should always start on new line.
										var line_starters =
											'continue,try,throw,return,var,let,const,if,switch,case,default,for,while,break,function,import,export'.split(
												','
											);
										var reserved_words = line_starters.concat([
											'do',
											'in',
											'of',
											'else',
											'get',
											'set',
											'new',
											'catch',
											'finally',
											'typeof',
											'yield',
											'async',
											'await',
											'from',
											'as'
										]);
										var reserved_word_pattern = new RegExp('^(?:' + reserved_words.join('|') + ')$');

										//  /* ... */ comment ends with nearest */ or end of file
										var block_comment_pattern = /\/\*(?:[\s\S]*?)((?:\*\/)|$)/g;

										// comment ends just before nearest linefeed or end of file
										var comment_pattern = /\/\/(?:[^\n\r\u2028\u2029]*)/g;

										var template_pattern = /(?:(?:<\?php|<\?=)[\s\S]*?\?>)|(?:<%[\s\S]*?%>)/g;

										var in_html_comment;

										var Tokenizer = function (input_string, options) {
											BaseTokenizer.call(this, input_string, options);

											this._whitespace_pattern =
												/[\n\r\u2028\u2029\t\u000B\u00A0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff ]+/g;
											this._newline_pattern = /([^\n\r\u2028\u2029]*)(\r\n|[\n\r\u2028\u2029])?/g;
										};
										Tokenizer.prototype = new BaseTokenizer();

										Tokenizer.prototype._is_comment = function (current_token) {
											return (
												current_token.type === TOKEN.COMMENT ||
												current_token.type === TOKEN.BLOCK_COMMENT ||
												current_token.type === TOKEN.UNKNOWN
											);
										};

										Tokenizer.prototype._is_opening = function (current_token) {
											return current_token.type === TOKEN.START_BLOCK || current_token.type === TOKEN.START_EXPR;
										};

										Tokenizer.prototype._is_closing = function (current_token, open_token) {
											return (
												(current_token.type === TOKEN.END_BLOCK || current_token.type === TOKEN.END_EXPR) &&
												open_token &&
												((current_token.text === ']' && open_token.text === '[') ||
													(current_token.text === ')' && open_token.text === '(') ||
													(current_token.text === '}' && open_token.text === '{'))
											);
										};

										Tokenizer.prototype._reset = function () {
											in_html_comment = false;
										};

										Tokenizer.prototype._get_next_token = function (previous_token, open_token) {
											this._readWhitespace();
											var token = null;
											var c = this._input.peek();

											token = token || this._read_singles(c);
											token = token || this._read_word(previous_token);
											token = token || this._read_comment(c);
											token = token || this._read_string(c);
											token = token || this._read_regexp(c, previous_token);
											token = token || this._read_xml(c, previous_token);
											token = token || this._read_non_javascript(c);
											token = token || this._read_punctuation();
											token = token || this._create_token(TOKEN.UNKNOWN, this._input.next());

											return token;
										};

										Tokenizer.prototype._read_word = function (previous_token) {
											var resulting_string;
											resulting_string = this._input.read(acorn.identifier);
											if (resulting_string !== '') {
												if (
													!(
														previous_token.type === TOKEN.DOT ||
														(previous_token.type === TOKEN.RESERVED &&
															(previous_token.text === 'set' || previous_token.text === 'get'))
													) &&
													reserved_word_pattern.test(resulting_string)
												) {
													if (resulting_string === 'in' || resulting_string === 'of') {
														// hack for 'in' and 'of' operators
														return this._create_token(TOKEN.OPERATOR, resulting_string);
													}
													return this._create_token(TOKEN.RESERVED, resulting_string);
												}

												return this._create_token(TOKEN.WORD, resulting_string);
											}

											resulting_string = this._input.read(number_pattern);
											if (resulting_string !== '') {
												return this._create_token(TOKEN.WORD, resulting_string);
											}
										};

										Tokenizer.prototype._read_singles = function (c) {
											var token = null;
											if (c === null) {
												token = this._create_token(TOKEN.EOF, '');
											} else if (c === '(' || c === '[') {
												token = this._create_token(TOKEN.START_EXPR, c);
											} else if (c === ')' || c === ']') {
												token = this._create_token(TOKEN.END_EXPR, c);
											} else if (c === '{') {
												token = this._create_token(TOKEN.START_BLOCK, c);
											} else if (c === '}') {
												token = this._create_token(TOKEN.END_BLOCK, c);
											} else if (c === ';') {
												token = this._create_token(TOKEN.SEMICOLON, c);
											} else if (c === '.' && dot_pattern.test(this._input.peek(1))) {
												token = this._create_token(TOKEN.DOT, c);
											} else if (c === ',') {
												token = this._create_token(TOKEN.COMMA, c);
											}

											if (token) {
												this._input.next();
											}
											return token;
										};

										Tokenizer.prototype._read_punctuation = function () {
											var resulting_string = this._input.read(punct_pattern);

											if (resulting_string !== '') {
												if (resulting_string === '=') {
													return this._create_token(TOKEN.EQUALS, resulting_string);
												} else {
													return this._create_token(TOKEN.OPERATOR, resulting_string);
												}
											}
										};

										Tokenizer.prototype._read_non_javascript = function (c) {
											var resulting_string = '';

											if (c === '#') {
												if (this._is_first_token()) {
													resulting_string = this._input.read(shebang_pattern);

													if (resulting_string) {
														return this._create_token(TOKEN.UNKNOWN, resulting_string.trim() + '\n');
													}
												}

												// handles extendscript #includes
												resulting_string = this._input.read(include_pattern);

												if (resulting_string) {
													return this._create_token(TOKEN.UNKNOWN, resulting_string.trim() + '\n');
												}

												c = this._input.next();

												// Spidermonkey-specific sharp variables for circular references. Considered obsolete.
												var sharp = '#';
												if (this._input.hasNext() && this._input.testChar(digit)) {
													do {
														c = this._input.next();
														sharp += c;
													} while (this._input.hasNext() && c !== '#' && c !== '=');
													if (c === '#');
													else if (this._input.peek() === '[' && this._input.peek(1) === ']') {
														sharp += '[]';
														this._input.next();
														this._input.next();
													} else if (this._input.peek() === '{' && this._input.peek(1) === '}') {
														sharp += '{}';
														this._input.next();
														this._input.next();
													}
													return this._create_token(TOKEN.WORD, sharp);
												}

												this._input.back();
											} else if (c === '<') {
												if (this._input.peek(1) === '?' || this._input.peek(1) === '%') {
													resulting_string = this._input.read(template_pattern);
													if (resulting_string) {
														resulting_string = resulting_string.replace(acorn.allLineBreaks, '\n');
														return this._create_token(TOKEN.STRING, resulting_string);
													}
												} else if (this._input.match(/<\!--/g)) {
													c = '<!--';
													while (this._input.hasNext() && !this._input.testChar(acorn.newline)) {
														c += this._input.next();
													}
													in_html_comment = true;
													return this._create_token(TOKEN.COMMENT, c);
												}
											} else if (c === '-' && in_html_comment && this._input.match(/-->/g)) {
												in_html_comment = false;
												return this._create_token(TOKEN.COMMENT, '-->');
											}

											return null;
										};

										Tokenizer.prototype._read_comment = function (c) {
											var token = null;
											if (c === '/') {
												var comment = '';
												if (this._input.peek(1) === '*') {
													// peek for comment /* ... */
													comment = this._input.read(block_comment_pattern);
													var directives = directives_core.get_directives(comment);
													if (directives && directives.ignore === 'start') {
														comment += directives_core.readIgnored(this._input);
													}
													comment = comment.replace(acorn.allLineBreaks, '\n');
													token = this._create_token(TOKEN.BLOCK_COMMENT, comment);
													token.directives = directives;
												} else if (this._input.peek(1) === '/') {
													// peek for comment // ...
													comment = this._input.read(comment_pattern);
													token = this._create_token(TOKEN.COMMENT, comment);
												}
											}
											return token;
										};

										Tokenizer.prototype._read_string = function (c) {
											if (c === '`' || c === "'" || c === '"') {
												var resulting_string = this._input.next();
												this.has_char_escapes = false;

												if (c === '`') {
													resulting_string += this._read_string_recursive('`', true, '${');
												} else {
													resulting_string += this._read_string_recursive(c);
												}

												if (this.has_char_escapes && this._options.unescape_strings) {
													resulting_string = unescape_string(resulting_string);
												}
												if (this._input.peek() === c) {
													resulting_string += this._input.next();
												}

												return this._create_token(TOKEN.STRING, resulting_string);
											}

											return null;
										};

										Tokenizer.prototype._allow_regexp_or_xml = function (previous_token) {
											// regex and xml can only appear in specific locations during parsing
											return (
												(previous_token.type === TOKEN.RESERVED &&
													in_array(previous_token.text, [
														'return',
														'case',
														'throw',
														'else',
														'do',
														'typeof',
														'yield'
													])) ||
												(previous_token.type === TOKEN.END_EXPR &&
													previous_token.text === ')' &&
													previous_token.opened.previous.type === TOKEN.RESERVED &&
													in_array(previous_token.opened.previous.text, ['if', 'while', 'for'])) ||
												in_array(previous_token.type, [
													TOKEN.COMMENT,
													TOKEN.START_EXPR,
													TOKEN.START_BLOCK,
													TOKEN.START,
													TOKEN.END_BLOCK,
													TOKEN.OPERATOR,
													TOKEN.EQUALS,
													TOKEN.EOF,
													TOKEN.SEMICOLON,
													TOKEN.COMMA
												])
											);
										};

										Tokenizer.prototype._read_regexp = function (c, previous_token) {
											if (c === '/' && this._allow_regexp_or_xml(previous_token)) {
												// handle regexp
												//
												var resulting_string = this._input.next();
												var esc = false;

												var in_char_class = false;
												while (
													this._input.hasNext() &&
													(esc || in_char_class || this._input.peek() !== c) &&
													!this._input.testChar(acorn.newline)
												) {
													resulting_string += this._input.peek();
													if (!esc) {
														esc = this._input.peek() === '\\';
														if (this._input.peek() === '[') {
															in_char_class = true;
														} else if (this._input.peek() === ']') {
															in_char_class = false;
														}
													} else {
														esc = false;
													}
													this._input.next();
												}

												if (this._input.peek() === c) {
													resulting_string += this._input.next();

													// regexps may have modifiers /regexp/MOD , so fetch those, too
													// Only [gim] are valid, but if the user puts in garbage, do what we can to take it.
													resulting_string += this._input.read(acorn.identifier);
												}
												return this._create_token(TOKEN.STRING, resulting_string);
											}
											return null;
										};

										var startXmlRegExp =
											/<()([-a-zA-Z:0-9_.]+|{[\s\S]+?}|!\[CDATA\[[\s\S]*?\]\])(\s+{[\s\S]+?}|\s+[-a-zA-Z:0-9_.]+|\s+[-a-zA-Z:0-9_.]+\s*=\s*('[^']*'|"[^"]*"|{[\s\S]+?}))*\s*(\/?)\s*>/g;
										var xmlRegExp =
											/[\s\S]*?<(\/?)([-a-zA-Z:0-9_.]+|{[\s\S]+?}|!\[CDATA\[[\s\S]*?\]\])(\s+{[\s\S]+?}|\s+[-a-zA-Z:0-9_.]+|\s+[-a-zA-Z:0-9_.]+\s*=\s*('[^']*'|"[^"]*"|{[\s\S]+?}))*\s*(\/?)\s*>/g;

										Tokenizer.prototype._read_xml = function (c, previous_token) {
											if (
												this._options.e4x &&
												c === '<' &&
												this._input.test(startXmlRegExp) &&
												this._allow_regexp_or_xml(previous_token)
											) {
												// handle e4x xml literals
												//
												var xmlStr = '';
												var match = this._input.match(startXmlRegExp);
												if (match) {
													// Trim root tag to attempt to
													var rootTag = match[2].replace(/^{\s+/, '{').replace(/\s+}$/, '}');
													var isCurlyRoot = rootTag.indexOf('{') === 0;
													var depth = 0;
													while (match) {
														var isEndTag = !!match[1];
														var tagName = match[2];
														var isSingletonTag = !!match[match.length - 1] || tagName.slice(0, 8) === '![CDATA[';
														if (
															!isSingletonTag &&
															(tagName === rootTag ||
																(isCurlyRoot && tagName.replace(/^{\s+/, '{').replace(/\s+}$/, '}')))
														) {
															if (isEndTag) {
																--depth;
															} else {
																++depth;
															}
														}
														xmlStr += match[0];
														if (depth <= 0) {
															break;
														}
														match = this._input.match(xmlRegExp);
													}
													// if we didn't close correctly, keep unformatted.
													if (!match) {
														xmlStr += this._input.match(/[\s\S]*/g)[0];
													}
													xmlStr = xmlStr.replace(acorn.allLineBreaks, '\n');
													return this._create_token(TOKEN.STRING, xmlStr);
												}
											}

											return null;
										};

										function unescape_string(s) {
											// You think that a regex would work for this
											// return s.replace(/\\x([0-9a-f]{2})/gi, function(match, val) {
											//         return String.fromCharCode(parseInt(val, 16));
											//     })
											// However, dealing with '\xff', '\\xff', '\\\xff' makes this more fun.
											var out = '',
												escaped = 0;

											var input_scan = new InputScanner(s);
											var matched = null;

											while (input_scan.hasNext()) {
												// Keep any whitespace, non-slash characters
												// also keep slash pairs.
												matched = input_scan.match(/([\s]|[^\\]|\\\\)+/g);

												if (matched) {
													out += matched[0];
												}

												if (input_scan.peek() === '\\') {
													input_scan.next();
													if (input_scan.peek() === 'x') {
														matched = input_scan.match(/x([0-9A-Fa-f]{2})/g);
													} else if (input_scan.peek() === 'u') {
														matched = input_scan.match(/u([0-9A-Fa-f]{4})/g);
													} else {
														out += '\\';
														if (input_scan.hasNext()) {
															out += input_scan.next();
														}
														continue;
													}

													// If there's some error decoding, return the original string
													if (!matched) {
														return s;
													}

													escaped = parseInt(matched[1], 16);

													if (escaped > 0x7e && escaped <= 0xff && matched[0].indexOf('x') === 0) {
														// we bail out on \x7f..\xff,
														// leaving whole string escaped,
														// as it's probably completely binary
														return s;
													} else if (escaped >= 0x00 && escaped < 0x20) {
														// leave 0x00...0x1f escaped
														out += '\\' + matched[0];
														continue;
													} else if (escaped === 0x22 || escaped === 0x27 || escaped === 0x5c) {
														// single-quote, apostrophe, backslash - escape these
														out += '\\' + String.fromCharCode(escaped);
													} else {
														out += String.fromCharCode(escaped);
													}
												}
											}

											return out;
										}

										// handle string
										//
										Tokenizer.prototype._read_string_recursive = function (
											delimiter,
											allow_unescaped_newlines,
											start_sub
										) {
											// Template strings can travers lines without escape characters.
											// Other strings cannot
											var current_char;
											var resulting_string = '';
											var esc = false;
											while (this._input.hasNext()) {
												current_char = this._input.peek();
												if (
													!(
														esc ||
														(current_char !== delimiter &&
															(allow_unescaped_newlines || !acorn.newline.test(current_char)))
													)
												) {
													break;
												}

												// Handle \r\n linebreaks after escapes or in template strings
												if ((esc || allow_unescaped_newlines) && acorn.newline.test(current_char)) {
													if (current_char === '\r' && this._input.peek(1) === '\n') {
														this._input.next();
														current_char = this._input.peek();
													}
													resulting_string += '\n';
												} else {
													resulting_string += current_char;
												}

												if (esc) {
													if (current_char === 'x' || current_char === 'u') {
														this.has_char_escapes = true;
													}
													esc = false;
												} else {
													esc = current_char === '\\';
												}

												this._input.next();

												if (
													start_sub &&
													resulting_string.indexOf(start_sub, resulting_string.length - start_sub.length) !== -1
												) {
													if (delimiter === '`') {
														resulting_string += this._read_string_recursive('}', allow_unescaped_newlines, '`');
													} else {
														resulting_string += this._read_string_recursive('`', allow_unescaped_newlines, '${');
													}

													if (this._input.hasNext()) {
														resulting_string += this._input.next();
													}
												}
											}

											return resulting_string;
										};

										module.exports.Tokenizer = Tokenizer;
										module.exports.TOKEN = TOKEN;
										module.exports.positionable_operators = positionable_operators.slice();
										module.exports.line_starters = line_starters.slice();

										/***/
									},
									/* 8 */
									/***/ function (module, exports, __webpack_require__) {
										function InputScanner(input_string) {
											this.__input = input_string || '';
											this.__input_length = this.__input.length;
											this.__position = 0;
										}

										InputScanner.prototype.restart = function () {
											this.__position = 0;
										};

										InputScanner.prototype.back = function () {
											if (this.__position > 0) {
												this.__position -= 1;
											}
										};

										InputScanner.prototype.hasNext = function () {
											return this.__position < this.__input_length;
										};

										InputScanner.prototype.next = function () {
											var val = null;
											if (this.hasNext()) {
												val = this.__input.charAt(this.__position);
												this.__position += 1;
											}
											return val;
										};

										InputScanner.prototype.peek = function (index) {
											var val = null;
											index = index || 0;
											index += this.__position;
											if (index >= 0 && index < this.__input_length) {
												val = this.__input.charAt(index);
											}
											return val;
										};

										InputScanner.prototype.test = function (pattern, index) {
											index = index || 0;
											index += this.__position;
											pattern.lastIndex = index;

											if (index >= 0 && index < this.__input_length) {
												var pattern_match = pattern.exec(this.__input);
												return pattern_match && pattern_match.index === index;
											} else {
												return false;
											}
										};

										InputScanner.prototype.testChar = function (pattern, index) {
											// test one character regex match
											var val = this.peek(index);
											return val !== null && pattern.test(val);
										};

										InputScanner.prototype.match = function (pattern) {
											pattern.lastIndex = this.__position;
											var pattern_match = pattern.exec(this.__input);
											if (pattern_match && pattern_match.index === this.__position) {
												this.__position += pattern_match[0].length;
											} else {
												pattern_match = null;
											}
											return pattern_match;
										};

										InputScanner.prototype.read = function (pattern) {
											var val = '';
											var match = this.match(pattern);
											if (match) {
												val = match[0];
											}
											return val;
										};

										InputScanner.prototype.readUntil = function (pattern, include_match) {
											var val = '';
											var match_index = this.__position;
											pattern.lastIndex = this.__position;
											var pattern_match = pattern.exec(this.__input);
											if (pattern_match) {
												if (include_match) {
													match_index = pattern_match.index + pattern_match[0].length;
												} else {
													match_index = pattern_match.index;
												}
											} else {
												match_index = this.__input_length;
											}

											val = this.__input.substring(this.__position, match_index);
											this.__position = match_index;
											return val;
										};

										InputScanner.prototype.readUntilAfter = function (pattern) {
											return this.readUntil(pattern, true);
										};

										/* css beautifier legacy helpers */
										InputScanner.prototype.peekUntilAfter = function (pattern) {
											var start = this.__position;
											var val = this.readUntilAfter(pattern);
											this.__position = start;
											return val;
										};

										InputScanner.prototype.lookBack = function (testVal) {
											var start = this.__position - 1;
											return (
												start >= testVal.length &&
												this.__input.substring(start - testVal.length, start).toLowerCase() === testVal
											);
										};

										module.exports.InputScanner = InputScanner;

										/***/
									},
									/* 9 */
									/***/ function (module, exports, __webpack_require__) {
										var InputScanner = __webpack_require__(8).InputScanner;
										var Token = __webpack_require__(3).Token;
										var TokenStream = __webpack_require__(10).TokenStream;

										var TOKEN = {
											START: 'TK_START',
											RAW: 'TK_RAW',
											EOF: 'TK_EOF'
										};

										var Tokenizer = function (input_string, options) {
											this._input = new InputScanner(input_string);
											this._options = options || {};
											this.__tokens = null;
											this.__newline_count = 0;
											this.__whitespace_before_token = '';

											this._whitespace_pattern = /[\n\r\t ]+/g;
											this._newline_pattern = /([^\n\r]*)(\r\n|[\n\r])?/g;
										};

										Tokenizer.prototype.tokenize = function () {
											this._input.restart();
											this.__tokens = new TokenStream();

											this._reset();

											var current;
											var previous = new Token(TOKEN.START, '');
											var open_token = null;
											var open_stack = [];
											var comments = new TokenStream();

											while (previous.type !== TOKEN.EOF) {
												current = this._get_next_token(previous, open_token);
												while (this._is_comment(current)) {
													comments.add(current);
													current = this._get_next_token(previous, open_token);
												}

												if (!comments.isEmpty()) {
													current.comments_before = comments;
													comments = new TokenStream();
												}

												current.parent = open_token;

												if (this._is_opening(current)) {
													open_stack.push(open_token);
													open_token = current;
												} else if (open_token && this._is_closing(current, open_token)) {
													current.opened = open_token;
													open_token.closed = current;
													open_token = open_stack.pop();
													current.parent = open_token;
												}

												current.previous = previous;
												previous.next = current;

												this.__tokens.add(current);
												previous = current;
											}

											return this.__tokens;
										};

										Tokenizer.prototype._is_first_token = function () {
											return this.__tokens.isEmpty();
										};

										Tokenizer.prototype._reset = function () {};

										Tokenizer.prototype._get_next_token = function (previous_token, open_token) {
											this._readWhitespace();
											var resulting_string = this._input.read(/.+/g);
											if (resulting_string) {
												return this._create_token(TOKEN.RAW, resulting_string);
											} else {
												return this._create_token(TOKEN.EOF, '');
											}
										};

										Tokenizer.prototype._is_comment = function (current_token) {
											return false;
										};

										Tokenizer.prototype._is_opening = function (current_token) {
											return false;
										};

										Tokenizer.prototype._is_closing = function (current_token, open_token) {
											return false;
										};

										Tokenizer.prototype._create_token = function (type, text) {
											var token = new Token(type, text, this.__newline_count, this.__whitespace_before_token);
											this.__newline_count = 0;
											this.__whitespace_before_token = '';
											return token;
										};

										Tokenizer.prototype._readWhitespace = function () {
											var resulting_string = this._input.read(this._whitespace_pattern);
											if (resulting_string === ' ') {
												this.__whitespace_before_token = resulting_string;
											} else if (resulting_string !== '') {
												this._newline_pattern.lastIndex = 0;
												var nextMatch = this._newline_pattern.exec(resulting_string);
												while (nextMatch[2]) {
													this.__newline_count += 1;
													nextMatch = this._newline_pattern.exec(resulting_string);
												}
												this.__whitespace_before_token = nextMatch[1];
											}
										};

										module.exports.Tokenizer = Tokenizer;
										module.exports.TOKEN = TOKEN;

										/***/
									},
									/* 10 */
									/***/ function (module, exports, __webpack_require__) {
										function TokenStream(parent_token) {
											// private
											this.__tokens = [];
											this.__tokens_length = this.__tokens.length;
											this.__position = 0;
											this.__parent_token = parent_token;
										}

										TokenStream.prototype.restart = function () {
											this.__position = 0;
										};

										TokenStream.prototype.isEmpty = function () {
											return this.__tokens_length === 0;
										};

										TokenStream.prototype.hasNext = function () {
											return this.__position < this.__tokens_length;
										};

										TokenStream.prototype.next = function () {
											var val = null;
											if (this.hasNext()) {
												val = this.__tokens[this.__position];
												this.__position += 1;
											}
											return val;
										};

										TokenStream.prototype.peek = function (index) {
											var val = null;
											index = index || 0;
											index += this.__position;
											if (index >= 0 && index < this.__tokens_length) {
												val = this.__tokens[index];
											}
											return val;
										};

										TokenStream.prototype.add = function (token) {
											if (this.__parent_token) {
												token.parent = this.__parent_token;
											}
											this.__tokens.push(token);
											this.__tokens_length += 1;
										};

										module.exports.TokenStream = TokenStream;

										/***/
									},
									/* 11 */
									/***/ function (module, exports, __webpack_require__) {
										function Directives(start_block_pattern, end_block_pattern) {
											start_block_pattern =
												typeof start_block_pattern === 'string' ? start_block_pattern : start_block_pattern.source;
											end_block_pattern =
												typeof end_block_pattern === 'string' ? end_block_pattern : end_block_pattern.source;
											this.__directives_block_pattern = new RegExp(
												start_block_pattern + / beautify( \w+[:]\w+)+ /.source + end_block_pattern,
												'g'
											);
											this.__directive_pattern = / (\w+)[:](\w+)/g;

											this.__directives_end_ignore_pattern = new RegExp(
												'(?:[\\s\\S]*?)((?:' +
													start_block_pattern +
													/\sbeautify\signore:end\s/.source +
													end_block_pattern +
													')|$)',
												'g'
											);
										}

										Directives.prototype.get_directives = function (text) {
											if (!text.match(this.__directives_block_pattern)) {
												return null;
											}

											var directives = {};
											this.__directive_pattern.lastIndex = 0;
											var directive_match = this.__directive_pattern.exec(text);

											while (directive_match) {
												directives[directive_match[1]] = directive_match[2];
												directive_match = this.__directive_pattern.exec(text);
											}

											return directives;
										};

										Directives.prototype.readIgnored = function (input) {
											return input.read(this.__directives_end_ignore_pattern);
										};

										module.exports.Directives = Directives;

										/***/
									}
									/******/
								]
							);
							var js_beautify = legacy_beautify_js;
							/* Footer */
							{
								// Add support for CommonJS. Just put this file somewhere on your require.paths
								// and you will be able to `var js_beautify = require("beautify").js_beautify`.
								exports.js_beautify = js_beautify;
							}
						})();
					});

					unwrapExports(beautify);
					var beautify_1 = beautify.js_beautify;

					/*
					 * Generated by PEG.js 0.10.0.
					 *
					 * http://pegjs.org/
					 */

					var javaAST = (function () {
						function peg$subclass(child, parent) {
							function ctor() {
								this.constructor = child;
							}
							ctor.prototype = parent.prototype;
							child.prototype = new ctor();
						}

						function peg$SyntaxError(message, expected, found, location) {
							this.message = message;
							this.expected = expected;
							this.found = found;
							this.location = location;
							this.name = 'SyntaxError';

							if (typeof Error.captureStackTrace === 'function') {
								Error.captureStackTrace(this, peg$SyntaxError);
							}
						}

						peg$subclass(peg$SyntaxError, Error);

						peg$SyntaxError.buildMessage = function (expected, found) {
							var DESCRIBE_EXPECTATION_FNS = {
								literal: function (expectation) {
									return '"' + literalEscape(expectation.text) + '"';
								},

								class: function (expectation) {
									var escapedParts = '',
										i;

									for (i = 0; i < expectation.parts.length; i++) {
										escapedParts +=
											expectation.parts[i] instanceof Array
												? classEscape(expectation.parts[i][0]) + '-' + classEscape(expectation.parts[i][1])
												: classEscape(expectation.parts[i]);
									}

									return '[' + (expectation.inverted ? '^' : '') + escapedParts + ']';
								},

								any: function (expectation) {
									return 'any character';
								},

								end: function (expectation) {
									return 'end of input';
								},

								other: function (expectation) {
									return expectation.description;
								}
							};

							function hex(ch) {
								return ch.charCodeAt(0).toString(16).toUpperCase();
							}

							function literalEscape(s) {
								return s
									.replace(/\\/g, '\\\\')
									.replace(/"/g, '\\"')
									.replace(/\0/g, '\\0')
									.replace(/\t/g, '\\t')
									.replace(/\n/g, '\\n')
									.replace(/\r/g, '\\r')
									.replace(/[\x00-\x0F]/g, function (ch) {
										return '\\x0' + hex(ch);
									})
									.replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) {
										return '\\x' + hex(ch);
									});
							}

							function classEscape(s) {
								return s
									.replace(/\\/g, '\\\\')
									.replace(/\]/g, '\\]')
									.replace(/\^/g, '\\^')
									.replace(/-/g, '\\-')
									.replace(/\0/g, '\\0')
									.replace(/\t/g, '\\t')
									.replace(/\n/g, '\\n')
									.replace(/\r/g, '\\r')
									.replace(/[\x00-\x0F]/g, function (ch) {
										return '\\x0' + hex(ch);
									})
									.replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) {
										return '\\x' + hex(ch);
									});
							}

							function describeExpectation(expectation) {
								return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
							}

							function describeExpected(expected) {
								var descriptions = new Array(expected.length),
									i,
									j;

								for (i = 0; i < expected.length; i++) {
									descriptions[i] = describeExpectation(expected[i]);
								}

								descriptions.sort();

								if (descriptions.length > 0) {
									for (i = 1, j = 1; i < descriptions.length; i++) {
										if (descriptions[i - 1] !== descriptions[i]) {
											descriptions[j] = descriptions[i];
											j++;
										}
									}
									descriptions.length = j;
								}

								switch (descriptions.length) {
									case 1:
										return descriptions[0];

									case 2:
										return descriptions[0] + ' or ' + descriptions[1];

									default:
										return descriptions.slice(0, -1).join(', ') + ', or ' + descriptions[descriptions.length - 1];
								}
							}

							function describeFound(found) {
								return found ? '"' + literalEscape(found) + '"' : 'end of input';
							}

							return 'Expected ' + describeExpected(expected) + ' but ' + describeFound(found) + ' found.';
						};

						function peg$parse(input, options) {
							options = options !== void 0 ? options : {};

							var peg$FAILED = {},
								peg$startRuleFunctions = { CompilationUnit: peg$parseCompilationUnit },
								peg$startRuleFunction = peg$parseCompilationUnit,
								peg$c0 = function (pack, imports, types) {
									return {
										node: 'CompilationUnit',
										types: skipNulls(types),
										package: pack,
										imports: skipNulls(imports)
									};
								},
								peg$c1 = function (annot, name) {
									return {
										node: 'PackageDeclaration',
										name: name,
										annotations: annot
									};
								},
								peg$c2 = function (stat, name, asterisk) {
									return {
										node: 'ImportDeclaration',
										name: name,
										static: !!stat,
										onDemand: !!extractOptional(asterisk, 1)
									};
								},
								peg$c3 = function () {
									return null;
								},
								peg$c4 = function (modifiers, type) {
									return mergeProps(type, { modifiers: modifiers });
								},
								peg$c5 = function (id, gen, ext, impl, body) {
									return {
										node: 'TypeDeclaration',
										name: id,
										superInterfaceTypes: extractOptionalList(impl, 1),
										superclassType: extractOptional(ext, 1),
										bodyDeclarations: body,
										typeParameters: optionalList(gen),
										interface: false
									};
								},
								peg$c6 = function (decls) {
									return skipNulls(decls);
								},
								peg$c7 = function (modifier, body) {
									return {
										node: 'Initializer',
										body: body,
										modifiers: modifier === null ? [] : [makeModifier('static')]
									};
								},
								peg$c8 = function (modifiers, member) {
									return mergeProps(member, { modifiers: modifiers });
								},
								peg$c9 = function (params, rest) {
									return mergeProps(rest, {
										node: 'MethodDeclaration',
										typeParameters: params
									});
								},
								peg$c10 = function (type, id, rest) {
									return mergeProps(rest, {
										node: 'MethodDeclaration',
										returnType2: type,
										name: id,
										typeParameters: []
									});
								},
								peg$c11 = function (type, decls) {
									return {
										node: 'FieldDeclaration',
										fragments: decls,
										type: type
									};
								},
								peg$c12 = function (id, rest) {
									return mergeProps(rest, {
										node: 'MethodDeclaration',
										returnType2: makePrimitive('void'),
										name: id,
										constructor: false
									});
								},
								peg$c13 = function (id, rest) {
									return mergeProps(rest, {
										node: 'MethodDeclaration',
										name: id,
										typeParameters: []
									});
								},
								peg$c14 = function () {
									return makePrimitive('void');
								},
								peg$c15 = function (type, id, rest) {
									return mergeProps(rest, {
										returnType2: type,
										name: id
									});
								},
								peg$c16 = function (id, rest) {
									return mergeProps(rest, { name: id });
								},
								peg$c17 = function (params, dims, throws) {
									return null;
								},
								peg$c18 = function (params, dims, throws, body) {
									return {
										parameters: params,
										thrownExceptions: extractThrowsClassType(extractOptionalList(throws, 1)),
										extraDimensions: dims.length,
										body: body,
										constructor: false
									};
								},
								peg$c19 = function (params, throws) {
									return null;
								},
								peg$c20 = function (params, throws, body) {
									return {
										parameters: params,
										thrownExceptions: extractThrowsClassType(extractOptionalList(throws, 1)),
										body: body,
										extraDimensions: 0,
										typeParameters: []
									};
								},
								peg$c21 = function (params, throws, body) {
									return {
										parameters: params,
										thrownExceptions: extractThrowsClassType(extractOptionalList(throws, 1)),
										body: body,
										returnType2: null,
										constructor: true,
										extraDimensions: 0
									};
								},
								peg$c22 = function (id, gen, ext, body) {
									return {
										node: 'TypeDeclaration',
										name: id,
										superInterfaceTypes: extractOptionalList(ext, 1),
										superclassType: null,
										bodyDeclarations: body,
										typeParameters: optionalList(gen),
										interface: true
									};
								},
								peg$c23 = function (type, id, rest) {
									if (rest.node === 'FieldDeclaration') {
										rest.fragments[0].name = id;
										return mergeProps(rest, { type: type });
									} else {
										return mergeProps(rest, {
											returnType2: type,
											name: id,
											typeParameters: []
										});
									}
								},
								peg$c24 = function (rest) {
									return { node: 'FieldDeclaration', fragments: rest };
								},
								peg$c25 = function (params, dims, throws) {
									return {
										node: 'MethodDeclaration',
										parameters: params,
										thrownExceptions: extractThrowsClassType(extractOptionalList(throws, 1)),
										extraDimensions: dims.length,
										body: null,
										constructor: false
									};
								},
								peg$c26 = function (params) {
									return makePrimitive('void');
								},
								peg$c27 = function (params, type, id, rest) {
									return mergeProps(rest, {
										returnType2: type,
										name: id,
										typeParameters: params
									});
								},
								peg$c28 = function (params, throws) {
									return {
										node: 'MethodDeclaration',
										parameters: params,
										thrownExceptions: extractThrowsClassType(extractOptionalList(throws, 1)),
										returnType2: makePrimitive('void'),
										extraDimensions: 0,
										typeParameters: [],
										body: null,
										constructor: false
									};
								},
								peg$c29 = function (first, rest) {
									return buildList(first, rest, 1);
								},
								peg$c30 = function (dims, init) {
									return {
										node: 'VariableDeclarationFragment',
										extraDimensions: dims.length,
										initializer: init
									};
								},
								peg$c31 = function (name, impl, eb) {
									return mergeProps(eb, {
										node: 'EnumDeclaration',
										name: name,
										superInterfaceTypes: extractOptionalList(impl, 1)
									});
								},
								peg$c32 = function (consts, body) {
									return {
										enumConstants: optionalList(consts),
										bodyDeclarations: optionalList(body)
									};
								},
								peg$c33 = function (annot, name, args, cls) {
									return {
										node: 'EnumConstantDeclaration',
										anonymousClassDeclaration:
											cls === null
												? null
												: {
														node: 'AnonymousClassDeclaration',
														bodyDeclarations: cls
												  },
										arguments: optionalList(args),
										modifiers: annot,
										name: name
									};
								},
								peg$c34 = function (decl) {
									return decl;
								},
								peg$c35 = function () {
									return makeModifier('final');
								},
								peg$c36 = function (modifiers, type, decls) {
									return {
										node: 'VariableDeclarationStatement',
										fragments: decls,
										modifiers: modifiers,
										type: type
									};
								},
								peg$c37 = function (name, dims, init) {
									return {
										node: 'VariableDeclarationFragment',
										name: name,
										extraDimensions: dims.length,
										initializer: extractOptional(init, 1)
									};
								},
								peg$c38 = function (params) {
									return optionalList(params);
								},
								peg$c39 = function (modifiers, type, decl) {
									return mergeProps(decl, {
										type: type,
										modifiers: modifiers,
										varargs: false,
										initializer: null
									});
								},
								peg$c40 = function (modifiers, type, decl) {
									return mergeProps(decl, {
										type: type,
										modifiers: modifiers,
										varargs: true,
										initializer: null
									});
								},
								peg$c41 = function (first, rest, last) {
									return buildList(first, rest, 1).concat(extractOptionalList(last, 1));
								},
								peg$c42 = function (last) {
									return [last];
								},
								peg$c43 = function (id, dims) {
									return {
										node: 'SingleVariableDeclaration',
										name: id,
										extraDimensions: dims.length
									};
								},
								peg$c44 = function (statements) {
									return {
										node: 'Block',
										statements: statements
									};
								},
								peg$c45 = function (modifiers, decl) {
									return {
										node: 'TypeDeclarationStatement',
										declaration: mergeProps(decl, { modifiers: modifiers })
									};
								},
								peg$c46 = function (expr, message) {
									return {
										node: 'AssertStatement',
										expression: expr,
										message: extractOptional(message, 1)
									};
								},
								peg$c47 = function (expr, then, alt) {
									return {
										node: 'IfStatement',
										elseStatement: extractOptional(alt, 1),
										thenStatement: then,
										expression: expr.expression
									};
								},
								peg$c48 = function (init, expr, up, body) {
									return {
										node: 'ForStatement',
										initializers: optionalList(init),
										expression: expr,
										updaters: optionalList(up),
										body: body
									};
								},
								peg$c49 = function (param, expr, statement) {
									return {
										node: 'EnhancedForStatement',
										parameter: param,
										expression: expr,
										body: statement
									};
								},
								peg$c50 = function (expr, body) {
									return {
										node: 'WhileStatement',
										expression: expr.expression,
										body: body
									};
								},
								peg$c51 = function (statement, expr) {
									return {
										node: 'DoStatement',
										expression: expr.expression,
										body: statement
									};
								},
								peg$c52 = function (first, rest, body, cat, fin) {
									return mergeProps(makeCatchFinally(cat, fin), {
										node: 'TryStatement',
										body: body,
										resources: buildList(first, rest, 1)
									});
								},
								peg$c53 = function (body, cat, fin) {
									return makeCatchFinally(cat, fin);
								},
								peg$c54 = function (body, fin) {
									return makeCatchFinally([], fin);
								},
								peg$c55 = function (body, rest) {
									return mergeProps(rest, {
										node: 'TryStatement',
										body: body,
										resources: []
									});
								},
								peg$c56 = function (expr, cases) {
									return { node: 'SwitchStatement', statements: cases, expression: expr.expression };
								},
								peg$c57 = function (expr, body) {
									return { node: 'SynchronizedStatement', expression: expr.expression, body: body };
								},
								peg$c58 = function (expr) {
									return { node: 'ReturnStatement', expression: expr };
								},
								peg$c59 = function (expr) {
									return { node: 'ThrowStatement', expression: expr };
								},
								peg$c60 = function (id) {
									return { node: 'BreakStatement', label: id };
								},
								peg$c61 = function (id) {
									return { node: 'ContinueStatement', label: id };
								},
								peg$c62 = function () {
									return { node: 'EmptyStatement' };
								},
								peg$c63 = function (statement) {
									return statement;
								},
								peg$c64 = function (id, statement) {
									return { node: 'LabeledStatement', label: id, body: statement };
								},
								peg$c65 = function (modifiers, type, decl, expr) {
									var fragment = mergeProps(decl, { initializer: expr });
									fragment.node = 'VariableDeclarationFragment';
									return {
										node: 'VariableDeclarationExpression',
										modifiers: modifiers,
										type: type,
										fragments: [fragment]
									};
								},
								peg$c66 = function (modifiers, first, rest, decl, body) {
									return {
										node: 'CatchClause',
										body: body,
										exception: mergeProps(decl, {
											modifiers: modifiers,
											initializer: null,
											varargs: false,
											type: rest.length
												? {
														node: 'UnionType',
														types: buildList(first, rest, 1)
												  }
												: first
										})
									};
								},
								peg$c67 = function (block) {
									return block;
								},
								peg$c68 = function (blocks) {
									return [].concat.apply([], blocks);
								},
								peg$c69 = function (expr, blocks) {
									return [{ node: 'SwitchCase', expression: expr }].concat(blocks);
								},
								peg$c70 = function (expr) {
									return expr;
								},
								peg$c71 = function (modifiers, type, decls) {
									return [
										{
											node: 'VariableDeclarationExpression',
											modifiers: modifiers,
											fragments: decls,
											type: type
										}
									];
								},
								peg$c72 = function (first, rest) {
									return extractExpressions(buildList(first, rest, 1));
								},
								peg$c73 = function (expr) {
									switch (expr.node) {
										case 'SuperConstructorInvocation':
										case 'ConstructorInvocation':
											return expr;
										default:
											return {
												node: 'ExpressionStatement',
												expression: expr
											};
									}
								},
								peg$c74 = function (left, op, right) {
									return {
										node: 'Assignment',
										operator: op[0] /* remove ending spaces */,
										leftHandSide: left,
										rightHandSide: right
									};
								},
								peg$c75 = function (expr, then, alt) {
									return {
										node: 'ConditionalExpression',
										expression: expr,
										thenExpression: then,
										elseExpression: alt
									};
								},
								peg$c76 = function (first, rest) {
									return buildInfixExpr(first, rest);
								},
								peg$c77 = function (first, rest) {
									return buildTree(first, rest, function (result, element) {
										return element[0][0] === 'instanceof'
											? {
													node: 'InstanceofExpression',
													leftOperand: result,
													rightOperand: element[1]
											  }
											: {
													node: 'InfixExpression',
													operator: element[0][0], // remove ending Spacing
													leftOperand: result,
													rightOperand: element[1]
											  };
									});
								},
								peg$c78 = function (operator, operand) {
									return operand.node === 'NumberLiteral' &&
										operator === '-' &&
										(operand.token === '9223372036854775808L' ||
											operand.token === '9223372036854775808l' ||
											operand.token === '2147483648')
										? { node: 'NumberLiteral', token: text() }
										: {
												node: 'PrefixExpression',
												operator: operator,
												operand: operand
										  };
								},
								peg$c79 = function (expr) {
									return {
										node: 'CastExpression',
										type: expr[1],
										expression: expr[3]
									};
								},
								peg$c80 = function (arg, sel, sels, operator) {
									return operator.length > 1
										? TODO(/* JLS7? */)
										: {
												node: 'PostfixExpression',
												operator: operator[0],
												operand: buildSelectorTree(arg, sel, sels)
										  };
								},
								peg$c81 = function (arg, sel, sels) {
									return buildSelectorTree(arg, sel, sels);
								},
								peg$c82 = function (arg, operator) {
									return operator.length > 1
										? TODO(/* JLS7? */)
										: {
												node: 'PostfixExpression',
												operator: operator[0],
												operand: arg
										  };
								},
								peg$c83 = function (args, args_r) {
									return { node: 'ConstructorInvocation', arguments: args_r, typeArguments: [] };
								},
								peg$c84 = function (args, ret) {
									if (ret.typeArguments.length) return TODO(/* Ugly ! */);
									ret.typeArguments = args;
									return ret;
								},
								peg$c85 = function (args) {
									return args === null
										? {
												node: 'ThisExpression',
												qualifier: null
										  }
										: {
												node: 'ConstructorInvocation',
												arguments: args,
												typeArguments: []
										  };
								},
								peg$c86 = function (suffix) {
									return suffix.node === 'SuperConstructorInvocation'
										? suffix
										: mergeProps(suffix, { qualifier: null });
								},
								peg$c87 = function (creator) {
									return creator;
								},
								peg$c88 = function (type, dims) {
									return {
										node: 'TypeLiteral',
										type: buildArrayTree(type, dims)
									};
								},
								peg$c89 = function () {
									return {
										node: 'TypeLiteral',
										type: makePrimitive('void')
									};
								},
								peg$c90 = function (qual, dims) {
									return {
										node: 'TypeLiteral',
										type: buildArrayTree(buildTypeName(qual, null, []), dims)
									};
								},
								peg$c91 = function (qual, expr) {
									return { node: 'ArrayAccess', array: qual, index: expr };
								},
								peg$c92 = function (qual, args) {
									return mergeProps(popQualified(qual), {
										node: 'MethodInvocation',
										arguments: args,
										typeArguments: []
									});
								},
								peg$c93 = function (qual) {
									return { node: 'TypeLiteral', type: buildTypeName(qual, null, []) };
								},
								peg$c94 = function (qual, ret) {
									if (ret.expression) return TODO(/* Ugly ! */);
									ret.expression = qual;
									return ret;
								},
								peg$c95 = function (qual) {
									return { node: 'ThisExpression', qualifier: qual };
								},
								peg$c96 = function (qual, args) {
									return {
										node: 'SuperConstructorInvocation',
										arguments: args,
										expression: qual,
										typeArguments: []
									};
								},
								peg$c97 = function (qual, args, rest) {
									return mergeProps(rest, { expression: qual, typeArguments: optionalList(args) });
								},
								peg$c98 = function () {
									return [];
								},
								peg$c99 = function (suffix) {
									return suffix;
								},
								peg$c100 = function (id, args) {
									return { node: 'MethodInvocation', arguments: args, name: id, typeArguments: [] };
								},
								peg$c101 = function (op) {
									return op[0]; /* remove ending spaces */
								},
								peg$c102 = function (id) {
									return { node: 'FieldAccess', name: id };
								},
								peg$c103 = function (ret) {
									return ret;
								},
								peg$c104 = function () {
									return TODO(/* Any sample ? */);
								},
								peg$c105 = function (args, ret) {
									return mergeProps(ret, { typeArguments: optionalList(args) });
								},
								peg$c106 = function (expr) {
									return { node: 'ArrayAccess', index: expr };
								},
								peg$c107 = function (args) {
									return {
										node: 'SuperConstructorInvocation',
										arguments: args,
										expression: null,
										typeArguments: []
									};
								},
								peg$c108 = function (gen, id, args) {
									return args === null
										? {
												node: 'SuperFieldAccess',
												name: id
										  }
										: {
												node: 'SuperMethodInvocation',
												typeArguments: optionalList(gen),
												name: id,
												arguments: args
										  };
								},
								peg$c109 = 'byte',
								peg$c110 = peg$literalExpectation('byte', false),
								peg$c111 = 'short',
								peg$c112 = peg$literalExpectation('short', false),
								peg$c113 = 'char',
								peg$c114 = peg$literalExpectation('char', false),
								peg$c115 = 'int',
								peg$c116 = peg$literalExpectation('int', false),
								peg$c117 = 'long',
								peg$c118 = peg$literalExpectation('long', false),
								peg$c119 = 'float',
								peg$c120 = peg$literalExpectation('float', false),
								peg$c121 = 'double',
								peg$c122 = peg$literalExpectation('double', false),
								peg$c123 = 'boolean',
								peg$c124 = peg$literalExpectation('boolean', false),
								peg$c125 = function (type) {
									return makePrimitive(type);
								},
								peg$c126 = function (args) {
									return optionalList(args);
								},
								peg$c127 = function (type, rest) {
									return {
										node: 'ArrayCreation',
										type: buildArrayTree(type, rest.extraDims),
										initializer: rest.init,
										dimensions: rest.dimms
									};
								},
								peg$c128 = function (args, type, rest) {
									return mergeProps(rest, {
										node: 'ClassInstanceCreation',
										type: type,
										typeArguments: optionalList(args),
										expression: null
									});
								},
								peg$c129 = function (qual, args, rest) {
									return buildTypeName(qual, args, rest);
								},
								peg$c130 = function (id, args, rest) {
									return mergeProps(rest, {
										node: 'ClassInstanceCreation',
										type: buildTypeName(id, args, [])
									});
								},
								peg$c131 = function (args, body) {
									return {
										arguments: args,
										anonymousClassDeclaration:
											body === null
												? null
												: {
														node: 'AnonymousClassDeclaration',
														bodyDeclarations: body
												  }
									};
								},
								peg$c132 = function (dims, init) {
									return { extraDims: dims, init: init, dimms: [] };
								},
								peg$c133 = function (dimexpr, dims) {
									return { extraDims: dimexpr.concat(dims), init: null, dimms: dimexpr };
								},
								peg$c134 = function (dim) {
									return { extraDims: [dim], init: null, dimms: [] };
								},
								peg$c135 = function (init) {
									return { node: 'ArrayInitializer', expressions: optionalList(init) };
								},
								peg$c136 = function (expr) {
									return { node: 'ParenthesizedExpression', expression: expr };
								},
								peg$c137 = function (first, rest) {
									return buildQualified(first, rest, 1);
								},
								peg$c138 = function (exp) {
									return exp;
								},
								peg$c139 = function (type, dims) {
									return buildArrayTree(type, dims);
								},
								peg$c140 = function (bas, dims) {
									return buildArrayTree(bas, dims);
								},
								peg$c141 = function (cls, dims) {
									return buildArrayTree(cls, dims);
								},
								peg$c142 = function () {
									return true;
								},
								peg$c143 = function () {
									return false;
								},
								peg$c144 = function (rest) {
									return {
										node: 'WildcardType',
										upperBound: extractOptional(rest, 0, true),
										bound: extractOptional(rest, 1)
									};
								},
								peg$c145 = function (id, bounds) {
									return {
										node: 'TypeParameter',
										name: id,
										typeBounds: extractOptionalList(bounds, 1)
									};
								},
								peg$c146 = 'public',
								peg$c147 = peg$literalExpectation('public', false),
								peg$c148 = 'protected',
								peg$c149 = peg$literalExpectation('protected', false),
								peg$c150 = 'private',
								peg$c151 = peg$literalExpectation('private', false),
								peg$c152 = 'static',
								peg$c153 = peg$literalExpectation('static', false),
								peg$c154 = 'abstract',
								peg$c155 = peg$literalExpectation('abstract', false),
								peg$c156 = 'final',
								peg$c157 = peg$literalExpectation('final', false),
								peg$c158 = 'native',
								peg$c159 = peg$literalExpectation('native', false),
								peg$c160 = 'synchronized',
								peg$c161 = peg$literalExpectation('synchronized', false),
								peg$c162 = 'transient',
								peg$c163 = peg$literalExpectation('transient', false),
								peg$c164 = 'volatile',
								peg$c165 = peg$literalExpectation('volatile', false),
								peg$c166 = 'strictfp',
								peg$c167 = peg$literalExpectation('strictfp', false),
								peg$c168 = function (keyword) {
									return makeModifier(keyword);
								},
								peg$c169 = function (id, body) {
									return {
										node: 'AnnotationTypeDeclaration',
										name: id,
										bodyDeclarations: body
									};
								},
								peg$c170 = function (decl) {
									return skipNulls(decl);
								},
								peg$c171 = function (modifiers, rest) {
									return mergeProps(rest, { modifiers: modifiers });
								},
								peg$c172 = function (type, rest) {
									return mergeProps(rest, { type: type });
								},
								peg$c173 = function (id, def) {
									return {
										node: 'AnnotationTypeMemberDeclaration',
										name: id,
										default: def
									};
								},
								peg$c174 = function (fragments) {
									return { node: 'FieldDeclaration', fragments: fragments };
								},
								peg$c175 = function (val) {
									return val;
								},
								peg$c176 = function (id, pairs) {
									return {
										node: 'NormalAnnotation',
										typeName: id,
										values: optionalList(pairs)
									};
								},
								peg$c177 = function (id, value) {
									return {
										node: 'SingleMemberAnnotation',
										typeName: id,
										value: value
									};
								},
								peg$c178 = function (id) {
									return { node: 'MarkerAnnotation', typeName: id };
								},
								peg$c179 = function (name, value) {
									return {
										node: 'MemberValuePair',
										name: name,
										value: value
									};
								},
								peg$c180 = function (values) {
									return { node: 'ArrayInitializer', expressions: optionalList(values) };
								},
								peg$c181 = /^[ \t\r\n\f]/,
								peg$c182 = peg$classExpectation([' ', '\t', '\r', '\n', '\f'], false, false),
								peg$c183 = '/*',
								peg$c184 = peg$literalExpectation('/*', false),
								peg$c185 = '*/',
								peg$c186 = peg$literalExpectation('*/', false),
								peg$c187 = '//',
								peg$c188 = peg$literalExpectation('//', false),
								peg$c189 = /^[\r\n]/,
								peg$c190 = peg$classExpectation(['\r', '\n'], false, false),
								peg$c191 = function (first, rest) {
									return { identifier: first + rest, node: 'SimpleName' };
								},
								peg$c192 = /^[a-z]/,
								peg$c193 = peg$classExpectation([['a', 'z']], false, false),
								peg$c194 = /^[A-Z]/,
								peg$c195 = peg$classExpectation([['A', 'Z']], false, false),
								peg$c196 = /^[_$]/,
								peg$c197 = peg$classExpectation(['_', '$'], false, false),
								peg$c198 = /^[0-9]/,
								peg$c199 = peg$classExpectation([['0', '9']], false, false),
								peg$c200 = 'assert',
								peg$c201 = peg$literalExpectation('assert', false),
								peg$c202 = 'break',
								peg$c203 = peg$literalExpectation('break', false),
								peg$c204 = 'case',
								peg$c205 = peg$literalExpectation('case', false),
								peg$c206 = 'catch',
								peg$c207 = peg$literalExpectation('catch', false),
								peg$c208 = 'class',
								peg$c209 = peg$literalExpectation('class', false),
								peg$c210 = 'const',
								peg$c211 = peg$literalExpectation('const', false),
								peg$c212 = 'continue',
								peg$c213 = peg$literalExpectation('continue', false),
								peg$c214 = 'default',
								peg$c215 = peg$literalExpectation('default', false),
								peg$c216 = 'do',
								peg$c217 = peg$literalExpectation('do', false),
								peg$c218 = 'else',
								peg$c219 = peg$literalExpectation('else', false),
								peg$c220 = 'enum',
								peg$c221 = peg$literalExpectation('enum', false),
								peg$c222 = 'extends',
								peg$c223 = peg$literalExpectation('extends', false),
								peg$c224 = 'false',
								peg$c225 = peg$literalExpectation('false', false),
								peg$c226 = 'finally',
								peg$c227 = peg$literalExpectation('finally', false),
								peg$c228 = 'for',
								peg$c229 = peg$literalExpectation('for', false),
								peg$c230 = 'goto',
								peg$c231 = peg$literalExpectation('goto', false),
								peg$c232 = 'if',
								peg$c233 = peg$literalExpectation('if', false),
								peg$c234 = 'implements',
								peg$c235 = peg$literalExpectation('implements', false),
								peg$c236 = 'import',
								peg$c237 = peg$literalExpectation('import', false),
								peg$c238 = 'interface',
								peg$c239 = peg$literalExpectation('interface', false),
								peg$c240 = 'instanceof',
								peg$c241 = peg$literalExpectation('instanceof', false),
								peg$c242 = 'new',
								peg$c243 = peg$literalExpectation('new', false),
								peg$c244 = 'null',
								peg$c245 = peg$literalExpectation('null', false),
								peg$c246 = 'package',
								peg$c247 = peg$literalExpectation('package', false),
								peg$c248 = 'return',
								peg$c249 = peg$literalExpectation('return', false),
								peg$c250 = 'super',
								peg$c251 = peg$literalExpectation('super', false),
								peg$c252 = 'switch',
								peg$c253 = peg$literalExpectation('switch', false),
								peg$c254 = 'this',
								peg$c255 = peg$literalExpectation('this', false),
								peg$c256 = 'throws',
								peg$c257 = peg$literalExpectation('throws', false),
								peg$c258 = 'throw',
								peg$c259 = peg$literalExpectation('throw', false),
								peg$c260 = 'true',
								peg$c261 = peg$literalExpectation('true', false),
								peg$c262 = 'try',
								peg$c263 = peg$literalExpectation('try', false),
								peg$c264 = 'void',
								peg$c265 = peg$literalExpectation('void', false),
								peg$c266 = 'while',
								peg$c267 = peg$literalExpectation('while', false),
								peg$c268 = function () {
									return { node: 'BooleanLiteral', booleanValue: true };
								},
								peg$c269 = function () {
									return { node: 'BooleanLiteral', booleanValue: false };
								},
								peg$c270 = function () {
									return { node: 'NullLiteral' };
								},
								peg$c271 = function (literal) {
									return literal;
								},
								peg$c272 = /^[lL]/,
								peg$c273 = peg$classExpectation(['l', 'L'], false, false),
								peg$c274 = function () {
									return { node: 'NumberLiteral', token: text() };
								},
								peg$c275 = '0',
								peg$c276 = peg$literalExpectation('0', false),
								peg$c277 = /^[1-9]/,
								peg$c278 = peg$classExpectation([['1', '9']], false, false),
								peg$c279 = /^[_]/,
								peg$c280 = peg$classExpectation(['_'], false, false),
								peg$c281 = '0x',
								peg$c282 = peg$literalExpectation('0x', false),
								peg$c283 = '0X',
								peg$c284 = peg$literalExpectation('0X', false),
								peg$c285 = '0b',
								peg$c286 = peg$literalExpectation('0b', false),
								peg$c287 = '0B',
								peg$c288 = peg$literalExpectation('0B', false),
								peg$c289 = /^[01]/,
								peg$c290 = peg$classExpectation(['0', '1'], false, false),
								peg$c291 = /^[0-7]/,
								peg$c292 = peg$classExpectation([['0', '7']], false, false),
								peg$c293 = '.',
								peg$c294 = peg$literalExpectation('.', false),
								peg$c295 = /^[fFdD]/,
								peg$c296 = peg$classExpectation(['f', 'F', 'd', 'D'], false, false),
								peg$c297 = /^[eE]/,
								peg$c298 = peg$classExpectation(['e', 'E'], false, false),
								peg$c299 = /^[+\-]/,
								peg$c300 = peg$classExpectation(['+', '-'], false, false),
								peg$c301 = /^[pP]/,
								peg$c302 = peg$classExpectation(['p', 'P'], false, false),
								peg$c303 = /^[a-f]/,
								peg$c304 = peg$classExpectation([['a', 'f']], false, false),
								peg$c305 = /^[A-F]/,
								peg$c306 = peg$classExpectation([['A', 'F']], false, false),
								peg$c307 = "'",
								peg$c308 = peg$literalExpectation("'", false),
								peg$c309 = /^['\\\n\r]/,
								peg$c310 = peg$classExpectation(["'", '\\', '\n', '\r'], false, false),
								peg$c311 = function () {
									return { node: 'CharacterLiteral', escapedValue: text() };
								},
								peg$c312 = '"',
								peg$c313 = peg$literalExpectation('"', false),
								peg$c314 = /^["\\\n\r]/,
								peg$c315 = peg$classExpectation(['"', '\\', '\n', '\r'], false, false),
								peg$c316 = function () {
									return { node: 'StringLiteral', escapedValue: text() };
								},
								peg$c317 = '\\',
								peg$c318 = peg$literalExpectation('\\', false),
								peg$c319 = /^[btnfr"'\\]/,
								peg$c320 = peg$classExpectation(['b', 't', 'n', 'f', 'r', '"', "'", '\\'], false, false),
								peg$c321 = /^[0-3]/,
								peg$c322 = peg$classExpectation([['0', '3']], false, false),
								peg$c323 = 'u',
								peg$c324 = peg$literalExpectation('u', false),
								peg$c325 = '@',
								peg$c326 = peg$literalExpectation('@', false),
								peg$c327 = '&',
								peg$c328 = peg$literalExpectation('&', false),
								peg$c329 = /^[=&]/,
								peg$c330 = peg$classExpectation(['=', '&'], false, false),
								peg$c331 = '&&',
								peg$c332 = peg$literalExpectation('&&', false),
								peg$c333 = '&=',
								peg$c334 = peg$literalExpectation('&=', false),
								peg$c335 = '!',
								peg$c336 = peg$literalExpectation('!', false),
								peg$c337 = '=',
								peg$c338 = peg$literalExpectation('=', false),
								peg$c339 = '>>>',
								peg$c340 = peg$literalExpectation('>>>', false),
								peg$c341 = '>>>=',
								peg$c342 = peg$literalExpectation('>>>=', false),
								peg$c343 = ':',
								peg$c344 = peg$literalExpectation(':', false),
								peg$c345 = ',',
								peg$c346 = peg$literalExpectation(',', false),
								peg$c347 = '--',
								peg$c348 = peg$literalExpectation('--', false),
								peg$c349 = '/',
								peg$c350 = peg$literalExpectation('/', false),
								peg$c351 = '/=',
								peg$c352 = peg$literalExpectation('/=', false),
								peg$c353 = '...',
								peg$c354 = peg$literalExpectation('...', false),
								peg$c355 = '==',
								peg$c356 = peg$literalExpectation('==', false),
								peg$c357 = '>=',
								peg$c358 = peg$literalExpectation('>=', false),
								peg$c359 = '>',
								peg$c360 = peg$literalExpectation('>', false),
								peg$c361 = /^[=>]/,
								peg$c362 = peg$classExpectation(['=', '>'], false, false),
								peg$c363 = '^',
								peg$c364 = peg$literalExpectation('^', false),
								peg$c365 = '^=',
								peg$c366 = peg$literalExpectation('^=', false),
								peg$c367 = '++',
								peg$c368 = peg$literalExpectation('++', false),
								peg$c369 = '[',
								peg$c370 = peg$literalExpectation('[', false),
								peg$c371 = '<=',
								peg$c372 = peg$literalExpectation('<=', false),
								peg$c373 = '(',
								peg$c374 = peg$literalExpectation('(', false),
								peg$c375 = '<',
								peg$c376 = peg$literalExpectation('<', false),
								peg$c377 = /^[=<]/,
								peg$c378 = peg$classExpectation(['=', '<'], false, false),
								peg$c379 = '{',
								peg$c380 = peg$literalExpectation('{', false),
								peg$c381 = '-',
								peg$c382 = peg$literalExpectation('-', false),
								peg$c383 = /^[=\-]/,
								peg$c384 = peg$classExpectation(['=', '-'], false, false),
								peg$c385 = '-=',
								peg$c386 = peg$literalExpectation('-=', false),
								peg$c387 = '%',
								peg$c388 = peg$literalExpectation('%', false),
								peg$c389 = '%=',
								peg$c390 = peg$literalExpectation('%=', false),
								peg$c391 = '!=',
								peg$c392 = peg$literalExpectation('!=', false),
								peg$c393 = '|',
								peg$c394 = peg$literalExpectation('|', false),
								peg$c395 = /^[=|]/,
								peg$c396 = peg$classExpectation(['=', '|'], false, false),
								peg$c397 = '|=',
								peg$c398 = peg$literalExpectation('|=', false),
								peg$c399 = '||',
								peg$c400 = peg$literalExpectation('||', false),
								peg$c401 = '+',
								peg$c402 = peg$literalExpectation('+', false),
								peg$c403 = /^[=+]/,
								peg$c404 = peg$classExpectation(['=', '+'], false, false),
								peg$c405 = '+=',
								peg$c406 = peg$literalExpectation('+=', false),
								peg$c407 = '?',
								peg$c408 = peg$literalExpectation('?', false),
								peg$c409 = ']',
								peg$c410 = peg$literalExpectation(']', false),
								peg$c411 = ')',
								peg$c412 = peg$literalExpectation(')', false),
								peg$c413 = '}',
								peg$c414 = peg$literalExpectation('}', false),
								peg$c415 = ';',
								peg$c416 = peg$literalExpectation(';', false),
								peg$c417 = '<<',
								peg$c418 = peg$literalExpectation('<<', false),
								peg$c419 = '<<=',
								peg$c420 = peg$literalExpectation('<<=', false),
								peg$c421 = '>>',
								peg$c422 = peg$literalExpectation('>>', false),
								peg$c423 = '>>=',
								peg$c424 = peg$literalExpectation('>>=', false),
								peg$c425 = '*',
								peg$c426 = peg$literalExpectation('*', false),
								peg$c427 = '*=',
								peg$c428 = peg$literalExpectation('*=', false),
								peg$c429 = '~',
								peg$c430 = peg$literalExpectation('~', false),
								peg$c431 = peg$anyExpectation(),
								peg$currPos = 0,
								peg$savedPos = 0,
								peg$posDetailsCache = [{ line: 1, column: 1 }],
								peg$maxFailPos = 0,
								peg$maxFailExpected = [],
								peg$silentFails = 0,
								peg$result;

							if ('startRule' in options) {
								if (!(options.startRule in peg$startRuleFunctions)) {
									throw new Error('Can\'t start parsing from rule "' + options.startRule + '".');
								}

								peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
							}

							function text() {
								return input.substring(peg$savedPos, peg$currPos);
							}

							function peg$literalExpectation(text, ignoreCase) {
								return { type: 'literal', text: text, ignoreCase: ignoreCase };
							}

							function peg$classExpectation(parts, inverted, ignoreCase) {
								return { type: 'class', parts: parts, inverted: inverted, ignoreCase: ignoreCase };
							}

							function peg$anyExpectation() {
								return { type: 'any' };
							}

							function peg$endExpectation() {
								return { type: 'end' };
							}

							function peg$computePosDetails(pos) {
								var details = peg$posDetailsCache[pos],
									p;

								if (details) {
									return details;
								} else {
									p = pos - 1;
									while (!peg$posDetailsCache[p]) {
										p--;
									}

									details = peg$posDetailsCache[p];
									details = {
										line: details.line,
										column: details.column
									};

									while (p < pos) {
										if (input.charCodeAt(p) === 10) {
											details.line++;
											details.column = 1;
										} else {
											details.column++;
										}

										p++;
									}

									peg$posDetailsCache[pos] = details;
									return details;
								}
							}

							function peg$computeLocation(startPos, endPos) {
								var startPosDetails = peg$computePosDetails(startPos),
									endPosDetails = peg$computePosDetails(endPos);

								return {
									start: {
										offset: startPos,
										line: startPosDetails.line,
										column: startPosDetails.column
									},
									end: {
										offset: endPos,
										line: endPosDetails.line,
										column: endPosDetails.column
									}
								};
							}

							function peg$fail(expected) {
								if (peg$currPos < peg$maxFailPos) {
									return;
								}

								if (peg$currPos > peg$maxFailPos) {
									peg$maxFailPos = peg$currPos;
									peg$maxFailExpected = [];
								}

								peg$maxFailExpected.push(expected);
							}

							function peg$buildStructuredError(expected, found, location) {
								return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected, found), expected, found, location);
							}

							function peg$parseCompilationUnit() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseSpacing();
								if (s1 !== peg$FAILED) {
									s2 = peg$parsePackageDeclaration();
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = [];
										s4 = peg$parseImportDeclaration();
										while (s4 !== peg$FAILED) {
											s3.push(s4);
											s4 = peg$parseImportDeclaration();
										}
										if (s3 !== peg$FAILED) {
											s4 = [];
											s5 = peg$parseTypeDeclaration();
											while (s5 !== peg$FAILED) {
												s4.push(s5);
												s5 = peg$parseTypeDeclaration();
											}
											if (s4 !== peg$FAILED) {
												s5 = peg$parseEOT();
												if (s5 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c0(s2, s3, s4);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parsePackageDeclaration() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = [];
								s2 = peg$parseAnnotation();
								while (s2 !== peg$FAILED) {
									s1.push(s2);
									s2 = peg$parseAnnotation();
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parsePACKAGE();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseQualifiedIdentifier();
										if (s3 !== peg$FAILED) {
											s4 = peg$parseSEMI();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c1(s1, s3);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseImportDeclaration() {
								var s0, s1, s2, s3, s4, s5, s6;

								s0 = peg$currPos;
								s1 = peg$parseIMPORT();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSTATIC();
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseQualifiedIdentifier();
										if (s3 !== peg$FAILED) {
											s4 = peg$currPos;
											s5 = peg$parseDOT();
											if (s5 !== peg$FAILED) {
												s6 = peg$parseSTAR();
												if (s6 !== peg$FAILED) {
													s5 = [s5, s6];
													s4 = s5;
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
											if (s4 === peg$FAILED) {
												s4 = null;
											}
											if (s4 !== peg$FAILED) {
												s5 = peg$parseSEMI();
												if (s5 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c2(s2, s3, s4);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseSEMI();
									if (s1 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c3();
									}
									s0 = s1;
								}

								return s0;
							}

							function peg$parseTypeDeclaration() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = [];
								s2 = peg$parseModifier();
								while (s2 !== peg$FAILED) {
									s1.push(s2);
									s2 = peg$parseModifier();
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseClassDeclaration();
									if (s2 === peg$FAILED) {
										s2 = peg$parseEnumDeclaration();
										if (s2 === peg$FAILED) {
											s2 = peg$parseInterfaceDeclaration();
											if (s2 === peg$FAILED) {
												s2 = peg$parseAnnotationTypeDeclaration();
											}
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c4(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseSEMI();
									if (s1 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c3();
									}
									s0 = s1;
								}

								return s0;
							}

							function peg$parseClassDeclaration() {
								var s0, s1, s2, s3, s4, s5, s6, s7;

								s0 = peg$currPos;
								s1 = peg$parseCLASS();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseIdentifier();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseTypeParameters();
										if (s3 === peg$FAILED) {
											s3 = null;
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$currPos;
											s5 = peg$parseEXTENDS();
											if (s5 !== peg$FAILED) {
												s6 = peg$parseClassType();
												if (s6 !== peg$FAILED) {
													s5 = [s5, s6];
													s4 = s5;
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
											if (s4 === peg$FAILED) {
												s4 = null;
											}
											if (s4 !== peg$FAILED) {
												s5 = peg$currPos;
												s6 = peg$parseIMPLEMENTS();
												if (s6 !== peg$FAILED) {
													s7 = peg$parseClassTypeList();
													if (s7 !== peg$FAILED) {
														s6 = [s6, s7];
														s5 = s6;
													} else {
														peg$currPos = s5;
														s5 = peg$FAILED;
													}
												} else {
													peg$currPos = s5;
													s5 = peg$FAILED;
												}
												if (s5 === peg$FAILED) {
													s5 = null;
												}
												if (s5 !== peg$FAILED) {
													s6 = peg$parseClassBody();
													if (s6 !== peg$FAILED) {
														peg$savedPos = s0;
														s1 = peg$c5(s2, s3, s4, s5, s6);
														s0 = s1;
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseClassBody() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseLWING();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$parseClassBodyDeclaration();
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$parseClassBodyDeclaration();
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseRWING();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c6(s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseClassBodyDeclaration() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parseSEMI();
								if (s1 !== peg$FAILED) {
									peg$savedPos = s0;
									s1 = peg$c3();
								}
								s0 = s1;
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseSTATIC();
									if (s1 === peg$FAILED) {
										s1 = null;
									}
									if (s1 !== peg$FAILED) {
										s2 = peg$parseBlock();
										if (s2 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c7(s1, s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
									if (s0 === peg$FAILED) {
										s0 = peg$currPos;
										s1 = [];
										s2 = peg$parseModifier();
										while (s2 !== peg$FAILED) {
											s1.push(s2);
											s2 = peg$parseModifier();
										}
										if (s1 !== peg$FAILED) {
											s2 = peg$parseMemberDecl();
											if (s2 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c8(s1, s2);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									}
								}

								return s0;
							}

							function peg$parseMemberDecl() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseTypeParameters();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseGenericMethodOrConstructorRest();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c9(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseType();
									if (s1 !== peg$FAILED) {
										s2 = peg$parseIdentifier();
										if (s2 !== peg$FAILED) {
											s3 = peg$parseMethodDeclaratorRest();
											if (s3 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c10(s1, s2, s3);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
									if (s0 === peg$FAILED) {
										s0 = peg$currPos;
										s1 = peg$parseType();
										if (s1 !== peg$FAILED) {
											s2 = peg$parseVariableDeclarators();
											if (s2 !== peg$FAILED) {
												s3 = peg$parseSEMI();
												if (s3 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c11(s1, s2);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
										if (s0 === peg$FAILED) {
											s0 = peg$currPos;
											s1 = peg$parseVOID();
											if (s1 !== peg$FAILED) {
												s2 = peg$parseIdentifier();
												if (s2 !== peg$FAILED) {
													s3 = peg$parseVoidMethodDeclaratorRest();
													if (s3 !== peg$FAILED) {
														peg$savedPos = s0;
														s1 = peg$c12(s2, s3);
														s0 = s1;
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
											if (s0 === peg$FAILED) {
												s0 = peg$currPos;
												s1 = peg$parseIdentifier();
												if (s1 !== peg$FAILED) {
													s2 = peg$parseConstructorDeclaratorRest();
													if (s2 !== peg$FAILED) {
														peg$savedPos = s0;
														s1 = peg$c13(s1, s2);
														s0 = s1;
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
												if (s0 === peg$FAILED) {
													s0 = peg$parseInterfaceDeclaration();
													if (s0 === peg$FAILED) {
														s0 = peg$parseClassDeclaration();
														if (s0 === peg$FAILED) {
															s0 = peg$parseEnumDeclaration();
															if (s0 === peg$FAILED) {
																s0 = peg$parseAnnotationTypeDeclaration();
															}
														}
													}
												}
											}
										}
									}
								}

								return s0;
							}

							function peg$parseGenericMethodOrConstructorRest() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseType();
								if (s1 === peg$FAILED) {
									s1 = peg$currPos;
									s2 = peg$parseVOID();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s1;
										s2 = peg$c14();
									}
									s1 = s2;
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseIdentifier();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseMethodDeclaratorRest();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c15(s1, s2, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseIdentifier();
									if (s1 !== peg$FAILED) {
										s2 = peg$parseConstructorDeclaratorRest();
										if (s2 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c16(s1, s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								}

								return s0;
							}

							function peg$parseMethodDeclaratorRest() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseFormalParameters();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$parseDim();
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$parseDim();
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$currPos;
										s4 = peg$parseTHROWS();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseClassTypeList();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
										if (s3 === peg$FAILED) {
											s3 = null;
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseBlock();
											if (s4 === peg$FAILED) {
												s4 = peg$currPos;
												s5 = peg$parseSEMI();
												if (s5 !== peg$FAILED) {
													peg$savedPos = s4;
													s5 = peg$c17(s1, s2, s3);
												}
												s4 = s5;
											}
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c18(s1, s2, s3, s4);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseVoidMethodDeclaratorRest() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = peg$parseFormalParameters();
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									s3 = peg$parseTHROWS();
									if (s3 !== peg$FAILED) {
										s4 = peg$parseClassTypeList();
										if (s4 !== peg$FAILED) {
											s3 = [s3, s4];
											s2 = s3;
										} else {
											peg$currPos = s2;
											s2 = peg$FAILED;
										}
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseBlock();
										if (s3 === peg$FAILED) {
											s3 = peg$currPos;
											s4 = peg$parseSEMI();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s3;
												s4 = peg$c19(s1, s2);
											}
											s3 = s4;
										}
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c20(s1, s2, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseConstructorDeclaratorRest() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = peg$parseFormalParameters();
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									s3 = peg$parseTHROWS();
									if (s3 !== peg$FAILED) {
										s4 = peg$parseClassTypeList();
										if (s4 !== peg$FAILED) {
											s3 = [s3, s4];
											s2 = s3;
										} else {
											peg$currPos = s2;
											s2 = peg$FAILED;
										}
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseBlock();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c21(s1, s2, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseInterfaceDeclaration() {
								var s0, s1, s2, s3, s4, s5, s6;

								s0 = peg$currPos;
								s1 = peg$parseINTERFACE();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseIdentifier();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseTypeParameters();
										if (s3 === peg$FAILED) {
											s3 = null;
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$currPos;
											s5 = peg$parseEXTENDS();
											if (s5 !== peg$FAILED) {
												s6 = peg$parseClassTypeList();
												if (s6 !== peg$FAILED) {
													s5 = [s5, s6];
													s4 = s5;
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
											if (s4 === peg$FAILED) {
												s4 = null;
											}
											if (s4 !== peg$FAILED) {
												s5 = peg$parseInterfaceBody();
												if (s5 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c22(s2, s3, s4, s5);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseInterfaceBody() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseLWING();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$parseInterfaceBodyDeclaration();
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$parseInterfaceBodyDeclaration();
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseRWING();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c6(s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseInterfaceBodyDeclaration() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = [];
								s2 = peg$parseModifier();
								while (s2 !== peg$FAILED) {
									s1.push(s2);
									s2 = peg$parseModifier();
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseInterfaceMemberDecl();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c8(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseSEMI();
									if (s1 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c3();
									}
									s0 = s1;
								}

								return s0;
							}

							function peg$parseInterfaceMemberDecl() {
								var s0, s1, s2, s3;

								s0 = peg$parseInterfaceMethodOrFieldDecl();
								if (s0 === peg$FAILED) {
									s0 = peg$parseInterfaceGenericMethodDecl();
									if (s0 === peg$FAILED) {
										s0 = peg$currPos;
										s1 = peg$parseVOID();
										if (s1 !== peg$FAILED) {
											s2 = peg$parseIdentifier();
											if (s2 !== peg$FAILED) {
												s3 = peg$parseVoidInterfaceMethodDeclaratorRest();
												if (s3 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c16(s2, s3);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
										if (s0 === peg$FAILED) {
											s0 = peg$parseInterfaceDeclaration();
											if (s0 === peg$FAILED) {
												s0 = peg$parseAnnotationTypeDeclaration();
												if (s0 === peg$FAILED) {
													s0 = peg$parseClassDeclaration();
													if (s0 === peg$FAILED) {
														s0 = peg$parseEnumDeclaration();
													}
												}
											}
										}
									}
								}

								return s0;
							}

							function peg$parseInterfaceMethodOrFieldDecl() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseType();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseIdentifier();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseInterfaceMethodOrFieldRest();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c23(s1, s2, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseInterfaceMethodOrFieldRest() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parseConstantDeclaratorsRest();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSEMI();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c24(s1);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$parseInterfaceMethodDeclaratorRest();
								}

								return s0;
							}

							function peg$parseInterfaceMethodDeclaratorRest() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseFormalParameters();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$parseDim();
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$parseDim();
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$currPos;
										s4 = peg$parseTHROWS();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseClassTypeList();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
										if (s3 === peg$FAILED) {
											s3 = null;
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseSEMI();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c25(s1, s2, s3);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseInterfaceGenericMethodDecl() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = peg$parseTypeParameters();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseType();
									if (s2 === peg$FAILED) {
										s2 = peg$currPos;
										s3 = peg$parseVOID();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s2;
											s3 = peg$c26(s1);
										}
										s2 = s3;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseIdentifier();
										if (s3 !== peg$FAILED) {
											s4 = peg$parseInterfaceMethodDeclaratorRest();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c27(s1, s2, s3, s4);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseVoidInterfaceMethodDeclaratorRest() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = peg$parseFormalParameters();
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									s3 = peg$parseTHROWS();
									if (s3 !== peg$FAILED) {
										s4 = peg$parseClassTypeList();
										if (s4 !== peg$FAILED) {
											s3 = [s3, s4];
											s2 = s3;
										} else {
											peg$currPos = s2;
											s2 = peg$FAILED;
										}
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSEMI();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c28(s1, s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseConstantDeclaratorsRest() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseConstantDeclaratorRest();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseCOMMA();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseConstantDeclarator();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseCOMMA();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseConstantDeclarator();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c29(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseConstantDeclarator() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parseIdentifier();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseConstantDeclaratorRest();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c16(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseConstantDeclaratorRest() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = [];
								s2 = peg$parseDim();
								while (s2 !== peg$FAILED) {
									s1.push(s2);
									s2 = peg$parseDim();
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseEQU();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseVariableInitializer();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c30(s1, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseEnumDeclaration() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseENUM();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseIdentifier();
									if (s2 !== peg$FAILED) {
										s3 = peg$currPos;
										s4 = peg$parseIMPLEMENTS();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseClassTypeList();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
										if (s3 === peg$FAILED) {
											s3 = null;
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseEnumBody();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c31(s2, s3, s4);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseEnumBody() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseLWING();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseEnumConstants();
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseCOMMA();
										if (s3 === peg$FAILED) {
											s3 = null;
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseEnumBodyDeclarations();
											if (s4 === peg$FAILED) {
												s4 = null;
											}
											if (s4 !== peg$FAILED) {
												s5 = peg$parseRWING();
												if (s5 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c32(s2, s4);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseEnumConstants() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseEnumConstant();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseCOMMA();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseEnumConstant();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseCOMMA();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseEnumConstant();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c29(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseEnumConstant() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = [];
								s2 = peg$parseAnnotation();
								while (s2 !== peg$FAILED) {
									s1.push(s2);
									s2 = peg$parseAnnotation();
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseIdentifier();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseArguments();
										if (s3 === peg$FAILED) {
											s3 = null;
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseClassBody();
											if (s4 === peg$FAILED) {
												s4 = null;
											}
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c33(s1, s2, s3, s4);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseEnumBodyDeclarations() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseSEMI();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$parseClassBodyDeclaration();
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$parseClassBodyDeclaration();
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c34(s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseLocalVariableDeclarationStatement() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = [];
								s2 = peg$currPos;
								s3 = peg$parseFINAL();
								if (s3 !== peg$FAILED) {
									peg$savedPos = s2;
									s3 = peg$c35();
								}
								s2 = s3;
								if (s2 === peg$FAILED) {
									s2 = peg$parseAnnotation();
								}
								while (s2 !== peg$FAILED) {
									s1.push(s2);
									s2 = peg$currPos;
									s3 = peg$parseFINAL();
									if (s3 !== peg$FAILED) {
										peg$savedPos = s2;
										s3 = peg$c35();
									}
									s2 = s3;
									if (s2 === peg$FAILED) {
										s2 = peg$parseAnnotation();
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseType();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseVariableDeclarators();
										if (s3 !== peg$FAILED) {
											s4 = peg$parseSEMI();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c36(s1, s2, s3);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseVariableDeclarators() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseVariableDeclarator();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseCOMMA();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseVariableDeclarator();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseCOMMA();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseVariableDeclarator();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c29(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseVariableDeclarator() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseIdentifier();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$parseDim();
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$parseDim();
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$currPos;
										s4 = peg$parseEQU();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseVariableInitializer();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
										if (s3 === peg$FAILED) {
											s3 = null;
										}
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c37(s1, s2, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseFormalParameters() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseLPAR();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseFormalParameterList();
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseRPAR();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c38(s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseFormalParameter() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = [];
								s2 = peg$currPos;
								s3 = peg$parseFINAL();
								if (s3 !== peg$FAILED) {
									peg$savedPos = s2;
									s3 = peg$c35();
								}
								s2 = s3;
								if (s2 === peg$FAILED) {
									s2 = peg$parseAnnotation();
								}
								while (s2 !== peg$FAILED) {
									s1.push(s2);
									s2 = peg$currPos;
									s3 = peg$parseFINAL();
									if (s3 !== peg$FAILED) {
										peg$savedPos = s2;
										s3 = peg$c35();
									}
									s2 = s3;
									if (s2 === peg$FAILED) {
										s2 = peg$parseAnnotation();
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseType();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseVariableDeclaratorId();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c39(s1, s2, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseLastFormalParameter() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = [];
								s2 = peg$currPos;
								s3 = peg$parseFINAL();
								if (s3 !== peg$FAILED) {
									peg$savedPos = s2;
									s3 = peg$c35();
								}
								s2 = s3;
								if (s2 === peg$FAILED) {
									s2 = peg$parseAnnotation();
								}
								while (s2 !== peg$FAILED) {
									s1.push(s2);
									s2 = peg$currPos;
									s3 = peg$parseFINAL();
									if (s3 !== peg$FAILED) {
										peg$savedPos = s2;
										s3 = peg$c35();
									}
									s2 = s3;
									if (s2 === peg$FAILED) {
										s2 = peg$parseAnnotation();
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseType();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseELLIPSIS();
										if (s3 !== peg$FAILED) {
											s4 = peg$parseVariableDeclaratorId();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c40(s1, s2, s4);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseFormalParameterList() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseFormalParameter();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseCOMMA();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseFormalParameter();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseCOMMA();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseFormalParameter();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$currPos;
										s4 = peg$parseCOMMA();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseLastFormalParameter();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
										if (s3 === peg$FAILED) {
											s3 = null;
										}
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c41(s1, s2, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseLastFormalParameter();
									if (s1 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c42(s1);
									}
									s0 = s1;
								}

								return s0;
							}

							function peg$parseVariableDeclaratorId() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseIdentifier();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$parseDim();
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$parseDim();
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c43(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseBlock() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseLWING();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseBlockStatements();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseRWING();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c44(s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseBlockStatements() {
								var s0, s1;

								s0 = [];
								s1 = peg$parseBlockStatement();
								while (s1 !== peg$FAILED) {
									s0.push(s1);
									s1 = peg$parseBlockStatement();
								}

								return s0;
							}

							function peg$parseBlockStatement() {
								var s0, s1, s2;

								s0 = peg$parseLocalVariableDeclarationStatement();
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = [];
									s2 = peg$parseModifier();
									while (s2 !== peg$FAILED) {
										s1.push(s2);
										s2 = peg$parseModifier();
									}
									if (s1 !== peg$FAILED) {
										s2 = peg$parseClassDeclaration();
										if (s2 === peg$FAILED) {
											s2 = peg$parseEnumDeclaration();
										}
										if (s2 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c45(s1, s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
									if (s0 === peg$FAILED) {
										s0 = peg$parseStatement();
									}
								}

								return s0;
							}

							function peg$parseStatement() {
								var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9;

								s0 = peg$parseBlock();
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseASSERT();
									if (s1 !== peg$FAILED) {
										s2 = peg$parseExpression();
										if (s2 !== peg$FAILED) {
											s3 = peg$currPos;
											s4 = peg$parseCOLON();
											if (s4 !== peg$FAILED) {
												s5 = peg$parseExpression();
												if (s5 !== peg$FAILED) {
													s4 = [s4, s5];
													s3 = s4;
												} else {
													peg$currPos = s3;
													s3 = peg$FAILED;
												}
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
											if (s3 === peg$FAILED) {
												s3 = null;
											}
											if (s3 !== peg$FAILED) {
												s4 = peg$parseSEMI();
												if (s4 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c46(s2, s3);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
									if (s0 === peg$FAILED) {
										s0 = peg$currPos;
										s1 = peg$parseIF();
										if (s1 !== peg$FAILED) {
											s2 = peg$parseParExpression();
											if (s2 !== peg$FAILED) {
												s3 = peg$parseStatement();
												if (s3 !== peg$FAILED) {
													s4 = peg$currPos;
													s5 = peg$parseELSE();
													if (s5 !== peg$FAILED) {
														s6 = peg$parseStatement();
														if (s6 !== peg$FAILED) {
															s5 = [s5, s6];
															s4 = s5;
														} else {
															peg$currPos = s4;
															s4 = peg$FAILED;
														}
													} else {
														peg$currPos = s4;
														s4 = peg$FAILED;
													}
													if (s4 === peg$FAILED) {
														s4 = null;
													}
													if (s4 !== peg$FAILED) {
														peg$savedPos = s0;
														s1 = peg$c47(s2, s3, s4);
														s0 = s1;
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
										if (s0 === peg$FAILED) {
											s0 = peg$currPos;
											s1 = peg$parseFOR();
											if (s1 !== peg$FAILED) {
												s2 = peg$parseLPAR();
												if (s2 !== peg$FAILED) {
													s3 = peg$parseForInit();
													if (s3 === peg$FAILED) {
														s3 = null;
													}
													if (s3 !== peg$FAILED) {
														s4 = peg$parseSEMI();
														if (s4 !== peg$FAILED) {
															s5 = peg$parseExpression();
															if (s5 === peg$FAILED) {
																s5 = null;
															}
															if (s5 !== peg$FAILED) {
																s6 = peg$parseSEMI();
																if (s6 !== peg$FAILED) {
																	s7 = peg$parseForUpdate();
																	if (s7 === peg$FAILED) {
																		s7 = null;
																	}
																	if (s7 !== peg$FAILED) {
																		s8 = peg$parseRPAR();
																		if (s8 !== peg$FAILED) {
																			s9 = peg$parseStatement();
																			if (s9 !== peg$FAILED) {
																				peg$savedPos = s0;
																				s1 = peg$c48(s3, s5, s7, s9);
																				s0 = s1;
																			} else {
																				peg$currPos = s0;
																				s0 = peg$FAILED;
																			}
																		} else {
																			peg$currPos = s0;
																			s0 = peg$FAILED;
																		}
																	} else {
																		peg$currPos = s0;
																		s0 = peg$FAILED;
																	}
																} else {
																	peg$currPos = s0;
																	s0 = peg$FAILED;
																}
															} else {
																peg$currPos = s0;
																s0 = peg$FAILED;
															}
														} else {
															peg$currPos = s0;
															s0 = peg$FAILED;
														}
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
											if (s0 === peg$FAILED) {
												s0 = peg$currPos;
												s1 = peg$parseFOR();
												if (s1 !== peg$FAILED) {
													s2 = peg$parseLPAR();
													if (s2 !== peg$FAILED) {
														s3 = peg$parseFormalParameter();
														if (s3 !== peg$FAILED) {
															s4 = peg$parseCOLON();
															if (s4 !== peg$FAILED) {
																s5 = peg$parseExpression();
																if (s5 !== peg$FAILED) {
																	s6 = peg$parseRPAR();
																	if (s6 !== peg$FAILED) {
																		s7 = peg$parseStatement();
																		if (s7 !== peg$FAILED) {
																			peg$savedPos = s0;
																			s1 = peg$c49(s3, s5, s7);
																			s0 = s1;
																		} else {
																			peg$currPos = s0;
																			s0 = peg$FAILED;
																		}
																	} else {
																		peg$currPos = s0;
																		s0 = peg$FAILED;
																	}
																} else {
																	peg$currPos = s0;
																	s0 = peg$FAILED;
																}
															} else {
																peg$currPos = s0;
																s0 = peg$FAILED;
															}
														} else {
															peg$currPos = s0;
															s0 = peg$FAILED;
														}
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
												if (s0 === peg$FAILED) {
													s0 = peg$currPos;
													s1 = peg$parseWHILE();
													if (s1 !== peg$FAILED) {
														s2 = peg$parseParExpression();
														if (s2 !== peg$FAILED) {
															s3 = peg$parseStatement();
															if (s3 !== peg$FAILED) {
																peg$savedPos = s0;
																s1 = peg$c50(s2, s3);
																s0 = s1;
															} else {
																peg$currPos = s0;
																s0 = peg$FAILED;
															}
														} else {
															peg$currPos = s0;
															s0 = peg$FAILED;
														}
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
													if (s0 === peg$FAILED) {
														s0 = peg$currPos;
														s1 = peg$parseDO();
														if (s1 !== peg$FAILED) {
															s2 = peg$parseStatement();
															if (s2 !== peg$FAILED) {
																s3 = peg$parseWHILE();
																if (s3 !== peg$FAILED) {
																	s4 = peg$parseParExpression();
																	if (s4 !== peg$FAILED) {
																		s5 = peg$parseSEMI();
																		if (s5 !== peg$FAILED) {
																			peg$savedPos = s0;
																			s1 = peg$c51(s2, s4);
																			s0 = s1;
																		} else {
																			peg$currPos = s0;
																			s0 = peg$FAILED;
																		}
																	} else {
																		peg$currPos = s0;
																		s0 = peg$FAILED;
																	}
																} else {
																	peg$currPos = s0;
																	s0 = peg$FAILED;
																}
															} else {
																peg$currPos = s0;
																s0 = peg$FAILED;
															}
														} else {
															peg$currPos = s0;
															s0 = peg$FAILED;
														}
														if (s0 === peg$FAILED) {
															s0 = peg$currPos;
															s1 = peg$parseTRY();
															if (s1 !== peg$FAILED) {
																s2 = peg$parseLPAR();
																if (s2 !== peg$FAILED) {
																	s3 = peg$parseResource();
																	if (s3 !== peg$FAILED) {
																		s4 = [];
																		s5 = peg$currPos;
																		s6 = peg$parseSEMI();
																		if (s6 !== peg$FAILED) {
																			s7 = peg$parseResource();
																			if (s7 !== peg$FAILED) {
																				s6 = [s6, s7];
																				s5 = s6;
																			} else {
																				peg$currPos = s5;
																				s5 = peg$FAILED;
																			}
																		} else {
																			peg$currPos = s5;
																			s5 = peg$FAILED;
																		}
																		while (s5 !== peg$FAILED) {
																			s4.push(s5);
																			s5 = peg$currPos;
																			s6 = peg$parseSEMI();
																			if (s6 !== peg$FAILED) {
																				s7 = peg$parseResource();
																				if (s7 !== peg$FAILED) {
																					s6 = [s6, s7];
																					s5 = s6;
																				} else {
																					peg$currPos = s5;
																					s5 = peg$FAILED;
																				}
																			} else {
																				peg$currPos = s5;
																				s5 = peg$FAILED;
																			}
																		}
																		if (s4 !== peg$FAILED) {
																			s5 = peg$parseSEMI();
																			if (s5 === peg$FAILED) {
																				s5 = null;
																			}
																			if (s5 !== peg$FAILED) {
																				s6 = peg$parseRPAR();
																				if (s6 !== peg$FAILED) {
																					s7 = peg$parseBlock();
																					if (s7 !== peg$FAILED) {
																						s8 = [];
																						s9 = peg$parseCatch();
																						while (s9 !== peg$FAILED) {
																							s8.push(s9);
																							s9 = peg$parseCatch();
																						}
																						if (s8 !== peg$FAILED) {
																							s9 = peg$parseFinally();
																							if (s9 === peg$FAILED) {
																								s9 = null;
																							}
																							if (s9 !== peg$FAILED) {
																								peg$savedPos = s0;
																								s1 = peg$c52(s3, s4, s7, s8, s9);
																								s0 = s1;
																							} else {
																								peg$currPos = s0;
																								s0 = peg$FAILED;
																							}
																						} else {
																							peg$currPos = s0;
																							s0 = peg$FAILED;
																						}
																					} else {
																						peg$currPos = s0;
																						s0 = peg$FAILED;
																					}
																				} else {
																					peg$currPos = s0;
																					s0 = peg$FAILED;
																				}
																			} else {
																				peg$currPos = s0;
																				s0 = peg$FAILED;
																			}
																		} else {
																			peg$currPos = s0;
																			s0 = peg$FAILED;
																		}
																	} else {
																		peg$currPos = s0;
																		s0 = peg$FAILED;
																	}
																} else {
																	peg$currPos = s0;
																	s0 = peg$FAILED;
																}
															} else {
																peg$currPos = s0;
																s0 = peg$FAILED;
															}
															if (s0 === peg$FAILED) {
																s0 = peg$currPos;
																s1 = peg$parseTRY();
																if (s1 !== peg$FAILED) {
																	s2 = peg$parseBlock();
																	if (s2 !== peg$FAILED) {
																		s3 = peg$currPos;
																		s4 = [];
																		s5 = peg$parseCatch();
																		if (s5 !== peg$FAILED) {
																			while (s5 !== peg$FAILED) {
																				s4.push(s5);
																				s5 = peg$parseCatch();
																			}
																		} else {
																			s4 = peg$FAILED;
																		}
																		if (s4 !== peg$FAILED) {
																			s5 = peg$parseFinally();
																			if (s5 === peg$FAILED) {
																				s5 = null;
																			}
																			if (s5 !== peg$FAILED) {
																				peg$savedPos = s3;
																				s4 = peg$c53(s2, s4, s5);
																				s3 = s4;
																			} else {
																				peg$currPos = s3;
																				s3 = peg$FAILED;
																			}
																		} else {
																			peg$currPos = s3;
																			s3 = peg$FAILED;
																		}
																		if (s3 === peg$FAILED) {
																			s3 = peg$currPos;
																			s4 = peg$parseFinally();
																			if (s4 !== peg$FAILED) {
																				peg$savedPos = s3;
																				s4 = peg$c54(s2, s4);
																			}
																			s3 = s4;
																		}
																		if (s3 !== peg$FAILED) {
																			peg$savedPos = s0;
																			s1 = peg$c55(s2, s3);
																			s0 = s1;
																		} else {
																			peg$currPos = s0;
																			s0 = peg$FAILED;
																		}
																	} else {
																		peg$currPos = s0;
																		s0 = peg$FAILED;
																	}
																} else {
																	peg$currPos = s0;
																	s0 = peg$FAILED;
																}
																if (s0 === peg$FAILED) {
																	s0 = peg$currPos;
																	s1 = peg$parseSWITCH();
																	if (s1 !== peg$FAILED) {
																		s2 = peg$parseParExpression();
																		if (s2 !== peg$FAILED) {
																			s3 = peg$parseLWING();
																			if (s3 !== peg$FAILED) {
																				s4 = peg$parseSwitchBlockStatementGroups();
																				if (s4 !== peg$FAILED) {
																					s5 = peg$parseRWING();
																					if (s5 !== peg$FAILED) {
																						peg$savedPos = s0;
																						s1 = peg$c56(s2, s4);
																						s0 = s1;
																					} else {
																						peg$currPos = s0;
																						s0 = peg$FAILED;
																					}
																				} else {
																					peg$currPos = s0;
																					s0 = peg$FAILED;
																				}
																			} else {
																				peg$currPos = s0;
																				s0 = peg$FAILED;
																			}
																		} else {
																			peg$currPos = s0;
																			s0 = peg$FAILED;
																		}
																	} else {
																		peg$currPos = s0;
																		s0 = peg$FAILED;
																	}
																	if (s0 === peg$FAILED) {
																		s0 = peg$currPos;
																		s1 = peg$parseSYNCHRONIZED();
																		if (s1 !== peg$FAILED) {
																			s2 = peg$parseParExpression();
																			if (s2 !== peg$FAILED) {
																				s3 = peg$parseBlock();
																				if (s3 !== peg$FAILED) {
																					peg$savedPos = s0;
																					s1 = peg$c57(s2, s3);
																					s0 = s1;
																				} else {
																					peg$currPos = s0;
																					s0 = peg$FAILED;
																				}
																			} else {
																				peg$currPos = s0;
																				s0 = peg$FAILED;
																			}
																		} else {
																			peg$currPos = s0;
																			s0 = peg$FAILED;
																		}
																		if (s0 === peg$FAILED) {
																			s0 = peg$currPos;
																			s1 = peg$parseRETURN();
																			if (s1 !== peg$FAILED) {
																				s2 = peg$parseExpression();
																				if (s2 === peg$FAILED) {
																					s2 = null;
																				}
																				if (s2 !== peg$FAILED) {
																					s3 = peg$parseSEMI();
																					if (s3 !== peg$FAILED) {
																						peg$savedPos = s0;
																						s1 = peg$c58(s2);
																						s0 = s1;
																					} else {
																						peg$currPos = s0;
																						s0 = peg$FAILED;
																					}
																				} else {
																					peg$currPos = s0;
																					s0 = peg$FAILED;
																				}
																			} else {
																				peg$currPos = s0;
																				s0 = peg$FAILED;
																			}
																			if (s0 === peg$FAILED) {
																				s0 = peg$currPos;
																				s1 = peg$parseTHROW();
																				if (s1 !== peg$FAILED) {
																					s2 = peg$parseExpression();
																					if (s2 !== peg$FAILED) {
																						s3 = peg$parseSEMI();
																						if (s3 !== peg$FAILED) {
																							peg$savedPos = s0;
																							s1 = peg$c59(s2);
																							s0 = s1;
																						} else {
																							peg$currPos = s0;
																							s0 = peg$FAILED;
																						}
																					} else {
																						peg$currPos = s0;
																						s0 = peg$FAILED;
																					}
																				} else {
																					peg$currPos = s0;
																					s0 = peg$FAILED;
																				}
																				if (s0 === peg$FAILED) {
																					s0 = peg$currPos;
																					s1 = peg$parseBREAK();
																					if (s1 !== peg$FAILED) {
																						s2 = peg$parseIdentifier();
																						if (s2 === peg$FAILED) {
																							s2 = null;
																						}
																						if (s2 !== peg$FAILED) {
																							s3 = peg$parseSEMI();
																							if (s3 !== peg$FAILED) {
																								peg$savedPos = s0;
																								s1 = peg$c60(s2);
																								s0 = s1;
																							} else {
																								peg$currPos = s0;
																								s0 = peg$FAILED;
																							}
																						} else {
																							peg$currPos = s0;
																							s0 = peg$FAILED;
																						}
																					} else {
																						peg$currPos = s0;
																						s0 = peg$FAILED;
																					}
																					if (s0 === peg$FAILED) {
																						s0 = peg$currPos;
																						s1 = peg$parseCONTINUE();
																						if (s1 !== peg$FAILED) {
																							s2 = peg$parseIdentifier();
																							if (s2 === peg$FAILED) {
																								s2 = null;
																							}
																							if (s2 !== peg$FAILED) {
																								s3 = peg$parseSEMI();
																								if (s3 !== peg$FAILED) {
																									peg$savedPos = s0;
																									s1 = peg$c61(s2);
																									s0 = s1;
																								} else {
																									peg$currPos = s0;
																									s0 = peg$FAILED;
																								}
																							} else {
																								peg$currPos = s0;
																								s0 = peg$FAILED;
																							}
																						} else {
																							peg$currPos = s0;
																							s0 = peg$FAILED;
																						}
																						if (s0 === peg$FAILED) {
																							s0 = peg$currPos;
																							s1 = peg$parseSEMI();
																							if (s1 !== peg$FAILED) {
																								peg$savedPos = s0;
																								s1 = peg$c62();
																							}
																							s0 = s1;
																							if (s0 === peg$FAILED) {
																								s0 = peg$currPos;
																								s1 = peg$parseStatementExpression();
																								if (s1 !== peg$FAILED) {
																									s2 = peg$parseSEMI();
																									if (s2 !== peg$FAILED) {
																										peg$savedPos = s0;
																										s1 = peg$c63(s1);
																										s0 = s1;
																									} else {
																										peg$currPos = s0;
																										s0 = peg$FAILED;
																									}
																								} else {
																									peg$currPos = s0;
																									s0 = peg$FAILED;
																								}
																								if (s0 === peg$FAILED) {
																									s0 = peg$currPos;
																									s1 = peg$parseIdentifier();
																									if (s1 !== peg$FAILED) {
																										s2 = peg$parseCOLON();
																										if (s2 !== peg$FAILED) {
																											s3 = peg$parseStatement();
																											if (s3 !== peg$FAILED) {
																												peg$savedPos = s0;
																												s1 = peg$c64(s1, s3);
																												s0 = s1;
																											} else {
																												peg$currPos = s0;
																												s0 = peg$FAILED;
																											}
																										} else {
																											peg$currPos = s0;
																											s0 = peg$FAILED;
																										}
																									} else {
																										peg$currPos = s0;
																										s0 = peg$FAILED;
																									}
																								}
																							}
																						}
																					}
																				}
																			}
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}

								return s0;
							}

							function peg$parseResource() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = [];
								s2 = peg$currPos;
								s3 = peg$parseFINAL();
								if (s3 !== peg$FAILED) {
									peg$savedPos = s2;
									s3 = peg$c35();
								}
								s2 = s3;
								if (s2 === peg$FAILED) {
									s2 = peg$parseAnnotation();
								}
								while (s2 !== peg$FAILED) {
									s1.push(s2);
									s2 = peg$currPos;
									s3 = peg$parseFINAL();
									if (s3 !== peg$FAILED) {
										peg$savedPos = s2;
										s3 = peg$c35();
									}
									s2 = s3;
									if (s2 === peg$FAILED) {
										s2 = peg$parseAnnotation();
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseType();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseVariableDeclaratorId();
										if (s3 !== peg$FAILED) {
											s4 = peg$parseEQU();
											if (s4 !== peg$FAILED) {
												s5 = peg$parseExpression();
												if (s5 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c65(s1, s2, s3, s5);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseCatch() {
								var s0, s1, s2, s3, s4, s5, s6, s7, s8;

								s0 = peg$currPos;
								s1 = peg$parseCATCH();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseLPAR();
									if (s2 !== peg$FAILED) {
										s3 = [];
										s4 = peg$currPos;
										s5 = peg$parseFINAL();
										if (s5 !== peg$FAILED) {
											peg$savedPos = s4;
											s5 = peg$c35();
										}
										s4 = s5;
										if (s4 === peg$FAILED) {
											s4 = peg$parseAnnotation();
										}
										while (s4 !== peg$FAILED) {
											s3.push(s4);
											s4 = peg$currPos;
											s5 = peg$parseFINAL();
											if (s5 !== peg$FAILED) {
												peg$savedPos = s4;
												s5 = peg$c35();
											}
											s4 = s5;
											if (s4 === peg$FAILED) {
												s4 = peg$parseAnnotation();
											}
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseType();
											if (s4 !== peg$FAILED) {
												s5 = [];
												s6 = peg$currPos;
												s7 = peg$parseOR();
												if (s7 !== peg$FAILED) {
													s8 = peg$parseType();
													if (s8 !== peg$FAILED) {
														s7 = [s7, s8];
														s6 = s7;
													} else {
														peg$currPos = s6;
														s6 = peg$FAILED;
													}
												} else {
													peg$currPos = s6;
													s6 = peg$FAILED;
												}
												while (s6 !== peg$FAILED) {
													s5.push(s6);
													s6 = peg$currPos;
													s7 = peg$parseOR();
													if (s7 !== peg$FAILED) {
														s8 = peg$parseType();
														if (s8 !== peg$FAILED) {
															s7 = [s7, s8];
															s6 = s7;
														} else {
															peg$currPos = s6;
															s6 = peg$FAILED;
														}
													} else {
														peg$currPos = s6;
														s6 = peg$FAILED;
													}
												}
												if (s5 !== peg$FAILED) {
													s6 = peg$parseVariableDeclaratorId();
													if (s6 !== peg$FAILED) {
														s7 = peg$parseRPAR();
														if (s7 !== peg$FAILED) {
															s8 = peg$parseBlock();
															if (s8 !== peg$FAILED) {
																peg$savedPos = s0;
																s1 = peg$c66(s3, s4, s5, s6, s8);
																s0 = s1;
															} else {
																peg$currPos = s0;
																s0 = peg$FAILED;
															}
														} else {
															peg$currPos = s0;
															s0 = peg$FAILED;
														}
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseFinally() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parseFINALLY();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseBlock();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c67(s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSwitchBlockStatementGroups() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = [];
								s2 = peg$parseSwitchBlockStatementGroup();
								while (s2 !== peg$FAILED) {
									s1.push(s2);
									s2 = peg$parseSwitchBlockStatementGroup();
								}
								if (s1 !== peg$FAILED) {
									peg$savedPos = s0;
									s1 = peg$c68(s1);
								}
								s0 = s1;

								return s0;
							}

							function peg$parseSwitchBlockStatementGroup() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parseSwitchLabel();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseBlockStatements();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c69(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSwitchLabel() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseCASE();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseExpression();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseCOLON();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c70(s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseCASE();
									if (s1 !== peg$FAILED) {
										s2 = peg$parseIdentifier();
										if (s2 !== peg$FAILED) {
											s3 = peg$parseCOLON();
											if (s3 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c70(s2);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
									if (s0 === peg$FAILED) {
										s0 = peg$currPos;
										s1 = peg$parseDEFAULT();
										if (s1 !== peg$FAILED) {
											s2 = peg$parseCOLON();
											if (s2 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c3();
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									}
								}

								return s0;
							}

							function peg$parseForInit() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = [];
								s2 = peg$currPos;
								s3 = peg$parseFINAL();
								if (s3 !== peg$FAILED) {
									peg$savedPos = s2;
									s3 = peg$c35();
								}
								s2 = s3;
								if (s2 === peg$FAILED) {
									s2 = peg$parseAnnotation();
								}
								while (s2 !== peg$FAILED) {
									s1.push(s2);
									s2 = peg$currPos;
									s3 = peg$parseFINAL();
									if (s3 !== peg$FAILED) {
										peg$savedPos = s2;
										s3 = peg$c35();
									}
									s2 = s3;
									if (s2 === peg$FAILED) {
										s2 = peg$parseAnnotation();
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseType();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseVariableDeclarators();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c71(s1, s2, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseStatementExpression();
									if (s1 !== peg$FAILED) {
										s2 = [];
										s3 = peg$currPos;
										s4 = peg$parseCOMMA();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseStatementExpression();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
										while (s3 !== peg$FAILED) {
											s2.push(s3);
											s3 = peg$currPos;
											s4 = peg$parseCOMMA();
											if (s4 !== peg$FAILED) {
												s5 = peg$parseStatementExpression();
												if (s5 !== peg$FAILED) {
													s4 = [s4, s5];
													s3 = s4;
												} else {
													peg$currPos = s3;
													s3 = peg$FAILED;
												}
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										}
										if (s2 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c72(s1, s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								}

								return s0;
							}

							function peg$parseForUpdate() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseStatementExpression();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseCOMMA();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseStatementExpression();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseCOMMA();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseStatementExpression();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c72(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseStatementExpression() {
								var s0, s1;

								s0 = peg$currPos;
								s1 = peg$parseExpression();
								if (s1 !== peg$FAILED) {
									peg$savedPos = s0;
									s1 = peg$c73(s1);
								}
								s0 = s1;

								return s0;
							}

							function peg$parseExpression() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseConditionalExpression();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseAssignmentOperator();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseExpression();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c74(s1, s2, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$parseConditionalExpression();
								}

								return s0;
							}

							function peg$parseAssignmentOperator() {
								var s0;

								s0 = peg$parseEQU();
								if (s0 === peg$FAILED) {
									s0 = peg$parsePLUSEQU();
									if (s0 === peg$FAILED) {
										s0 = peg$parseMINUSEQU();
										if (s0 === peg$FAILED) {
											s0 = peg$parseSTAREQU();
											if (s0 === peg$FAILED) {
												s0 = peg$parseDIVEQU();
												if (s0 === peg$FAILED) {
													s0 = peg$parseANDEQU();
													if (s0 === peg$FAILED) {
														s0 = peg$parseOREQU();
														if (s0 === peg$FAILED) {
															s0 = peg$parseHATEQU();
															if (s0 === peg$FAILED) {
																s0 = peg$parseMODEQU();
																if (s0 === peg$FAILED) {
																	s0 = peg$parseSLEQU();
																	if (s0 === peg$FAILED) {
																		s0 = peg$parseSREQU();
																		if (s0 === peg$FAILED) {
																			s0 = peg$parseBSREQU();
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}

								return s0;
							}

							function peg$parseConditionalExpression() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseConditionalOrExpression();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseQUERY();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseExpression();
										if (s3 !== peg$FAILED) {
											s4 = peg$parseCOLON();
											if (s4 !== peg$FAILED) {
												s5 = peg$parseConditionalExpression();
												if (s5 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c75(s1, s3, s5);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$parseConditionalOrExpression();
								}

								return s0;
							}

							function peg$parseConditionalOrExpression() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseConditionalAndExpression();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseOROR();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseConditionalAndExpression();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseOROR();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseConditionalAndExpression();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c76(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseConditionalAndExpression() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseInclusiveOrExpression();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseANDAND();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseInclusiveOrExpression();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseANDAND();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseInclusiveOrExpression();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c76(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseInclusiveOrExpression() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseExclusiveOrExpression();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseOR();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseExclusiveOrExpression();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseOR();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseExclusiveOrExpression();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c76(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseExclusiveOrExpression() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseAndExpression();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseHAT();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseAndExpression();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseHAT();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseAndExpression();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c76(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseAndExpression() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseEqualityExpression();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseAND();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseEqualityExpression();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseAND();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseEqualityExpression();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c76(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseEqualityExpression() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseRelationalExpression();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseEQUAL();
									if (s4 === peg$FAILED) {
										s4 = peg$parseNOTEQUAL();
									}
									if (s4 !== peg$FAILED) {
										s5 = peg$parseRelationalExpression();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseEQUAL();
										if (s4 === peg$FAILED) {
											s4 = peg$parseNOTEQUAL();
										}
										if (s4 !== peg$FAILED) {
											s5 = peg$parseRelationalExpression();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c76(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseRelationalExpression() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseShiftExpression();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseLE();
									if (s4 === peg$FAILED) {
										s4 = peg$parseGE();
										if (s4 === peg$FAILED) {
											s4 = peg$parseLT();
											if (s4 === peg$FAILED) {
												s4 = peg$parseGT();
											}
										}
									}
									if (s4 !== peg$FAILED) {
										s5 = peg$parseShiftExpression();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									if (s3 === peg$FAILED) {
										s3 = peg$currPos;
										s4 = peg$parseINSTANCEOF();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseReferenceType();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseLE();
										if (s4 === peg$FAILED) {
											s4 = peg$parseGE();
											if (s4 === peg$FAILED) {
												s4 = peg$parseLT();
												if (s4 === peg$FAILED) {
													s4 = peg$parseGT();
												}
											}
										}
										if (s4 !== peg$FAILED) {
											s5 = peg$parseShiftExpression();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
										if (s3 === peg$FAILED) {
											s3 = peg$currPos;
											s4 = peg$parseINSTANCEOF();
											if (s4 !== peg$FAILED) {
												s5 = peg$parseReferenceType();
												if (s5 !== peg$FAILED) {
													s4 = [s4, s5];
													s3 = s4;
												} else {
													peg$currPos = s3;
													s3 = peg$FAILED;
												}
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c77(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseShiftExpression() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseAdditiveExpression();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseSL();
									if (s4 === peg$FAILED) {
										s4 = peg$parseSR();
										if (s4 === peg$FAILED) {
											s4 = peg$parseBSR();
										}
									}
									if (s4 !== peg$FAILED) {
										s5 = peg$parseAdditiveExpression();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseSL();
										if (s4 === peg$FAILED) {
											s4 = peg$parseSR();
											if (s4 === peg$FAILED) {
												s4 = peg$parseBSR();
											}
										}
										if (s4 !== peg$FAILED) {
											s5 = peg$parseAdditiveExpression();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c76(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseAdditiveExpression() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseMultiplicativeExpression();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parsePLUS();
									if (s4 === peg$FAILED) {
										s4 = peg$parseMINUS();
									}
									if (s4 !== peg$FAILED) {
										s5 = peg$parseMultiplicativeExpression();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parsePLUS();
										if (s4 === peg$FAILED) {
											s4 = peg$parseMINUS();
										}
										if (s4 !== peg$FAILED) {
											s5 = peg$parseMultiplicativeExpression();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c76(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseMultiplicativeExpression() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseUnaryExpression();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseSTAR();
									if (s4 === peg$FAILED) {
										s4 = peg$parseDIV();
										if (s4 === peg$FAILED) {
											s4 = peg$parseMOD();
										}
									}
									if (s4 !== peg$FAILED) {
										s5 = peg$parseUnaryExpression();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseSTAR();
										if (s4 === peg$FAILED) {
											s4 = peg$parseDIV();
											if (s4 === peg$FAILED) {
												s4 = peg$parseMOD();
											}
										}
										if (s4 !== peg$FAILED) {
											s5 = peg$parseUnaryExpression();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c76(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseUnaryExpression() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parsePrefixOp();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseUnaryExpression();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c78(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$parseUnaryExpressionNotPlusMinus();
								}

								return s0;
							}

							function peg$parseUnaryExpressionNotPlusMinus() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseCastExpression();
								if (s1 !== peg$FAILED) {
									peg$savedPos = s0;
									s1 = peg$c79(s1);
								}
								s0 = s1;
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parsePrimary();
									if (s1 !== peg$FAILED) {
										s2 = peg$parseSelector();
										if (s2 !== peg$FAILED) {
											s3 = [];
											s4 = peg$parseSelector();
											while (s4 !== peg$FAILED) {
												s3.push(s4);
												s4 = peg$parseSelector();
											}
											if (s3 !== peg$FAILED) {
												s4 = [];
												s5 = peg$parsePostfixOp();
												if (s5 !== peg$FAILED) {
													while (s5 !== peg$FAILED) {
														s4.push(s5);
														s5 = peg$parsePostfixOp();
													}
												} else {
													s4 = peg$FAILED;
												}
												if (s4 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c80(s1, s2, s3, s4);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
									if (s0 === peg$FAILED) {
										s0 = peg$currPos;
										s1 = peg$parsePrimary();
										if (s1 !== peg$FAILED) {
											s2 = peg$parseSelector();
											if (s2 !== peg$FAILED) {
												s3 = [];
												s4 = peg$parseSelector();
												while (s4 !== peg$FAILED) {
													s3.push(s4);
													s4 = peg$parseSelector();
												}
												if (s3 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c81(s1, s2, s3);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
										if (s0 === peg$FAILED) {
											s0 = peg$currPos;
											s1 = peg$parsePrimary();
											if (s1 !== peg$FAILED) {
												s2 = [];
												s3 = peg$parsePostfixOp();
												if (s3 !== peg$FAILED) {
													while (s3 !== peg$FAILED) {
														s2.push(s3);
														s3 = peg$parsePostfixOp();
													}
												} else {
													s2 = peg$FAILED;
												}
												if (s2 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c82(s1, s2);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
											if (s0 === peg$FAILED) {
												s0 = peg$parsePrimary();
											}
										}
									}
								}

								return s0;
							}

							function peg$parseCastExpression() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = peg$parseLPAR();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseBasicType();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseRPAR();
										if (s3 !== peg$FAILED) {
											s4 = peg$parseUnaryExpression();
											if (s4 !== peg$FAILED) {
												s1 = [s1, s2, s3, s4];
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseLPAR();
									if (s1 !== peg$FAILED) {
										s2 = peg$parseReferenceType();
										if (s2 !== peg$FAILED) {
											s3 = peg$parseRPAR();
											if (s3 !== peg$FAILED) {
												s4 = peg$parseUnaryExpressionNotPlusMinus();
												if (s4 !== peg$FAILED) {
													s1 = [s1, s2, s3, s4];
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								}

								return s0;
							}

							function peg$parsePrimary() {
								var s0, s1, s2, s3, s4;

								s0 = peg$parseParExpression();
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseNonWildcardTypeArguments();
									if (s1 !== peg$FAILED) {
										s2 = peg$parseExplicitGenericInvocationSuffix();
										if (s2 === peg$FAILED) {
											s2 = peg$currPos;
											s3 = peg$parseTHIS();
											if (s3 !== peg$FAILED) {
												s4 = peg$parseArguments();
												if (s4 !== peg$FAILED) {
													peg$savedPos = s2;
													s3 = peg$c83(s1, s4);
													s2 = s3;
												} else {
													peg$currPos = s2;
													s2 = peg$FAILED;
												}
											} else {
												peg$currPos = s2;
												s2 = peg$FAILED;
											}
										}
										if (s2 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c84(s1, s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
									if (s0 === peg$FAILED) {
										s0 = peg$currPos;
										s1 = peg$parseTHIS();
										if (s1 !== peg$FAILED) {
											s2 = peg$parseArguments();
											if (s2 === peg$FAILED) {
												s2 = null;
											}
											if (s2 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c85(s2);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
										if (s0 === peg$FAILED) {
											s0 = peg$currPos;
											s1 = peg$parseSUPER();
											if (s1 !== peg$FAILED) {
												s2 = peg$parseSuperSuffix();
												if (s2 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c86(s2);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
											if (s0 === peg$FAILED) {
												s0 = peg$parseLiteral();
												if (s0 === peg$FAILED) {
													s0 = peg$currPos;
													s1 = peg$parseNEW();
													if (s1 !== peg$FAILED) {
														s2 = peg$parseCreator();
														if (s2 !== peg$FAILED) {
															peg$savedPos = s0;
															s1 = peg$c87(s2);
															s0 = s1;
														} else {
															peg$currPos = s0;
															s0 = peg$FAILED;
														}
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
													if (s0 === peg$FAILED) {
														s0 = peg$parseQualifiedIdentifierSuffix();
														if (s0 === peg$FAILED) {
															s0 = peg$parseQualifiedIdentifier();
															if (s0 === peg$FAILED) {
																s0 = peg$currPos;
																s1 = peg$parseBasicType();
																if (s1 !== peg$FAILED) {
																	s2 = [];
																	s3 = peg$parseDim();
																	while (s3 !== peg$FAILED) {
																		s2.push(s3);
																		s3 = peg$parseDim();
																	}
																	if (s2 !== peg$FAILED) {
																		s3 = peg$parseDOT();
																		if (s3 !== peg$FAILED) {
																			s4 = peg$parseCLASS();
																			if (s4 !== peg$FAILED) {
																				peg$savedPos = s0;
																				s1 = peg$c88(s1, s2);
																				s0 = s1;
																			} else {
																				peg$currPos = s0;
																				s0 = peg$FAILED;
																			}
																		} else {
																			peg$currPos = s0;
																			s0 = peg$FAILED;
																		}
																	} else {
																		peg$currPos = s0;
																		s0 = peg$FAILED;
																	}
																} else {
																	peg$currPos = s0;
																	s0 = peg$FAILED;
																}
																if (s0 === peg$FAILED) {
																	s0 = peg$currPos;
																	s1 = peg$parseVOID();
																	if (s1 !== peg$FAILED) {
																		s2 = peg$parseDOT();
																		if (s2 !== peg$FAILED) {
																			s3 = peg$parseCLASS();
																			if (s3 !== peg$FAILED) {
																				peg$savedPos = s0;
																				s1 = peg$c89();
																				s0 = s1;
																			} else {
																				peg$currPos = s0;
																				s0 = peg$FAILED;
																			}
																		} else {
																			peg$currPos = s0;
																			s0 = peg$FAILED;
																		}
																	} else {
																		peg$currPos = s0;
																		s0 = peg$FAILED;
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}

								return s0;
							}

							function peg$parseQualifiedIdentifierSuffix() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseQualifiedIdentifier();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$parseDim();
									if (s3 !== peg$FAILED) {
										while (s3 !== peg$FAILED) {
											s2.push(s3);
											s3 = peg$parseDim();
										}
									} else {
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseDOT();
										if (s3 !== peg$FAILED) {
											s4 = peg$parseCLASS();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c90(s1, s2);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseQualifiedIdentifier();
									if (s1 !== peg$FAILED) {
										s2 = peg$parseLBRK();
										if (s2 !== peg$FAILED) {
											s3 = peg$parseExpression();
											if (s3 !== peg$FAILED) {
												s4 = peg$parseRBRK();
												if (s4 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c91(s1, s3);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
									if (s0 === peg$FAILED) {
										s0 = peg$currPos;
										s1 = peg$parseQualifiedIdentifier();
										if (s1 !== peg$FAILED) {
											s2 = peg$parseArguments();
											if (s2 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c92(s1, s2);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
										if (s0 === peg$FAILED) {
											s0 = peg$currPos;
											s1 = peg$parseQualifiedIdentifier();
											if (s1 !== peg$FAILED) {
												s2 = peg$parseDOT();
												if (s2 !== peg$FAILED) {
													s3 = peg$parseCLASS();
													if (s3 !== peg$FAILED) {
														peg$savedPos = s0;
														s1 = peg$c93(s1);
														s0 = s1;
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
											if (s0 === peg$FAILED) {
												s0 = peg$currPos;
												s1 = peg$parseQualifiedIdentifier();
												if (s1 !== peg$FAILED) {
													s2 = peg$parseDOT();
													if (s2 !== peg$FAILED) {
														s3 = peg$parseExplicitGenericInvocation();
														if (s3 !== peg$FAILED) {
															peg$savedPos = s0;
															s1 = peg$c94(s1, s3);
															s0 = s1;
														} else {
															peg$currPos = s0;
															s0 = peg$FAILED;
														}
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
												if (s0 === peg$FAILED) {
													s0 = peg$currPos;
													s1 = peg$parseQualifiedIdentifier();
													if (s1 !== peg$FAILED) {
														s2 = peg$parseDOT();
														if (s2 !== peg$FAILED) {
															s3 = peg$parseTHIS();
															if (s3 !== peg$FAILED) {
																peg$savedPos = s0;
																s1 = peg$c95(s1);
																s0 = s1;
															} else {
																peg$currPos = s0;
																s0 = peg$FAILED;
															}
														} else {
															peg$currPos = s0;
															s0 = peg$FAILED;
														}
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
													if (s0 === peg$FAILED) {
														s0 = peg$currPos;
														s1 = peg$parseQualifiedIdentifier();
														if (s1 !== peg$FAILED) {
															s2 = peg$parseDOT();
															if (s2 !== peg$FAILED) {
																s3 = peg$parseSUPER();
																if (s3 !== peg$FAILED) {
																	s4 = peg$parseArguments();
																	if (s4 !== peg$FAILED) {
																		peg$savedPos = s0;
																		s1 = peg$c96(s1, s4);
																		s0 = s1;
																	} else {
																		peg$currPos = s0;
																		s0 = peg$FAILED;
																	}
																} else {
																	peg$currPos = s0;
																	s0 = peg$FAILED;
																}
															} else {
																peg$currPos = s0;
																s0 = peg$FAILED;
															}
														} else {
															peg$currPos = s0;
															s0 = peg$FAILED;
														}
														if (s0 === peg$FAILED) {
															s0 = peg$currPos;
															s1 = peg$parseQualifiedIdentifier();
															if (s1 !== peg$FAILED) {
																s2 = peg$parseDOT();
																if (s2 !== peg$FAILED) {
																	s3 = peg$parseNEW();
																	if (s3 !== peg$FAILED) {
																		s4 = peg$parseNonWildcardTypeArguments();
																		if (s4 === peg$FAILED) {
																			s4 = null;
																		}
																		if (s4 !== peg$FAILED) {
																			s5 = peg$parseInnerCreator();
																			if (s5 !== peg$FAILED) {
																				peg$savedPos = s0;
																				s1 = peg$c97(s1, s4, s5);
																				s0 = s1;
																			} else {
																				peg$currPos = s0;
																				s0 = peg$FAILED;
																			}
																		} else {
																			peg$currPos = s0;
																			s0 = peg$FAILED;
																		}
																	} else {
																		peg$currPos = s0;
																		s0 = peg$FAILED;
																	}
																} else {
																	peg$currPos = s0;
																	s0 = peg$FAILED;
																}
															} else {
																peg$currPos = s0;
																s0 = peg$FAILED;
															}
														}
													}
												}
											}
										}
									}
								}

								return s0;
							}

							function peg$parseExplicitGenericInvocation() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parseNonWildcardTypeArguments();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseExplicitGenericInvocationSuffix();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c84(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseNonWildcardTypeArguments() {
								var s0, s1, s2, s3, s4, s5, s6;

								s0 = peg$currPos;
								s1 = peg$parseLPOINT();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseReferenceType();
									if (s2 !== peg$FAILED) {
										s3 = [];
										s4 = peg$currPos;
										s5 = peg$parseCOMMA();
										if (s5 !== peg$FAILED) {
											s6 = peg$parseReferenceType();
											if (s6 !== peg$FAILED) {
												s5 = [s5, s6];
												s4 = s5;
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
										} else {
											peg$currPos = s4;
											s4 = peg$FAILED;
										}
										while (s4 !== peg$FAILED) {
											s3.push(s4);
											s4 = peg$currPos;
											s5 = peg$parseCOMMA();
											if (s5 !== peg$FAILED) {
												s6 = peg$parseReferenceType();
												if (s6 !== peg$FAILED) {
													s5 = [s5, s6];
													s4 = s5;
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseRPOINT();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c29(s2, s3);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseTypeArgumentsOrDiamond() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parseLPOINT();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseRPOINT();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c98();
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$parseTypeArguments();
								}

								return s0;
							}

							function peg$parseNonWildcardTypeArgumentsOrDiamond() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parseLPOINT();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseRPOINT();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$parseNonWildcardTypeArguments();
								}

								return s0;
							}

							function peg$parseExplicitGenericInvocationSuffix() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parseSUPER();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSuperSuffix();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c99(s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseIdentifier();
									if (s1 !== peg$FAILED) {
										s2 = peg$parseArguments();
										if (s2 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c100(s1, s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								}

								return s0;
							}

							function peg$parsePrefixOp() {
								var s0, s1;

								s0 = peg$currPos;
								s1 = peg$parseINC();
								if (s1 === peg$FAILED) {
									s1 = peg$parseDEC();
									if (s1 === peg$FAILED) {
										s1 = peg$parseBANG();
										if (s1 === peg$FAILED) {
											s1 = peg$parseTILDA();
											if (s1 === peg$FAILED) {
												s1 = peg$parsePLUS();
												if (s1 === peg$FAILED) {
													s1 = peg$parseMINUS();
												}
											}
										}
									}
								}
								if (s1 !== peg$FAILED) {
									peg$savedPos = s0;
									s1 = peg$c101(s1);
								}
								s0 = s1;

								return s0;
							}

							function peg$parsePostfixOp() {
								var s0, s1;

								s0 = peg$currPos;
								s1 = peg$parseINC();
								if (s1 === peg$FAILED) {
									s1 = peg$parseDEC();
								}
								if (s1 !== peg$FAILED) {
									peg$savedPos = s0;
									s1 = peg$c101(s1);
								}
								s0 = s1;

								return s0;
							}

							function peg$parseSelector() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = peg$parseDOT();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseIdentifier();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseArguments();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c100(s2, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseDOT();
									if (s1 !== peg$FAILED) {
										s2 = peg$parseIdentifier();
										if (s2 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c102(s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
									if (s0 === peg$FAILED) {
										s0 = peg$currPos;
										s1 = peg$parseDOT();
										if (s1 !== peg$FAILED) {
											s2 = peg$parseExplicitGenericInvocation();
											if (s2 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c103(s2);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
										if (s0 === peg$FAILED) {
											s0 = peg$currPos;
											s1 = peg$parseDOT();
											if (s1 !== peg$FAILED) {
												s2 = peg$parseTHIS();
												if (s2 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c104();
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
											if (s0 === peg$FAILED) {
												s0 = peg$currPos;
												s1 = peg$parseDOT();
												if (s1 !== peg$FAILED) {
													s2 = peg$parseSUPER();
													if (s2 !== peg$FAILED) {
														s3 = peg$parseSuperSuffix();
														if (s3 !== peg$FAILED) {
															peg$savedPos = s0;
															s1 = peg$c99(s3);
															s0 = s1;
														} else {
															peg$currPos = s0;
															s0 = peg$FAILED;
														}
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
												if (s0 === peg$FAILED) {
													s0 = peg$currPos;
													s1 = peg$parseDOT();
													if (s1 !== peg$FAILED) {
														s2 = peg$parseNEW();
														if (s2 !== peg$FAILED) {
															s3 = peg$parseNonWildcardTypeArguments();
															if (s3 === peg$FAILED) {
																s3 = null;
															}
															if (s3 !== peg$FAILED) {
																s4 = peg$parseInnerCreator();
																if (s4 !== peg$FAILED) {
																	peg$savedPos = s0;
																	s1 = peg$c105(s3, s4);
																	s0 = s1;
																} else {
																	peg$currPos = s0;
																	s0 = peg$FAILED;
																}
															} else {
																peg$currPos = s0;
																s0 = peg$FAILED;
															}
														} else {
															peg$currPos = s0;
															s0 = peg$FAILED;
														}
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
													if (s0 === peg$FAILED) {
														s0 = peg$currPos;
														s1 = peg$parseDimExpr();
														if (s1 !== peg$FAILED) {
															peg$savedPos = s0;
															s1 = peg$c106(s1);
														}
														s0 = s1;
													}
												}
											}
										}
									}
								}

								return s0;
							}

							function peg$parseSuperSuffix() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = peg$parseArguments();
								if (s1 !== peg$FAILED) {
									peg$savedPos = s0;
									s1 = peg$c107(s1);
								}
								s0 = s1;
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseDOT();
									if (s1 !== peg$FAILED) {
										s2 = peg$parseNonWildcardTypeArguments();
										if (s2 === peg$FAILED) {
											s2 = null;
										}
										if (s2 !== peg$FAILED) {
											s3 = peg$parseIdentifier();
											if (s3 !== peg$FAILED) {
												s4 = peg$parseArguments();
												if (s4 === peg$FAILED) {
													s4 = null;
												}
												if (s4 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c108(s2, s3, s4);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								}

								return s0;
							}

							function peg$parseBasicType() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 4) === peg$c109) {
									s1 = peg$c109;
									peg$currPos += 4;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c110);
									}
								}
								if (s1 === peg$FAILED) {
									if (input.substr(peg$currPos, 5) === peg$c111) {
										s1 = peg$c111;
										peg$currPos += 5;
									} else {
										s1 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c112);
										}
									}
									if (s1 === peg$FAILED) {
										if (input.substr(peg$currPos, 4) === peg$c113) {
											s1 = peg$c113;
											peg$currPos += 4;
										} else {
											s1 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c114);
											}
										}
										if (s1 === peg$FAILED) {
											if (input.substr(peg$currPos, 3) === peg$c115) {
												s1 = peg$c115;
												peg$currPos += 3;
											} else {
												s1 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c116);
												}
											}
											if (s1 === peg$FAILED) {
												if (input.substr(peg$currPos, 4) === peg$c117) {
													s1 = peg$c117;
													peg$currPos += 4;
												} else {
													s1 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c118);
													}
												}
												if (s1 === peg$FAILED) {
													if (input.substr(peg$currPos, 5) === peg$c119) {
														s1 = peg$c119;
														peg$currPos += 5;
													} else {
														s1 = peg$FAILED;
														if (peg$silentFails === 0) {
															peg$fail(peg$c120);
														}
													}
													if (s1 === peg$FAILED) {
														if (input.substr(peg$currPos, 6) === peg$c121) {
															s1 = peg$c121;
															peg$currPos += 6;
														} else {
															s1 = peg$FAILED;
															if (peg$silentFails === 0) {
																peg$fail(peg$c122);
															}
														}
														if (s1 === peg$FAILED) {
															if (input.substr(peg$currPos, 7) === peg$c123) {
																s1 = peg$c123;
																peg$currPos += 7;
															} else {
																s1 = peg$FAILED;
																if (peg$silentFails === 0) {
																	peg$fail(peg$c124);
																}
															}
														}
													}
												}
											}
										}
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c125(s1);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseArguments() {
								var s0, s1, s2, s3, s4, s5, s6, s7;

								s0 = peg$currPos;
								s1 = peg$parseLPAR();
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									s3 = peg$parseExpression();
									if (s3 !== peg$FAILED) {
										s4 = [];
										s5 = peg$currPos;
										s6 = peg$parseCOMMA();
										if (s6 !== peg$FAILED) {
											s7 = peg$parseExpression();
											if (s7 !== peg$FAILED) {
												s6 = [s6, s7];
												s5 = s6;
											} else {
												peg$currPos = s5;
												s5 = peg$FAILED;
											}
										} else {
											peg$currPos = s5;
											s5 = peg$FAILED;
										}
										while (s5 !== peg$FAILED) {
											s4.push(s5);
											s5 = peg$currPos;
											s6 = peg$parseCOMMA();
											if (s6 !== peg$FAILED) {
												s7 = peg$parseExpression();
												if (s7 !== peg$FAILED) {
													s6 = [s6, s7];
													s5 = s6;
												} else {
													peg$currPos = s5;
													s5 = peg$FAILED;
												}
											} else {
												peg$currPos = s5;
												s5 = peg$FAILED;
											}
										}
										if (s4 !== peg$FAILED) {
											peg$savedPos = s2;
											s3 = peg$c29(s3, s4);
											s2 = s3;
										} else {
											peg$currPos = s2;
											s2 = peg$FAILED;
										}
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseRPAR();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c126(s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseCreator() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseBasicType();
								if (s1 === peg$FAILED) {
									s1 = peg$parseCreatedName();
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseArrayCreatorRest();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c127(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseNonWildcardTypeArguments();
									if (s1 === peg$FAILED) {
										s1 = null;
									}
									if (s1 !== peg$FAILED) {
										s2 = peg$parseCreatedName();
										if (s2 !== peg$FAILED) {
											s3 = peg$parseClassCreatorRest();
											if (s3 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c128(s1, s2, s3);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								}

								return s0;
							}

							function peg$parseCreatedName() {
								var s0, s1, s2, s3, s4, s5, s6, s7;

								s0 = peg$currPos;
								s1 = peg$parseQualifiedIdentifier();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseTypeArgumentsOrDiamond();
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = [];
										s4 = peg$currPos;
										s5 = peg$parseDOT();
										if (s5 !== peg$FAILED) {
											s6 = peg$parseIdentifier();
											if (s6 !== peg$FAILED) {
												s7 = peg$parseTypeArgumentsOrDiamond();
												if (s7 === peg$FAILED) {
													s7 = null;
												}
												if (s7 !== peg$FAILED) {
													s5 = [s5, s6, s7];
													s4 = s5;
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
										} else {
											peg$currPos = s4;
											s4 = peg$FAILED;
										}
										while (s4 !== peg$FAILED) {
											s3.push(s4);
											s4 = peg$currPos;
											s5 = peg$parseDOT();
											if (s5 !== peg$FAILED) {
												s6 = peg$parseIdentifier();
												if (s6 !== peg$FAILED) {
													s7 = peg$parseTypeArgumentsOrDiamond();
													if (s7 === peg$FAILED) {
														s7 = null;
													}
													if (s7 !== peg$FAILED) {
														s5 = [s5, s6, s7];
														s4 = s5;
													} else {
														peg$currPos = s4;
														s4 = peg$FAILED;
													}
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
										}
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c129(s1, s2, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseInnerCreator() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseIdentifier();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseNonWildcardTypeArgumentsOrDiamond();
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseClassCreatorRest();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c130(s1, s2, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseClassCreatorRest() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parseArguments();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseClassBody();
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c131(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseArrayCreatorRest() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = [];
								s2 = peg$parseDim();
								if (s2 !== peg$FAILED) {
									while (s2 !== peg$FAILED) {
										s1.push(s2);
										s2 = peg$parseDim();
									}
								} else {
									s1 = peg$FAILED;
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseArrayInitializer();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c132(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = [];
									s2 = peg$parseDimExpr();
									if (s2 !== peg$FAILED) {
										while (s2 !== peg$FAILED) {
											s1.push(s2);
											s2 = peg$parseDimExpr();
										}
									} else {
										s1 = peg$FAILED;
									}
									if (s1 !== peg$FAILED) {
										s2 = [];
										s3 = peg$parseDim();
										while (s3 !== peg$FAILED) {
											s2.push(s3);
											s3 = peg$parseDim();
										}
										if (s2 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c133(s1, s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
									if (s0 === peg$FAILED) {
										s0 = peg$currPos;
										s1 = peg$parseDim();
										if (s1 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c134(s1);
										}
										s0 = s1;
									}
								}

								return s0;
							}

							function peg$parseArrayInitializer() {
								var s0, s1, s2, s3, s4, s5, s6, s7;

								s0 = peg$currPos;
								s1 = peg$parseLWING();
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									s3 = peg$parseVariableInitializer();
									if (s3 !== peg$FAILED) {
										s4 = [];
										s5 = peg$currPos;
										s6 = peg$parseCOMMA();
										if (s6 !== peg$FAILED) {
											s7 = peg$parseVariableInitializer();
											if (s7 !== peg$FAILED) {
												s6 = [s6, s7];
												s5 = s6;
											} else {
												peg$currPos = s5;
												s5 = peg$FAILED;
											}
										} else {
											peg$currPos = s5;
											s5 = peg$FAILED;
										}
										while (s5 !== peg$FAILED) {
											s4.push(s5);
											s5 = peg$currPos;
											s6 = peg$parseCOMMA();
											if (s6 !== peg$FAILED) {
												s7 = peg$parseVariableInitializer();
												if (s7 !== peg$FAILED) {
													s6 = [s6, s7];
													s5 = s6;
												} else {
													peg$currPos = s5;
													s5 = peg$FAILED;
												}
											} else {
												peg$currPos = s5;
												s5 = peg$FAILED;
											}
										}
										if (s4 !== peg$FAILED) {
											peg$savedPos = s2;
											s3 = peg$c29(s3, s4);
											s2 = s3;
										} else {
											peg$currPos = s2;
											s2 = peg$FAILED;
										}
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseCOMMA();
										if (s3 === peg$FAILED) {
											s3 = null;
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseRWING();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c135(s2);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseVariableInitializer() {
								var s0;

								s0 = peg$parseArrayInitializer();
								if (s0 === peg$FAILED) {
									s0 = peg$parseExpression();
								}

								return s0;
							}

							function peg$parseParExpression() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseLPAR();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseExpression();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseRPAR();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c136(s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseQualifiedIdentifier() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseIdentifier();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseDOT();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseIdentifier();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseDOT();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseIdentifier();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c137(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseDim() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parseLBRK();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseRBRK();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseDimExpr() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseLBRK();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseExpression();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseRBRK();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c138(s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseType() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseBasicType();
								if (s1 === peg$FAILED) {
									s1 = peg$parseClassType();
								}
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$parseDim();
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$parseDim();
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c139(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseReferenceType() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseBasicType();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$parseDim();
									if (s3 !== peg$FAILED) {
										while (s3 !== peg$FAILED) {
											s2.push(s3);
											s3 = peg$parseDim();
										}
									} else {
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c140(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseClassType();
									if (s1 !== peg$FAILED) {
										s2 = [];
										s3 = peg$parseDim();
										while (s3 !== peg$FAILED) {
											s2.push(s3);
											s3 = peg$parseDim();
										}
										if (s2 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c141(s1, s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								}

								return s0;
							}

							function peg$parseClassType() {
								var s0, s1, s2, s3, s4, s5, s6, s7;

								s0 = peg$currPos;
								s1 = peg$parseQualifiedIdentifier();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseTypeArguments();
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = [];
										s4 = peg$currPos;
										s5 = peg$parseDOT();
										if (s5 !== peg$FAILED) {
											s6 = peg$parseIdentifier();
											if (s6 !== peg$FAILED) {
												s7 = peg$parseTypeArguments();
												if (s7 === peg$FAILED) {
													s7 = null;
												}
												if (s7 !== peg$FAILED) {
													s5 = [s5, s6, s7];
													s4 = s5;
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
										} else {
											peg$currPos = s4;
											s4 = peg$FAILED;
										}
										while (s4 !== peg$FAILED) {
											s3.push(s4);
											s4 = peg$currPos;
											s5 = peg$parseDOT();
											if (s5 !== peg$FAILED) {
												s6 = peg$parseIdentifier();
												if (s6 !== peg$FAILED) {
													s7 = peg$parseTypeArguments();
													if (s7 === peg$FAILED) {
														s7 = null;
													}
													if (s7 !== peg$FAILED) {
														s5 = [s5, s6, s7];
														s4 = s5;
													} else {
														peg$currPos = s4;
														s4 = peg$FAILED;
													}
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
										}
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c129(s1, s2, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseClassTypeList() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseClassType();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseCOMMA();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseClassType();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseCOMMA();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseClassType();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c29(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseTypeArguments() {
								var s0, s1, s2, s3, s4, s5, s6;

								s0 = peg$currPos;
								s1 = peg$parseLPOINT();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseTypeArgument();
									if (s2 !== peg$FAILED) {
										s3 = [];
										s4 = peg$currPos;
										s5 = peg$parseCOMMA();
										if (s5 !== peg$FAILED) {
											s6 = peg$parseTypeArgument();
											if (s6 !== peg$FAILED) {
												s5 = [s5, s6];
												s4 = s5;
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
										} else {
											peg$currPos = s4;
											s4 = peg$FAILED;
										}
										while (s4 !== peg$FAILED) {
											s3.push(s4);
											s4 = peg$currPos;
											s5 = peg$parseCOMMA();
											if (s5 !== peg$FAILED) {
												s6 = peg$parseTypeArgument();
												if (s6 !== peg$FAILED) {
													s5 = [s5, s6];
													s4 = s5;
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseRPOINT();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c29(s2, s3);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseTypeArgument() {
								var s0, s1, s2, s3, s4;

								s0 = peg$parseReferenceType();
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseQUERY();
									if (s1 !== peg$FAILED) {
										s2 = peg$currPos;
										s3 = peg$currPos;
										s4 = peg$parseEXTENDS();
										if (s4 !== peg$FAILED) {
											peg$savedPos = s3;
											s4 = peg$c142();
										}
										s3 = s4;
										if (s3 === peg$FAILED) {
											s3 = peg$currPos;
											s4 = peg$parseSUPER();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s3;
												s4 = peg$c143();
											}
											s3 = s4;
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseReferenceType();
											if (s4 !== peg$FAILED) {
												s3 = [s3, s4];
												s2 = s3;
											} else {
												peg$currPos = s2;
												s2 = peg$FAILED;
											}
										} else {
											peg$currPos = s2;
											s2 = peg$FAILED;
										}
										if (s2 === peg$FAILED) {
											s2 = null;
										}
										if (s2 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c144(s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								}

								return s0;
							}

							function peg$parseTypeParameters() {
								var s0, s1, s2, s3, s4, s5, s6;

								s0 = peg$currPos;
								s1 = peg$parseLPOINT();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseTypeParameter();
									if (s2 !== peg$FAILED) {
										s3 = [];
										s4 = peg$currPos;
										s5 = peg$parseCOMMA();
										if (s5 !== peg$FAILED) {
											s6 = peg$parseTypeParameter();
											if (s6 !== peg$FAILED) {
												s5 = [s5, s6];
												s4 = s5;
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
										} else {
											peg$currPos = s4;
											s4 = peg$FAILED;
										}
										while (s4 !== peg$FAILED) {
											s3.push(s4);
											s4 = peg$currPos;
											s5 = peg$parseCOMMA();
											if (s5 !== peg$FAILED) {
												s6 = peg$parseTypeParameter();
												if (s6 !== peg$FAILED) {
													s5 = [s5, s6];
													s4 = s5;
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseRPOINT();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c29(s2, s3);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseTypeParameter() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = peg$parseIdentifier();
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									s3 = peg$parseEXTENDS();
									if (s3 !== peg$FAILED) {
										s4 = peg$parseBound();
										if (s4 !== peg$FAILED) {
											s3 = [s3, s4];
											s2 = s3;
										} else {
											peg$currPos = s2;
											s2 = peg$FAILED;
										}
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c145(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseBound() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseClassType();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseAND();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseClassType();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseAND();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseClassType();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c29(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseModifier() {
								var s0, s1, s2, s3;

								s0 = peg$parseAnnotation();
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									if (input.substr(peg$currPos, 6) === peg$c146) {
										s1 = peg$c146;
										peg$currPos += 6;
									} else {
										s1 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c147);
										}
									}
									if (s1 === peg$FAILED) {
										if (input.substr(peg$currPos, 9) === peg$c148) {
											s1 = peg$c148;
											peg$currPos += 9;
										} else {
											s1 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c149);
											}
										}
										if (s1 === peg$FAILED) {
											if (input.substr(peg$currPos, 7) === peg$c150) {
												s1 = peg$c150;
												peg$currPos += 7;
											} else {
												s1 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c151);
												}
											}
											if (s1 === peg$FAILED) {
												if (input.substr(peg$currPos, 6) === peg$c152) {
													s1 = peg$c152;
													peg$currPos += 6;
												} else {
													s1 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c153);
													}
												}
												if (s1 === peg$FAILED) {
													if (input.substr(peg$currPos, 8) === peg$c154) {
														s1 = peg$c154;
														peg$currPos += 8;
													} else {
														s1 = peg$FAILED;
														if (peg$silentFails === 0) {
															peg$fail(peg$c155);
														}
													}
													if (s1 === peg$FAILED) {
														if (input.substr(peg$currPos, 5) === peg$c156) {
															s1 = peg$c156;
															peg$currPos += 5;
														} else {
															s1 = peg$FAILED;
															if (peg$silentFails === 0) {
																peg$fail(peg$c157);
															}
														}
														if (s1 === peg$FAILED) {
															if (input.substr(peg$currPos, 6) === peg$c158) {
																s1 = peg$c158;
																peg$currPos += 6;
															} else {
																s1 = peg$FAILED;
																if (peg$silentFails === 0) {
																	peg$fail(peg$c159);
																}
															}
															if (s1 === peg$FAILED) {
																if (input.substr(peg$currPos, 12) === peg$c160) {
																	s1 = peg$c160;
																	peg$currPos += 12;
																} else {
																	s1 = peg$FAILED;
																	if (peg$silentFails === 0) {
																		peg$fail(peg$c161);
																	}
																}
																if (s1 === peg$FAILED) {
																	if (input.substr(peg$currPos, 9) === peg$c162) {
																		s1 = peg$c162;
																		peg$currPos += 9;
																	} else {
																		s1 = peg$FAILED;
																		if (peg$silentFails === 0) {
																			peg$fail(peg$c163);
																		}
																	}
																	if (s1 === peg$FAILED) {
																		if (input.substr(peg$currPos, 8) === peg$c164) {
																			s1 = peg$c164;
																			peg$currPos += 8;
																		} else {
																			s1 = peg$FAILED;
																			if (peg$silentFails === 0) {
																				peg$fail(peg$c165);
																			}
																		}
																		if (s1 === peg$FAILED) {
																			if (input.substr(peg$currPos, 8) === peg$c166) {
																				s1 = peg$c166;
																				peg$currPos += 8;
																			} else {
																				s1 = peg$FAILED;
																				if (peg$silentFails === 0) {
																					peg$fail(peg$c167);
																				}
																			}
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}
									if (s1 !== peg$FAILED) {
										s2 = peg$currPos;
										peg$silentFails++;
										s3 = peg$parseLetterOrDigit();
										peg$silentFails--;
										if (s3 === peg$FAILED) {
											s2 = void 0;
										} else {
											peg$currPos = s2;
											s2 = peg$FAILED;
										}
										if (s2 !== peg$FAILED) {
											s3 = peg$parseSpacing();
											if (s3 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c168(s1);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								}

								return s0;
							}

							function peg$parseAnnotationTypeDeclaration() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = peg$parseAT();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseINTERFACE();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseIdentifier();
										if (s3 !== peg$FAILED) {
											s4 = peg$parseAnnotationTypeBody();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c169(s3, s4);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseAnnotationTypeBody() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseLWING();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$parseAnnotationTypeElementDeclaration();
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$parseAnnotationTypeElementDeclaration();
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseRWING();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c170(s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseAnnotationTypeElementDeclaration() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = [];
								s2 = peg$parseModifier();
								while (s2 !== peg$FAILED) {
									s1.push(s2);
									s2 = peg$parseModifier();
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseAnnotationTypeElementRest();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c171(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseSEMI();
									if (s1 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c3();
									}
									s0 = s1;
								}

								return s0;
							}

							function peg$parseAnnotationTypeElementRest() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseType();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseAnnotationMethodOrConstantRest();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSEMI();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c172(s1, s2);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$parseClassDeclaration();
									if (s0 === peg$FAILED) {
										s0 = peg$parseEnumDeclaration();
										if (s0 === peg$FAILED) {
											s0 = peg$parseInterfaceDeclaration();
											if (s0 === peg$FAILED) {
												s0 = peg$parseAnnotationTypeDeclaration();
											}
										}
									}
								}

								return s0;
							}

							function peg$parseAnnotationMethodOrConstantRest() {
								var s0;

								s0 = peg$parseAnnotationMethodRest();
								if (s0 === peg$FAILED) {
									s0 = peg$parseAnnotationConstantRest();
								}

								return s0;
							}

							function peg$parseAnnotationMethodRest() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = peg$parseIdentifier();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseLPAR();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseRPAR();
										if (s3 !== peg$FAILED) {
											s4 = peg$parseDefaultValue();
											if (s4 === peg$FAILED) {
												s4 = null;
											}
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c173(s1, s4);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseAnnotationConstantRest() {
								var s0, s1;

								s0 = peg$currPos;
								s1 = peg$parseVariableDeclarators();
								if (s1 !== peg$FAILED) {
									peg$savedPos = s0;
									s1 = peg$c174(s1);
								}
								s0 = s1;

								return s0;
							}

							function peg$parseDefaultValue() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parseDEFAULT();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseElementValue();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c175(s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseAnnotation() {
								var s0;

								s0 = peg$parseNormalAnnotation();
								if (s0 === peg$FAILED) {
									s0 = peg$parseSingleElementAnnotation();
									if (s0 === peg$FAILED) {
										s0 = peg$parseMarkerAnnotation();
									}
								}

								return s0;
							}

							function peg$parseNormalAnnotation() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseAT();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseQualifiedIdentifier();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseLPAR();
										if (s3 !== peg$FAILED) {
											s4 = peg$parseElementValuePairs();
											if (s4 === peg$FAILED) {
												s4 = null;
											}
											if (s4 !== peg$FAILED) {
												s5 = peg$parseRPAR();
												if (s5 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c176(s2, s4);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSingleElementAnnotation() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseAT();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseQualifiedIdentifier();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseLPAR();
										if (s3 !== peg$FAILED) {
											s4 = peg$parseElementValue();
											if (s4 !== peg$FAILED) {
												s5 = peg$parseRPAR();
												if (s5 !== peg$FAILED) {
													peg$savedPos = s0;
													s1 = peg$c177(s2, s4);
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseMarkerAnnotation() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parseAT();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseQualifiedIdentifier();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c178(s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseElementValuePairs() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseElementValuePair();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseCOMMA();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseElementValuePair();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseCOMMA();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseElementValuePair();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c29(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseElementValuePair() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseIdentifier();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseEQU();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseElementValue();
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c179(s1, s3);
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseElementValue() {
								var s0;

								s0 = peg$parseConditionalExpression();
								if (s0 === peg$FAILED) {
									s0 = peg$parseAnnotation();
									if (s0 === peg$FAILED) {
										s0 = peg$parseElementValueArrayInitializer();
									}
								}

								return s0;
							}

							function peg$parseElementValueArrayInitializer() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = peg$parseLWING();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseElementValues();
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseCOMMA();
										if (s3 === peg$FAILED) {
											s3 = null;
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseRWING();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c180(s2);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseElementValues() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseElementValue();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = peg$parseCOMMA();
									if (s4 !== peg$FAILED) {
										s5 = peg$parseElementValue();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = peg$parseCOMMA();
										if (s4 !== peg$FAILED) {
											s5 = peg$parseElementValue();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c29(s1, s2);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSpacing() {
								var s0, s1, s2, s3, s4, s5, s6;

								s0 = [];
								s1 = [];
								if (peg$c181.test(input.charAt(peg$currPos))) {
									s2 = input.charAt(peg$currPos);
									peg$currPos++;
								} else {
									s2 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c182);
									}
								}
								if (s2 !== peg$FAILED) {
									while (s2 !== peg$FAILED) {
										s1.push(s2);
										if (peg$c181.test(input.charAt(peg$currPos))) {
											s2 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s2 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c182);
											}
										}
									}
								} else {
									s1 = peg$FAILED;
								}
								if (s1 === peg$FAILED) {
									s1 = peg$currPos;
									if (input.substr(peg$currPos, 2) === peg$c183) {
										s2 = peg$c183;
										peg$currPos += 2;
									} else {
										s2 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c184);
										}
									}
									if (s2 !== peg$FAILED) {
										s3 = [];
										s4 = peg$currPos;
										s5 = peg$currPos;
										peg$silentFails++;
										if (input.substr(peg$currPos, 2) === peg$c185) {
											s6 = peg$c185;
											peg$currPos += 2;
										} else {
											s6 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c186);
											}
										}
										peg$silentFails--;
										if (s6 === peg$FAILED) {
											s5 = void 0;
										} else {
											peg$currPos = s5;
											s5 = peg$FAILED;
										}
										if (s5 !== peg$FAILED) {
											s6 = peg$parse_();
											if (s6 !== peg$FAILED) {
												s5 = [s5, s6];
												s4 = s5;
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
										} else {
											peg$currPos = s4;
											s4 = peg$FAILED;
										}
										while (s4 !== peg$FAILED) {
											s3.push(s4);
											s4 = peg$currPos;
											s5 = peg$currPos;
											peg$silentFails++;
											if (input.substr(peg$currPos, 2) === peg$c185) {
												s6 = peg$c185;
												peg$currPos += 2;
											} else {
												s6 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c186);
												}
											}
											peg$silentFails--;
											if (s6 === peg$FAILED) {
												s5 = void 0;
											} else {
												peg$currPos = s5;
												s5 = peg$FAILED;
											}
											if (s5 !== peg$FAILED) {
												s6 = peg$parse_();
												if (s6 !== peg$FAILED) {
													s5 = [s5, s6];
													s4 = s5;
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
										}
										if (s3 !== peg$FAILED) {
											if (input.substr(peg$currPos, 2) === peg$c185) {
												s4 = peg$c185;
												peg$currPos += 2;
											} else {
												s4 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c186);
												}
											}
											if (s4 !== peg$FAILED) {
												s2 = [s2, s3, s4];
												s1 = s2;
											} else {
												peg$currPos = s1;
												s1 = peg$FAILED;
											}
										} else {
											peg$currPos = s1;
											s1 = peg$FAILED;
										}
									} else {
										peg$currPos = s1;
										s1 = peg$FAILED;
									}
									if (s1 === peg$FAILED) {
										s1 = peg$currPos;
										if (input.substr(peg$currPos, 2) === peg$c187) {
											s2 = peg$c187;
											peg$currPos += 2;
										} else {
											s2 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c188);
											}
										}
										if (s2 !== peg$FAILED) {
											s3 = [];
											s4 = peg$currPos;
											s5 = peg$currPos;
											peg$silentFails++;
											if (peg$c189.test(input.charAt(peg$currPos))) {
												s6 = input.charAt(peg$currPos);
												peg$currPos++;
											} else {
												s6 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c190);
												}
											}
											peg$silentFails--;
											if (s6 === peg$FAILED) {
												s5 = void 0;
											} else {
												peg$currPos = s5;
												s5 = peg$FAILED;
											}
											if (s5 !== peg$FAILED) {
												s6 = peg$parse_();
												if (s6 !== peg$FAILED) {
													s5 = [s5, s6];
													s4 = s5;
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
											while (s4 !== peg$FAILED) {
												s3.push(s4);
												s4 = peg$currPos;
												s5 = peg$currPos;
												peg$silentFails++;
												if (peg$c189.test(input.charAt(peg$currPos))) {
													s6 = input.charAt(peg$currPos);
													peg$currPos++;
												} else {
													s6 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c190);
													}
												}
												peg$silentFails--;
												if (s6 === peg$FAILED) {
													s5 = void 0;
												} else {
													peg$currPos = s5;
													s5 = peg$FAILED;
												}
												if (s5 !== peg$FAILED) {
													s6 = peg$parse_();
													if (s6 !== peg$FAILED) {
														s5 = [s5, s6];
														s4 = s5;
													} else {
														peg$currPos = s4;
														s4 = peg$FAILED;
													}
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											}
											if (s3 !== peg$FAILED) {
												if (peg$c189.test(input.charAt(peg$currPos))) {
													s4 = input.charAt(peg$currPos);
													peg$currPos++;
												} else {
													s4 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c190);
													}
												}
												if (s4 !== peg$FAILED) {
													s2 = [s2, s3, s4];
													s1 = s2;
												} else {
													peg$currPos = s1;
													s1 = peg$FAILED;
												}
											} else {
												peg$currPos = s1;
												s1 = peg$FAILED;
											}
										} else {
											peg$currPos = s1;
											s1 = peg$FAILED;
										}
									}
								}
								while (s1 !== peg$FAILED) {
									s0.push(s1);
									s1 = [];
									if (peg$c181.test(input.charAt(peg$currPos))) {
										s2 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s2 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c182);
										}
									}
									if (s2 !== peg$FAILED) {
										while (s2 !== peg$FAILED) {
											s1.push(s2);
											if (peg$c181.test(input.charAt(peg$currPos))) {
												s2 = input.charAt(peg$currPos);
												peg$currPos++;
											} else {
												s2 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c182);
												}
											}
										}
									} else {
										s1 = peg$FAILED;
									}
									if (s1 === peg$FAILED) {
										s1 = peg$currPos;
										if (input.substr(peg$currPos, 2) === peg$c183) {
											s2 = peg$c183;
											peg$currPos += 2;
										} else {
											s2 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c184);
											}
										}
										if (s2 !== peg$FAILED) {
											s3 = [];
											s4 = peg$currPos;
											s5 = peg$currPos;
											peg$silentFails++;
											if (input.substr(peg$currPos, 2) === peg$c185) {
												s6 = peg$c185;
												peg$currPos += 2;
											} else {
												s6 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c186);
												}
											}
											peg$silentFails--;
											if (s6 === peg$FAILED) {
												s5 = void 0;
											} else {
												peg$currPos = s5;
												s5 = peg$FAILED;
											}
											if (s5 !== peg$FAILED) {
												s6 = peg$parse_();
												if (s6 !== peg$FAILED) {
													s5 = [s5, s6];
													s4 = s5;
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
											while (s4 !== peg$FAILED) {
												s3.push(s4);
												s4 = peg$currPos;
												s5 = peg$currPos;
												peg$silentFails++;
												if (input.substr(peg$currPos, 2) === peg$c185) {
													s6 = peg$c185;
													peg$currPos += 2;
												} else {
													s6 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c186);
													}
												}
												peg$silentFails--;
												if (s6 === peg$FAILED) {
													s5 = void 0;
												} else {
													peg$currPos = s5;
													s5 = peg$FAILED;
												}
												if (s5 !== peg$FAILED) {
													s6 = peg$parse_();
													if (s6 !== peg$FAILED) {
														s5 = [s5, s6];
														s4 = s5;
													} else {
														peg$currPos = s4;
														s4 = peg$FAILED;
													}
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											}
											if (s3 !== peg$FAILED) {
												if (input.substr(peg$currPos, 2) === peg$c185) {
													s4 = peg$c185;
													peg$currPos += 2;
												} else {
													s4 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c186);
													}
												}
												if (s4 !== peg$FAILED) {
													s2 = [s2, s3, s4];
													s1 = s2;
												} else {
													peg$currPos = s1;
													s1 = peg$FAILED;
												}
											} else {
												peg$currPos = s1;
												s1 = peg$FAILED;
											}
										} else {
											peg$currPos = s1;
											s1 = peg$FAILED;
										}
										if (s1 === peg$FAILED) {
											s1 = peg$currPos;
											if (input.substr(peg$currPos, 2) === peg$c187) {
												s2 = peg$c187;
												peg$currPos += 2;
											} else {
												s2 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c188);
												}
											}
											if (s2 !== peg$FAILED) {
												s3 = [];
												s4 = peg$currPos;
												s5 = peg$currPos;
												peg$silentFails++;
												if (peg$c189.test(input.charAt(peg$currPos))) {
													s6 = input.charAt(peg$currPos);
													peg$currPos++;
												} else {
													s6 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c190);
													}
												}
												peg$silentFails--;
												if (s6 === peg$FAILED) {
													s5 = void 0;
												} else {
													peg$currPos = s5;
													s5 = peg$FAILED;
												}
												if (s5 !== peg$FAILED) {
													s6 = peg$parse_();
													if (s6 !== peg$FAILED) {
														s5 = [s5, s6];
														s4 = s5;
													} else {
														peg$currPos = s4;
														s4 = peg$FAILED;
													}
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
												while (s4 !== peg$FAILED) {
													s3.push(s4);
													s4 = peg$currPos;
													s5 = peg$currPos;
													peg$silentFails++;
													if (peg$c189.test(input.charAt(peg$currPos))) {
														s6 = input.charAt(peg$currPos);
														peg$currPos++;
													} else {
														s6 = peg$FAILED;
														if (peg$silentFails === 0) {
															peg$fail(peg$c190);
														}
													}
													peg$silentFails--;
													if (s6 === peg$FAILED) {
														s5 = void 0;
													} else {
														peg$currPos = s5;
														s5 = peg$FAILED;
													}
													if (s5 !== peg$FAILED) {
														s6 = peg$parse_();
														if (s6 !== peg$FAILED) {
															s5 = [s5, s6];
															s4 = s5;
														} else {
															peg$currPos = s4;
															s4 = peg$FAILED;
														}
													} else {
														peg$currPos = s4;
														s4 = peg$FAILED;
													}
												}
												if (s3 !== peg$FAILED) {
													if (peg$c189.test(input.charAt(peg$currPos))) {
														s4 = input.charAt(peg$currPos);
														peg$currPos++;
													} else {
														s4 = peg$FAILED;
														if (peg$silentFails === 0) {
															peg$fail(peg$c190);
														}
													}
													if (s4 !== peg$FAILED) {
														s2 = [s2, s3, s4];
														s1 = s2;
													} else {
														peg$currPos = s1;
														s1 = peg$FAILED;
													}
												} else {
													peg$currPos = s1;
													s1 = peg$FAILED;
												}
											} else {
												peg$currPos = s1;
												s1 = peg$FAILED;
											}
										}
									}
								}

								return s0;
							}

							function peg$parseIdentifier() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$currPos;
								peg$silentFails++;
								s2 = peg$parseKeyword();
								peg$silentFails--;
								if (s2 === peg$FAILED) {
									s1 = void 0;
								} else {
									peg$currPos = s1;
									s1 = peg$FAILED;
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseLetter();
									if (s2 !== peg$FAILED) {
										s3 = peg$currPos;
										s4 = [];
										s5 = peg$parseLetterOrDigit();
										while (s5 !== peg$FAILED) {
											s4.push(s5);
											s5 = peg$parseLetterOrDigit();
										}
										if (s4 !== peg$FAILED) {
											s3 = input.substring(s3, peg$currPos);
										} else {
											s3 = s4;
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseSpacing();
											if (s4 !== peg$FAILED) {
												peg$savedPos = s0;
												s1 = peg$c191(s2, s3);
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseLetter() {
								var s0;

								if (peg$c192.test(input.charAt(peg$currPos))) {
									s0 = input.charAt(peg$currPos);
									peg$currPos++;
								} else {
									s0 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c193);
									}
								}
								if (s0 === peg$FAILED) {
									if (peg$c194.test(input.charAt(peg$currPos))) {
										s0 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s0 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c195);
										}
									}
									if (s0 === peg$FAILED) {
										if (peg$c196.test(input.charAt(peg$currPos))) {
											s0 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s0 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c197);
											}
										}
									}
								}

								return s0;
							}

							function peg$parseLetterOrDigit() {
								var s0;

								if (peg$c192.test(input.charAt(peg$currPos))) {
									s0 = input.charAt(peg$currPos);
									peg$currPos++;
								} else {
									s0 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c193);
									}
								}
								if (s0 === peg$FAILED) {
									if (peg$c194.test(input.charAt(peg$currPos))) {
										s0 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s0 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c195);
										}
									}
									if (s0 === peg$FAILED) {
										if (peg$c198.test(input.charAt(peg$currPos))) {
											s0 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s0 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c199);
											}
										}
										if (s0 === peg$FAILED) {
											if (peg$c196.test(input.charAt(peg$currPos))) {
												s0 = input.charAt(peg$currPos);
												peg$currPos++;
											} else {
												s0 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c197);
												}
											}
										}
									}
								}

								return s0;
							}

							function peg$parseKeyword() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 8) === peg$c154) {
									s1 = peg$c154;
									peg$currPos += 8;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c155);
									}
								}
								if (s1 === peg$FAILED) {
									if (input.substr(peg$currPos, 6) === peg$c200) {
										s1 = peg$c200;
										peg$currPos += 6;
									} else {
										s1 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c201);
										}
									}
									if (s1 === peg$FAILED) {
										if (input.substr(peg$currPos, 7) === peg$c123) {
											s1 = peg$c123;
											peg$currPos += 7;
										} else {
											s1 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c124);
											}
										}
										if (s1 === peg$FAILED) {
											if (input.substr(peg$currPos, 5) === peg$c202) {
												s1 = peg$c202;
												peg$currPos += 5;
											} else {
												s1 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c203);
												}
											}
											if (s1 === peg$FAILED) {
												if (input.substr(peg$currPos, 4) === peg$c109) {
													s1 = peg$c109;
													peg$currPos += 4;
												} else {
													s1 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c110);
													}
												}
												if (s1 === peg$FAILED) {
													if (input.substr(peg$currPos, 4) === peg$c204) {
														s1 = peg$c204;
														peg$currPos += 4;
													} else {
														s1 = peg$FAILED;
														if (peg$silentFails === 0) {
															peg$fail(peg$c205);
														}
													}
													if (s1 === peg$FAILED) {
														if (input.substr(peg$currPos, 5) === peg$c206) {
															s1 = peg$c206;
															peg$currPos += 5;
														} else {
															s1 = peg$FAILED;
															if (peg$silentFails === 0) {
																peg$fail(peg$c207);
															}
														}
														if (s1 === peg$FAILED) {
															if (input.substr(peg$currPos, 4) === peg$c113) {
																s1 = peg$c113;
																peg$currPos += 4;
															} else {
																s1 = peg$FAILED;
																if (peg$silentFails === 0) {
																	peg$fail(peg$c114);
																}
															}
															if (s1 === peg$FAILED) {
																if (input.substr(peg$currPos, 5) === peg$c208) {
																	s1 = peg$c208;
																	peg$currPos += 5;
																} else {
																	s1 = peg$FAILED;
																	if (peg$silentFails === 0) {
																		peg$fail(peg$c209);
																	}
																}
																if (s1 === peg$FAILED) {
																	if (input.substr(peg$currPos, 5) === peg$c210) {
																		s1 = peg$c210;
																		peg$currPos += 5;
																	} else {
																		s1 = peg$FAILED;
																		if (peg$silentFails === 0) {
																			peg$fail(peg$c211);
																		}
																	}
																	if (s1 === peg$FAILED) {
																		if (input.substr(peg$currPos, 8) === peg$c212) {
																			s1 = peg$c212;
																			peg$currPos += 8;
																		} else {
																			s1 = peg$FAILED;
																			if (peg$silentFails === 0) {
																				peg$fail(peg$c213);
																			}
																		}
																		if (s1 === peg$FAILED) {
																			if (input.substr(peg$currPos, 7) === peg$c214) {
																				s1 = peg$c214;
																				peg$currPos += 7;
																			} else {
																				s1 = peg$FAILED;
																				if (peg$silentFails === 0) {
																					peg$fail(peg$c215);
																				}
																			}
																			if (s1 === peg$FAILED) {
																				if (input.substr(peg$currPos, 6) === peg$c121) {
																					s1 = peg$c121;
																					peg$currPos += 6;
																				} else {
																					s1 = peg$FAILED;
																					if (peg$silentFails === 0) {
																						peg$fail(peg$c122);
																					}
																				}
																				if (s1 === peg$FAILED) {
																					if (input.substr(peg$currPos, 2) === peg$c216) {
																						s1 = peg$c216;
																						peg$currPos += 2;
																					} else {
																						s1 = peg$FAILED;
																						if (peg$silentFails === 0) {
																							peg$fail(peg$c217);
																						}
																					}
																					if (s1 === peg$FAILED) {
																						if (input.substr(peg$currPos, 4) === peg$c218) {
																							s1 = peg$c218;
																							peg$currPos += 4;
																						} else {
																							s1 = peg$FAILED;
																							if (peg$silentFails === 0) {
																								peg$fail(peg$c219);
																							}
																						}
																						if (s1 === peg$FAILED) {
																							if (input.substr(peg$currPos, 4) === peg$c220) {
																								s1 = peg$c220;
																								peg$currPos += 4;
																							} else {
																								s1 = peg$FAILED;
																								if (peg$silentFails === 0) {
																									peg$fail(peg$c221);
																								}
																							}
																							if (s1 === peg$FAILED) {
																								if (input.substr(peg$currPos, 7) === peg$c222) {
																									s1 = peg$c222;
																									peg$currPos += 7;
																								} else {
																									s1 = peg$FAILED;
																									if (peg$silentFails === 0) {
																										peg$fail(peg$c223);
																									}
																								}
																								if (s1 === peg$FAILED) {
																									if (input.substr(peg$currPos, 5) === peg$c224) {
																										s1 = peg$c224;
																										peg$currPos += 5;
																									} else {
																										s1 = peg$FAILED;
																										if (peg$silentFails === 0) {
																											peg$fail(peg$c225);
																										}
																									}
																									if (s1 === peg$FAILED) {
																										if (input.substr(peg$currPos, 7) === peg$c226) {
																											s1 = peg$c226;
																											peg$currPos += 7;
																										} else {
																											s1 = peg$FAILED;
																											if (peg$silentFails === 0) {
																												peg$fail(peg$c227);
																											}
																										}
																										if (s1 === peg$FAILED) {
																											if (input.substr(peg$currPos, 5) === peg$c156) {
																												s1 = peg$c156;
																												peg$currPos += 5;
																											} else {
																												s1 = peg$FAILED;
																												if (peg$silentFails === 0) {
																													peg$fail(peg$c157);
																												}
																											}
																											if (s1 === peg$FAILED) {
																												if (input.substr(peg$currPos, 5) === peg$c119) {
																													s1 = peg$c119;
																													peg$currPos += 5;
																												} else {
																													s1 = peg$FAILED;
																													if (peg$silentFails === 0) {
																														peg$fail(peg$c120);
																													}
																												}
																												if (s1 === peg$FAILED) {
																													if (input.substr(peg$currPos, 3) === peg$c228) {
																														s1 = peg$c228;
																														peg$currPos += 3;
																													} else {
																														s1 = peg$FAILED;
																														if (peg$silentFails === 0) {
																															peg$fail(peg$c229);
																														}
																													}
																													if (s1 === peg$FAILED) {
																														if (input.substr(peg$currPos, 4) === peg$c230) {
																															s1 = peg$c230;
																															peg$currPos += 4;
																														} else {
																															s1 = peg$FAILED;
																															if (peg$silentFails === 0) {
																																peg$fail(peg$c231);
																															}
																														}
																														if (s1 === peg$FAILED) {
																															if (input.substr(peg$currPos, 2) === peg$c232) {
																																s1 = peg$c232;
																																peg$currPos += 2;
																															} else {
																																s1 = peg$FAILED;
																																if (peg$silentFails === 0) {
																																	peg$fail(peg$c233);
																																}
																															}
																															if (s1 === peg$FAILED) {
																																if (input.substr(peg$currPos, 10) === peg$c234) {
																																	s1 = peg$c234;
																																	peg$currPos += 10;
																																} else {
																																	s1 = peg$FAILED;
																																	if (peg$silentFails === 0) {
																																		peg$fail(peg$c235);
																																	}
																																}
																																if (s1 === peg$FAILED) {
																																	if (input.substr(peg$currPos, 6) === peg$c236) {
																																		s1 = peg$c236;
																																		peg$currPos += 6;
																																	} else {
																																		s1 = peg$FAILED;
																																		if (peg$silentFails === 0) {
																																			peg$fail(peg$c237);
																																		}
																																	}
																																	if (s1 === peg$FAILED) {
																																		if (input.substr(peg$currPos, 9) === peg$c238) {
																																			s1 = peg$c238;
																																			peg$currPos += 9;
																																		} else {
																																			s1 = peg$FAILED;
																																			if (peg$silentFails === 0) {
																																				peg$fail(peg$c239);
																																			}
																																		}
																																		if (s1 === peg$FAILED) {
																																			if (input.substr(peg$currPos, 3) === peg$c115) {
																																				s1 = peg$c115;
																																				peg$currPos += 3;
																																			} else {
																																				s1 = peg$FAILED;
																																				if (peg$silentFails === 0) {
																																					peg$fail(peg$c116);
																																				}
																																			}
																																			if (s1 === peg$FAILED) {
																																				if (
																																					input.substr(peg$currPos, 10) === peg$c240
																																				) {
																																					s1 = peg$c240;
																																					peg$currPos += 10;
																																				} else {
																																					s1 = peg$FAILED;
																																					if (peg$silentFails === 0) {
																																						peg$fail(peg$c241);
																																					}
																																				}
																																				if (s1 === peg$FAILED) {
																																					if (
																																						input.substr(peg$currPos, 4) === peg$c117
																																					) {
																																						s1 = peg$c117;
																																						peg$currPos += 4;
																																					} else {
																																						s1 = peg$FAILED;
																																						if (peg$silentFails === 0) {
																																							peg$fail(peg$c118);
																																						}
																																					}
																																					if (s1 === peg$FAILED) {
																																						if (
																																							input.substr(peg$currPos, 6) === peg$c158
																																						) {
																																							s1 = peg$c158;
																																							peg$currPos += 6;
																																						} else {
																																							s1 = peg$FAILED;
																																							if (peg$silentFails === 0) {
																																								peg$fail(peg$c159);
																																							}
																																						}
																																						if (s1 === peg$FAILED) {
																																							if (
																																								input.substr(peg$currPos, 3) ===
																																								peg$c242
																																							) {
																																								s1 = peg$c242;
																																								peg$currPos += 3;
																																							} else {
																																								s1 = peg$FAILED;
																																								if (peg$silentFails === 0) {
																																									peg$fail(peg$c243);
																																								}
																																							}
																																							if (s1 === peg$FAILED) {
																																								if (
																																									input.substr(peg$currPos, 4) ===
																																									peg$c244
																																								) {
																																									s1 = peg$c244;
																																									peg$currPos += 4;
																																								} else {
																																									s1 = peg$FAILED;
																																									if (peg$silentFails === 0) {
																																										peg$fail(peg$c245);
																																									}
																																								}
																																								if (s1 === peg$FAILED) {
																																									if (
																																										input.substr(peg$currPos, 7) ===
																																										peg$c246
																																									) {
																																										s1 = peg$c246;
																																										peg$currPos += 7;
																																									} else {
																																										s1 = peg$FAILED;
																																										if (peg$silentFails === 0) {
																																											peg$fail(peg$c247);
																																										}
																																									}
																																									if (s1 === peg$FAILED) {
																																										if (
																																											input.substr(peg$currPos, 7) ===
																																											peg$c150
																																										) {
																																											s1 = peg$c150;
																																											peg$currPos += 7;
																																										} else {
																																											s1 = peg$FAILED;
																																											if (peg$silentFails === 0) {
																																												peg$fail(peg$c151);
																																											}
																																										}
																																										if (s1 === peg$FAILED) {
																																											if (
																																												input.substr(peg$currPos, 9) ===
																																												peg$c148
																																											) {
																																												s1 = peg$c148;
																																												peg$currPos += 9;
																																											} else {
																																												s1 = peg$FAILED;
																																												if (peg$silentFails === 0) {
																																													peg$fail(peg$c149);
																																												}
																																											}
																																											if (s1 === peg$FAILED) {
																																												if (
																																													input.substr(
																																														peg$currPos,
																																														6
																																													) === peg$c146
																																												) {
																																													s1 = peg$c146;
																																													peg$currPos += 6;
																																												} else {
																																													s1 = peg$FAILED;
																																													if (peg$silentFails === 0) {
																																														peg$fail(peg$c147);
																																													}
																																												}
																																												if (s1 === peg$FAILED) {
																																													if (
																																														input.substr(
																																															peg$currPos,
																																															6
																																														) === peg$c248
																																													) {
																																														s1 = peg$c248;
																																														peg$currPos += 6;
																																													} else {
																																														s1 = peg$FAILED;
																																														if (peg$silentFails === 0) {
																																															peg$fail(peg$c249);
																																														}
																																													}
																																													if (s1 === peg$FAILED) {
																																														if (
																																															input.substr(
																																																peg$currPos,
																																																5
																																															) === peg$c111
																																														) {
																																															s1 = peg$c111;
																																															peg$currPos += 5;
																																														} else {
																																															s1 = peg$FAILED;
																																															if (
																																																peg$silentFails === 0
																																															) {
																																																peg$fail(peg$c112);
																																															}
																																														}
																																														if (s1 === peg$FAILED) {
																																															if (
																																																input.substr(
																																																	peg$currPos,
																																																	6
																																																) === peg$c152
																																															) {
																																																s1 = peg$c152;
																																																peg$currPos += 6;
																																															} else {
																																																s1 = peg$FAILED;
																																																if (
																																																	peg$silentFails === 0
																																																) {
																																																	peg$fail(peg$c153);
																																																}
																																															}
																																															if (s1 === peg$FAILED) {
																																																if (
																																																	input.substr(
																																																		peg$currPos,
																																																		8
																																																	) === peg$c166
																																																) {
																																																	s1 = peg$c166;
																																																	peg$currPos += 8;
																																																} else {
																																																	s1 = peg$FAILED;
																																																	if (
																																																		peg$silentFails ===
																																																		0
																																																	) {
																																																		peg$fail(peg$c167);
																																																	}
																																																}
																																																if (s1 === peg$FAILED) {
																																																	if (
																																																		input.substr(
																																																			peg$currPos,
																																																			5
																																																		) === peg$c250
																																																	) {
																																																		s1 = peg$c250;
																																																		peg$currPos += 5;
																																																	} else {
																																																		s1 = peg$FAILED;
																																																		if (
																																																			peg$silentFails ===
																																																			0
																																																		) {
																																																			peg$fail(
																																																				peg$c251
																																																			);
																																																		}
																																																	}
																																																	if (
																																																		s1 === peg$FAILED
																																																	) {
																																																		if (
																																																			input.substr(
																																																				peg$currPos,
																																																				6
																																																			) === peg$c252
																																																		) {
																																																			s1 = peg$c252;
																																																			peg$currPos += 6;
																																																		} else {
																																																			s1 = peg$FAILED;
																																																			if (
																																																				peg$silentFails ===
																																																				0
																																																			) {
																																																				peg$fail(
																																																					peg$c253
																																																				);
																																																			}
																																																		}
																																																		if (
																																																			s1 === peg$FAILED
																																																		) {
																																																			if (
																																																				input.substr(
																																																					peg$currPos,
																																																					12
																																																				) === peg$c160
																																																			) {
																																																				s1 = peg$c160;
																																																				peg$currPos += 12;
																																																			} else {
																																																				s1 = peg$FAILED;
																																																				if (
																																																					peg$silentFails ===
																																																					0
																																																				) {
																																																					peg$fail(
																																																						peg$c161
																																																					);
																																																				}
																																																			}
																																																			if (
																																																				s1 ===
																																																				peg$FAILED
																																																			) {
																																																				if (
																																																					input.substr(
																																																						peg$currPos,
																																																						4
																																																					) === peg$c254
																																																				) {
																																																					s1 = peg$c254;
																																																					peg$currPos += 4;
																																																				} else {
																																																					s1 =
																																																						peg$FAILED;
																																																					if (
																																																						peg$silentFails ===
																																																						0
																																																					) {
																																																						peg$fail(
																																																							peg$c255
																																																						);
																																																					}
																																																				}
																																																				if (
																																																					s1 ===
																																																					peg$FAILED
																																																				) {
																																																					if (
																																																						input.substr(
																																																							peg$currPos,
																																																							6
																																																						) ===
																																																						peg$c256
																																																					) {
																																																						s1 =
																																																							peg$c256;
																																																						peg$currPos += 6;
																																																					} else {
																																																						s1 =
																																																							peg$FAILED;
																																																						if (
																																																							peg$silentFails ===
																																																							0
																																																						) {
																																																							peg$fail(
																																																								peg$c257
																																																							);
																																																						}
																																																					}
																																																					if (
																																																						s1 ===
																																																						peg$FAILED
																																																					) {
																																																						if (
																																																							input.substr(
																																																								peg$currPos,
																																																								5
																																																							) ===
																																																							peg$c258
																																																						) {
																																																							s1 =
																																																								peg$c258;
																																																							peg$currPos += 5;
																																																						} else {
																																																							s1 =
																																																								peg$FAILED;
																																																							if (
																																																								peg$silentFails ===
																																																								0
																																																							) {
																																																								peg$fail(
																																																									peg$c259
																																																								);
																																																							}
																																																						}
																																																						if (
																																																							s1 ===
																																																							peg$FAILED
																																																						) {
																																																							if (
																																																								input.substr(
																																																									peg$currPos,
																																																									9
																																																								) ===
																																																								peg$c162
																																																							) {
																																																								s1 =
																																																									peg$c162;
																																																								peg$currPos += 9;
																																																							} else {
																																																								s1 =
																																																									peg$FAILED;
																																																								if (
																																																									peg$silentFails ===
																																																									0
																																																								) {
																																																									peg$fail(
																																																										peg$c163
																																																									);
																																																								}
																																																							}
																																																							if (
																																																								s1 ===
																																																								peg$FAILED
																																																							) {
																																																								if (
																																																									input.substr(
																																																										peg$currPos,
																																																										4
																																																									) ===
																																																									peg$c260
																																																								) {
																																																									s1 =
																																																										peg$c260;
																																																									peg$currPos += 4;
																																																								} else {
																																																									s1 =
																																																										peg$FAILED;
																																																									if (
																																																										peg$silentFails ===
																																																										0
																																																									) {
																																																										peg$fail(
																																																											peg$c261
																																																										);
																																																									}
																																																								}
																																																								if (
																																																									s1 ===
																																																									peg$FAILED
																																																								) {
																																																									if (
																																																										input.substr(
																																																											peg$currPos,
																																																											3
																																																										) ===
																																																										peg$c262
																																																									) {
																																																										s1 =
																																																											peg$c262;
																																																										peg$currPos += 3;
																																																									} else {
																																																										s1 =
																																																											peg$FAILED;
																																																										if (
																																																											peg$silentFails ===
																																																											0
																																																										) {
																																																											peg$fail(
																																																												peg$c263
																																																											);
																																																										}
																																																									}
																																																									if (
																																																										s1 ===
																																																										peg$FAILED
																																																									) {
																																																										if (
																																																											input.substr(
																																																												peg$currPos,
																																																												4
																																																											) ===
																																																											peg$c264
																																																										) {
																																																											s1 =
																																																												peg$c264;
																																																											peg$currPos += 4;
																																																										} else {
																																																											s1 =
																																																												peg$FAILED;
																																																											if (
																																																												peg$silentFails ===
																																																												0
																																																											) {
																																																												peg$fail(
																																																													peg$c265
																																																												);
																																																											}
																																																										}
																																																										if (
																																																											s1 ===
																																																											peg$FAILED
																																																										) {
																																																											if (
																																																												input.substr(
																																																													peg$currPos,
																																																													8
																																																												) ===
																																																												peg$c164
																																																											) {
																																																												s1 =
																																																													peg$c164;
																																																												peg$currPos += 8;
																																																											} else {
																																																												s1 =
																																																													peg$FAILED;
																																																												if (
																																																													peg$silentFails ===
																																																													0
																																																												) {
																																																													peg$fail(
																																																														peg$c165
																																																													);
																																																												}
																																																											}
																																																											if (
																																																												s1 ===
																																																												peg$FAILED
																																																											) {
																																																												if (
																																																													input.substr(
																																																														peg$currPos,
																																																														5
																																																													) ===
																																																													peg$c266
																																																												) {
																																																													s1 =
																																																														peg$c266;
																																																													peg$currPos += 5;
																																																												} else {
																																																													s1 =
																																																														peg$FAILED;
																																																													if (
																																																														peg$silentFails ===
																																																														0
																																																													) {
																																																														peg$fail(
																																																															peg$c267
																																																														);
																																																													}
																																																												}
																																																											}
																																																										}
																																																									}
																																																								}
																																																							}
																																																						}
																																																					}
																																																				}
																																																			}
																																																		}
																																																	}
																																																}
																																															}
																																														}
																																													}
																																												}
																																											}
																																										}
																																									}
																																								}
																																							}
																																						}
																																					}
																																				}
																																			}
																																		}
																																	}
																																}
																															}
																														}
																													}
																												}
																											}
																										}
																									}
																								}
																							}
																						}
																					}
																				}
																			}
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseASSERT() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 6) === peg$c200) {
									s1 = peg$c200;
									peg$currPos += 6;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c201);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseBREAK() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 5) === peg$c202) {
									s1 = peg$c202;
									peg$currPos += 5;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c203);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseCASE() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 4) === peg$c204) {
									s1 = peg$c204;
									peg$currPos += 4;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c205);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseCATCH() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 5) === peg$c206) {
									s1 = peg$c206;
									peg$currPos += 5;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c207);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseCLASS() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 5) === peg$c208) {
									s1 = peg$c208;
									peg$currPos += 5;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c209);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseCONTINUE() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 8) === peg$c212) {
									s1 = peg$c212;
									peg$currPos += 8;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c213);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseDEFAULT() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 7) === peg$c214) {
									s1 = peg$c214;
									peg$currPos += 7;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c215);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseDO() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c216) {
									s1 = peg$c216;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c217);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseELSE() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 4) === peg$c218) {
									s1 = peg$c218;
									peg$currPos += 4;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c219);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseENUM() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 4) === peg$c220) {
									s1 = peg$c220;
									peg$currPos += 4;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c221);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseEXTENDS() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 7) === peg$c222) {
									s1 = peg$c222;
									peg$currPos += 7;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c223);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseFINALLY() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 7) === peg$c226) {
									s1 = peg$c226;
									peg$currPos += 7;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c227);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseFINAL() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 5) === peg$c156) {
									s1 = peg$c156;
									peg$currPos += 5;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c157);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseFOR() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 3) === peg$c228) {
									s1 = peg$c228;
									peg$currPos += 3;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c229);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseIF() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c232) {
									s1 = peg$c232;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c233);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseIMPLEMENTS() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 10) === peg$c234) {
									s1 = peg$c234;
									peg$currPos += 10;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c235);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseIMPORT() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 6) === peg$c236) {
									s1 = peg$c236;
									peg$currPos += 6;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c237);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseINTERFACE() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 9) === peg$c238) {
									s1 = peg$c238;
									peg$currPos += 9;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c239);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseINSTANCEOF() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 10) === peg$c240) {
									s1 = peg$c240;
									peg$currPos += 10;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c241);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseNEW() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 3) === peg$c242) {
									s1 = peg$c242;
									peg$currPos += 3;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c243);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parsePACKAGE() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 7) === peg$c246) {
									s1 = peg$c246;
									peg$currPos += 7;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c247);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseRETURN() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 6) === peg$c248) {
									s1 = peg$c248;
									peg$currPos += 6;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c249);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSTATIC() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 6) === peg$c152) {
									s1 = peg$c152;
									peg$currPos += 6;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c153);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSUPER() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 5) === peg$c250) {
									s1 = peg$c250;
									peg$currPos += 5;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c251);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSWITCH() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 6) === peg$c252) {
									s1 = peg$c252;
									peg$currPos += 6;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c253);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSYNCHRONIZED() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 12) === peg$c160) {
									s1 = peg$c160;
									peg$currPos += 12;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c161);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseTHIS() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 4) === peg$c254) {
									s1 = peg$c254;
									peg$currPos += 4;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c255);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseTHROWS() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 6) === peg$c256) {
									s1 = peg$c256;
									peg$currPos += 6;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c257);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseTHROW() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 5) === peg$c258) {
									s1 = peg$c258;
									peg$currPos += 5;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c259);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseTRY() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 3) === peg$c262) {
									s1 = peg$c262;
									peg$currPos += 3;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c263);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseVOID() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 4) === peg$c264) {
									s1 = peg$c264;
									peg$currPos += 4;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c265);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseWHILE() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 5) === peg$c266) {
									s1 = peg$c266;
									peg$currPos += 5;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c267);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									s3 = peg$parseLetterOrDigit();
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseLiteral() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								s1 = peg$parseFloatLiteral();
								if (s1 === peg$FAILED) {
									s1 = peg$parseIntegerLiteral();
									if (s1 === peg$FAILED) {
										s1 = peg$parseCharLiteral();
										if (s1 === peg$FAILED) {
											s1 = peg$parseStringLiteral();
											if (s1 === peg$FAILED) {
												s1 = peg$currPos;
												if (input.substr(peg$currPos, 4) === peg$c260) {
													s2 = peg$c260;
													peg$currPos += 4;
												} else {
													s2 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c261);
													}
												}
												if (s2 !== peg$FAILED) {
													s3 = peg$currPos;
													peg$silentFails++;
													s4 = peg$parseLetterOrDigit();
													peg$silentFails--;
													if (s4 === peg$FAILED) {
														s3 = void 0;
													} else {
														peg$currPos = s3;
														s3 = peg$FAILED;
													}
													if (s3 !== peg$FAILED) {
														peg$savedPos = s1;
														s2 = peg$c268();
														s1 = s2;
													} else {
														peg$currPos = s1;
														s1 = peg$FAILED;
													}
												} else {
													peg$currPos = s1;
													s1 = peg$FAILED;
												}
												if (s1 === peg$FAILED) {
													s1 = peg$currPos;
													if (input.substr(peg$currPos, 5) === peg$c224) {
														s2 = peg$c224;
														peg$currPos += 5;
													} else {
														s2 = peg$FAILED;
														if (peg$silentFails === 0) {
															peg$fail(peg$c225);
														}
													}
													if (s2 !== peg$FAILED) {
														s3 = peg$currPos;
														peg$silentFails++;
														s4 = peg$parseLetterOrDigit();
														peg$silentFails--;
														if (s4 === peg$FAILED) {
															s3 = void 0;
														} else {
															peg$currPos = s3;
															s3 = peg$FAILED;
														}
														if (s3 !== peg$FAILED) {
															peg$savedPos = s1;
															s2 = peg$c269();
															s1 = s2;
														} else {
															peg$currPos = s1;
															s1 = peg$FAILED;
														}
													} else {
														peg$currPos = s1;
														s1 = peg$FAILED;
													}
													if (s1 === peg$FAILED) {
														s1 = peg$currPos;
														if (input.substr(peg$currPos, 4) === peg$c244) {
															s2 = peg$c244;
															peg$currPos += 4;
														} else {
															s2 = peg$FAILED;
															if (peg$silentFails === 0) {
																peg$fail(peg$c245);
															}
														}
														if (s2 !== peg$FAILED) {
															s3 = peg$currPos;
															peg$silentFails++;
															s4 = peg$parseLetterOrDigit();
															peg$silentFails--;
															if (s4 === peg$FAILED) {
																s3 = void 0;
															} else {
																peg$currPos = s3;
																s3 = peg$FAILED;
															}
															if (s3 !== peg$FAILED) {
																peg$savedPos = s1;
																s2 = peg$c270();
																s1 = s2;
															} else {
																peg$currPos = s1;
																s1 = peg$FAILED;
															}
														} else {
															peg$currPos = s1;
															s1 = peg$FAILED;
														}
													}
												}
											}
										}
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c271(s1);
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseIntegerLiteral() {
								var s0, s1, s2;

								s0 = peg$currPos;
								s1 = peg$parseHexNumeral();
								if (s1 === peg$FAILED) {
									s1 = peg$parseBinaryNumeral();
									if (s1 === peg$FAILED) {
										s1 = peg$parseOctalNumeral();
										if (s1 === peg$FAILED) {
											s1 = peg$parseDecimalNumeral();
										}
									}
								}
								if (s1 !== peg$FAILED) {
									if (peg$c272.test(input.charAt(peg$currPos))) {
										s2 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s2 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c273);
										}
									}
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										peg$savedPos = s0;
										s1 = peg$c274();
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseDecimalNumeral() {
								var s0, s1, s2, s3, s4, s5;

								if (input.charCodeAt(peg$currPos) === 48) {
									s0 = peg$c275;
									peg$currPos++;
								} else {
									s0 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c276);
									}
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									if (peg$c277.test(input.charAt(peg$currPos))) {
										s1 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s1 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c278);
										}
									}
									if (s1 !== peg$FAILED) {
										s2 = [];
										s3 = peg$currPos;
										s4 = [];
										if (peg$c279.test(input.charAt(peg$currPos))) {
											s5 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s5 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c280);
											}
										}
										while (s5 !== peg$FAILED) {
											s4.push(s5);
											if (peg$c279.test(input.charAt(peg$currPos))) {
												s5 = input.charAt(peg$currPos);
												peg$currPos++;
											} else {
												s5 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c280);
												}
											}
										}
										if (s4 !== peg$FAILED) {
											if (peg$c198.test(input.charAt(peg$currPos))) {
												s5 = input.charAt(peg$currPos);
												peg$currPos++;
											} else {
												s5 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c199);
												}
											}
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
										while (s3 !== peg$FAILED) {
											s2.push(s3);
											s3 = peg$currPos;
											s4 = [];
											if (peg$c279.test(input.charAt(peg$currPos))) {
												s5 = input.charAt(peg$currPos);
												peg$currPos++;
											} else {
												s5 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c280);
												}
											}
											while (s5 !== peg$FAILED) {
												s4.push(s5);
												if (peg$c279.test(input.charAt(peg$currPos))) {
													s5 = input.charAt(peg$currPos);
													peg$currPos++;
												} else {
													s5 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c280);
													}
												}
											}
											if (s4 !== peg$FAILED) {
												if (peg$c198.test(input.charAt(peg$currPos))) {
													s5 = input.charAt(peg$currPos);
													peg$currPos++;
												} else {
													s5 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c199);
													}
												}
												if (s5 !== peg$FAILED) {
													s4 = [s4, s5];
													s3 = s4;
												} else {
													peg$currPos = s3;
													s3 = peg$FAILED;
												}
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										}
										if (s2 !== peg$FAILED) {
											s1 = [s1, s2];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								}

								return s0;
							}

							function peg$parseHexNumeral() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c281) {
									s1 = peg$c281;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c282);
									}
								}
								if (s1 === peg$FAILED) {
									if (input.substr(peg$currPos, 2) === peg$c283) {
										s1 = peg$c283;
										peg$currPos += 2;
									} else {
										s1 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c284);
										}
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseHexDigits();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseBinaryNumeral() {
								var s0, s1, s2, s3, s4, s5, s6;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c285) {
									s1 = peg$c285;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c286);
									}
								}
								if (s1 === peg$FAILED) {
									if (input.substr(peg$currPos, 2) === peg$c287) {
										s1 = peg$c287;
										peg$currPos += 2;
									} else {
										s1 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c288);
										}
									}
								}
								if (s1 !== peg$FAILED) {
									if (peg$c289.test(input.charAt(peg$currPos))) {
										s2 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s2 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c290);
										}
									}
									if (s2 !== peg$FAILED) {
										s3 = [];
										s4 = peg$currPos;
										s5 = [];
										if (peg$c279.test(input.charAt(peg$currPos))) {
											s6 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s6 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c280);
											}
										}
										while (s6 !== peg$FAILED) {
											s5.push(s6);
											if (peg$c279.test(input.charAt(peg$currPos))) {
												s6 = input.charAt(peg$currPos);
												peg$currPos++;
											} else {
												s6 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c280);
												}
											}
										}
										if (s5 !== peg$FAILED) {
											if (peg$c289.test(input.charAt(peg$currPos))) {
												s6 = input.charAt(peg$currPos);
												peg$currPos++;
											} else {
												s6 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c290);
												}
											}
											if (s6 !== peg$FAILED) {
												s5 = [s5, s6];
												s4 = s5;
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
										} else {
											peg$currPos = s4;
											s4 = peg$FAILED;
										}
										while (s4 !== peg$FAILED) {
											s3.push(s4);
											s4 = peg$currPos;
											s5 = [];
											if (peg$c279.test(input.charAt(peg$currPos))) {
												s6 = input.charAt(peg$currPos);
												peg$currPos++;
											} else {
												s6 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c280);
												}
											}
											while (s6 !== peg$FAILED) {
												s5.push(s6);
												if (peg$c279.test(input.charAt(peg$currPos))) {
													s6 = input.charAt(peg$currPos);
													peg$currPos++;
												} else {
													s6 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c280);
													}
												}
											}
											if (s5 !== peg$FAILED) {
												if (peg$c289.test(input.charAt(peg$currPos))) {
													s6 = input.charAt(peg$currPos);
													peg$currPos++;
												} else {
													s6 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c290);
													}
												}
												if (s6 !== peg$FAILED) {
													s5 = [s5, s6];
													s4 = s5;
												} else {
													peg$currPos = s4;
													s4 = peg$FAILED;
												}
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
										}
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseOctalNumeral() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 48) {
									s1 = peg$c275;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c276);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = [];
									if (peg$c279.test(input.charAt(peg$currPos))) {
										s5 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s5 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c280);
										}
									}
									while (s5 !== peg$FAILED) {
										s4.push(s5);
										if (peg$c279.test(input.charAt(peg$currPos))) {
											s5 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s5 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c280);
											}
										}
									}
									if (s4 !== peg$FAILED) {
										if (peg$c291.test(input.charAt(peg$currPos))) {
											s5 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s5 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c292);
											}
										}
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									if (s3 !== peg$FAILED) {
										while (s3 !== peg$FAILED) {
											s2.push(s3);
											s3 = peg$currPos;
											s4 = [];
											if (peg$c279.test(input.charAt(peg$currPos))) {
												s5 = input.charAt(peg$currPos);
												peg$currPos++;
											} else {
												s5 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c280);
												}
											}
											while (s5 !== peg$FAILED) {
												s4.push(s5);
												if (peg$c279.test(input.charAt(peg$currPos))) {
													s5 = input.charAt(peg$currPos);
													peg$currPos++;
												} else {
													s5 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c280);
													}
												}
											}
											if (s4 !== peg$FAILED) {
												if (peg$c291.test(input.charAt(peg$currPos))) {
													s5 = input.charAt(peg$currPos);
													peg$currPos++;
												} else {
													s5 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c292);
													}
												}
												if (s5 !== peg$FAILED) {
													s4 = [s4, s5];
													s3 = s4;
												} else {
													peg$currPos = s3;
													s3 = peg$FAILED;
												}
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										}
									} else {
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseFloatLiteral() {
								var s0, s1;

								s0 = peg$currPos;
								s1 = peg$parseHexFloat();
								if (s1 === peg$FAILED) {
									s1 = peg$parseDecimalFloat();
								}
								if (s1 !== peg$FAILED) {
									peg$savedPos = s0;
									s1 = peg$c274();
								}
								s0 = s1;

								return s0;
							}

							function peg$parseDecimalFloat() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseDigits();
								if (s1 !== peg$FAILED) {
									if (input.charCodeAt(peg$currPos) === 46) {
										s2 = peg$c293;
										peg$currPos++;
									} else {
										s2 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c294);
										}
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseDigits();
										if (s3 === peg$FAILED) {
											s3 = null;
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseExponent();
											if (s4 === peg$FAILED) {
												s4 = null;
											}
											if (s4 !== peg$FAILED) {
												if (peg$c295.test(input.charAt(peg$currPos))) {
													s5 = input.charAt(peg$currPos);
													peg$currPos++;
												} else {
													s5 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c296);
													}
												}
												if (s5 === peg$FAILED) {
													s5 = null;
												}
												if (s5 !== peg$FAILED) {
													s1 = [s1, s2, s3, s4, s5];
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									if (input.charCodeAt(peg$currPos) === 46) {
										s1 = peg$c293;
										peg$currPos++;
									} else {
										s1 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c294);
										}
									}
									if (s1 !== peg$FAILED) {
										s2 = peg$parseDigits();
										if (s2 !== peg$FAILED) {
											s3 = peg$parseExponent();
											if (s3 === peg$FAILED) {
												s3 = null;
											}
											if (s3 !== peg$FAILED) {
												if (peg$c295.test(input.charAt(peg$currPos))) {
													s4 = input.charAt(peg$currPos);
													peg$currPos++;
												} else {
													s4 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c296);
													}
												}
												if (s4 === peg$FAILED) {
													s4 = null;
												}
												if (s4 !== peg$FAILED) {
													s1 = [s1, s2, s3, s4];
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
									if (s0 === peg$FAILED) {
										s0 = peg$currPos;
										s1 = peg$parseDigits();
										if (s1 !== peg$FAILED) {
											s2 = peg$parseExponent();
											if (s2 !== peg$FAILED) {
												if (peg$c295.test(input.charAt(peg$currPos))) {
													s3 = input.charAt(peg$currPos);
													peg$currPos++;
												} else {
													s3 = peg$FAILED;
													if (peg$silentFails === 0) {
														peg$fail(peg$c296);
													}
												}
												if (s3 === peg$FAILED) {
													s3 = null;
												}
												if (s3 !== peg$FAILED) {
													s1 = [s1, s2, s3];
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
										if (s0 === peg$FAILED) {
											s0 = peg$currPos;
											s1 = peg$parseDigits();
											if (s1 !== peg$FAILED) {
												s2 = peg$parseExponent();
												if (s2 === peg$FAILED) {
													s2 = null;
												}
												if (s2 !== peg$FAILED) {
													if (peg$c295.test(input.charAt(peg$currPos))) {
														s3 = input.charAt(peg$currPos);
														peg$currPos++;
													} else {
														s3 = peg$FAILED;
														if (peg$silentFails === 0) {
															peg$fail(peg$c296);
														}
													}
													if (s3 !== peg$FAILED) {
														s1 = [s1, s2, s3];
														s0 = s1;
													} else {
														peg$currPos = s0;
														s0 = peg$FAILED;
													}
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										}
									}
								}

								return s0;
							}

							function peg$parseExponent() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (peg$c297.test(input.charAt(peg$currPos))) {
									s1 = input.charAt(peg$currPos);
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c298);
									}
								}
								if (s1 !== peg$FAILED) {
									if (peg$c299.test(input.charAt(peg$currPos))) {
										s2 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s2 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c300);
										}
									}
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseDigits();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseHexFloat() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								s1 = peg$parseHexSignificand();
								if (s1 !== peg$FAILED) {
									s2 = peg$parseBinaryExponent();
									if (s2 !== peg$FAILED) {
										if (peg$c295.test(input.charAt(peg$currPos))) {
											s3 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s3 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c296);
											}
										}
										if (s3 === peg$FAILED) {
											s3 = null;
										}
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseHexSignificand() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c281) {
									s1 = peg$c281;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c282);
									}
								}
								if (s1 === peg$FAILED) {
									if (input.substr(peg$currPos, 2) === peg$c283) {
										s1 = peg$c283;
										peg$currPos += 2;
									} else {
										s1 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c284);
										}
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseHexDigits();
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										if (input.charCodeAt(peg$currPos) === 46) {
											s3 = peg$c293;
											peg$currPos++;
										} else {
											s3 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c294);
											}
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parseHexDigits();
											if (s4 !== peg$FAILED) {
												s1 = [s1, s2, s3, s4];
												s0 = s1;
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									s1 = peg$parseHexNumeral();
									if (s1 !== peg$FAILED) {
										if (input.charCodeAt(peg$currPos) === 46) {
											s2 = peg$c293;
											peg$currPos++;
										} else {
											s2 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c294);
											}
										}
										if (s2 === peg$FAILED) {
											s2 = null;
										}
										if (s2 !== peg$FAILED) {
											s1 = [s1, s2];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								}

								return s0;
							}

							function peg$parseBinaryExponent() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (peg$c301.test(input.charAt(peg$currPos))) {
									s1 = input.charAt(peg$currPos);
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c302);
									}
								}
								if (s1 !== peg$FAILED) {
									if (peg$c299.test(input.charAt(peg$currPos))) {
										s2 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s2 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c300);
										}
									}
									if (s2 === peg$FAILED) {
										s2 = null;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseDigits();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseDigits() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								if (peg$c198.test(input.charAt(peg$currPos))) {
									s1 = input.charAt(peg$currPos);
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c199);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = [];
									if (peg$c279.test(input.charAt(peg$currPos))) {
										s5 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s5 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c280);
										}
									}
									while (s5 !== peg$FAILED) {
										s4.push(s5);
										if (peg$c279.test(input.charAt(peg$currPos))) {
											s5 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s5 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c280);
											}
										}
									}
									if (s4 !== peg$FAILED) {
										if (peg$c198.test(input.charAt(peg$currPos))) {
											s5 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s5 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c199);
											}
										}
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = [];
										if (peg$c279.test(input.charAt(peg$currPos))) {
											s5 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s5 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c280);
											}
										}
										while (s5 !== peg$FAILED) {
											s4.push(s5);
											if (peg$c279.test(input.charAt(peg$currPos))) {
												s5 = input.charAt(peg$currPos);
												peg$currPos++;
											} else {
												s5 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c280);
												}
											}
										}
										if (s4 !== peg$FAILED) {
											if (peg$c198.test(input.charAt(peg$currPos))) {
												s5 = input.charAt(peg$currPos);
												peg$currPos++;
											} else {
												s5 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c199);
												}
											}
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseHexDigits() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = peg$parseHexDigit();
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$currPos;
									s4 = [];
									if (peg$c279.test(input.charAt(peg$currPos))) {
										s5 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s5 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c280);
										}
									}
									while (s5 !== peg$FAILED) {
										s4.push(s5);
										if (peg$c279.test(input.charAt(peg$currPos))) {
											s5 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s5 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c280);
											}
										}
									}
									if (s4 !== peg$FAILED) {
										s5 = peg$parseHexDigit();
										if (s5 !== peg$FAILED) {
											s4 = [s4, s5];
											s3 = s4;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									} else {
										peg$currPos = s3;
										s3 = peg$FAILED;
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$currPos;
										s4 = [];
										if (peg$c279.test(input.charAt(peg$currPos))) {
											s5 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s5 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c280);
											}
										}
										while (s5 !== peg$FAILED) {
											s4.push(s5);
											if (peg$c279.test(input.charAt(peg$currPos))) {
												s5 = input.charAt(peg$currPos);
												peg$currPos++;
											} else {
												s5 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c280);
												}
											}
										}
										if (s4 !== peg$FAILED) {
											s5 = peg$parseHexDigit();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseHexDigit() {
								var s0;

								if (peg$c303.test(input.charAt(peg$currPos))) {
									s0 = input.charAt(peg$currPos);
									peg$currPos++;
								} else {
									s0 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c304);
									}
								}
								if (s0 === peg$FAILED) {
									if (peg$c305.test(input.charAt(peg$currPos))) {
										s0 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s0 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c306);
										}
									}
									if (s0 === peg$FAILED) {
										if (peg$c198.test(input.charAt(peg$currPos))) {
											s0 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s0 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c199);
											}
										}
									}
								}

								return s0;
							}

							function peg$parseCharLiteral() {
								var s0, s1, s2, s3, s4;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 39) {
									s1 = peg$c307;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c308);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseEscape();
									if (s2 === peg$FAILED) {
										s2 = peg$currPos;
										s3 = peg$currPos;
										peg$silentFails++;
										if (peg$c309.test(input.charAt(peg$currPos))) {
											s4 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s4 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c310);
											}
										}
										peg$silentFails--;
										if (s4 === peg$FAILED) {
											s3 = void 0;
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
										if (s3 !== peg$FAILED) {
											s4 = peg$parse_();
											if (s4 !== peg$FAILED) {
												s3 = [s3, s4];
												s2 = s3;
											} else {
												peg$currPos = s2;
												s2 = peg$FAILED;
											}
										} else {
											peg$currPos = s2;
											s2 = peg$FAILED;
										}
									}
									if (s2 !== peg$FAILED) {
										if (input.charCodeAt(peg$currPos) === 39) {
											s3 = peg$c307;
											peg$currPos++;
										} else {
											s3 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c308);
											}
										}
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c311();
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseStringLiteral() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 34) {
									s1 = peg$c312;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c313);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = [];
									s3 = peg$parseEscape();
									if (s3 === peg$FAILED) {
										s3 = peg$currPos;
										s4 = peg$currPos;
										peg$silentFails++;
										if (peg$c314.test(input.charAt(peg$currPos))) {
											s5 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s5 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c315);
											}
										}
										peg$silentFails--;
										if (s5 === peg$FAILED) {
											s4 = void 0;
										} else {
											peg$currPos = s4;
											s4 = peg$FAILED;
										}
										if (s4 !== peg$FAILED) {
											s5 = peg$parse_();
											if (s5 !== peg$FAILED) {
												s4 = [s4, s5];
												s3 = s4;
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										} else {
											peg$currPos = s3;
											s3 = peg$FAILED;
										}
									}
									while (s3 !== peg$FAILED) {
										s2.push(s3);
										s3 = peg$parseEscape();
										if (s3 === peg$FAILED) {
											s3 = peg$currPos;
											s4 = peg$currPos;
											peg$silentFails++;
											if (peg$c314.test(input.charAt(peg$currPos))) {
												s5 = input.charAt(peg$currPos);
												peg$currPos++;
											} else {
												s5 = peg$FAILED;
												if (peg$silentFails === 0) {
													peg$fail(peg$c315);
												}
											}
											peg$silentFails--;
											if (s5 === peg$FAILED) {
												s4 = void 0;
											} else {
												peg$currPos = s4;
												s4 = peg$FAILED;
											}
											if (s4 !== peg$FAILED) {
												s5 = peg$parse_();
												if (s5 !== peg$FAILED) {
													s4 = [s4, s5];
													s3 = s4;
												} else {
													peg$currPos = s3;
													s3 = peg$FAILED;
												}
											} else {
												peg$currPos = s3;
												s3 = peg$FAILED;
											}
										}
									}
									if (s2 !== peg$FAILED) {
										if (input.charCodeAt(peg$currPos) === 34) {
											s3 = peg$c312;
											peg$currPos++;
										} else {
											s3 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c313);
											}
										}
										if (s3 !== peg$FAILED) {
											peg$savedPos = s0;
											s1 = peg$c316();
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseEscape() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 92) {
									s1 = peg$c317;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c318);
									}
								}
								if (s1 !== peg$FAILED) {
									if (peg$c319.test(input.charAt(peg$currPos))) {
										s2 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s2 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c320);
										}
									}
									if (s2 === peg$FAILED) {
										s2 = peg$parseOctalEscape();
										if (s2 === peg$FAILED) {
											s2 = peg$parseUnicodeEscape();
										}
									}
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseOctalEscape() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (peg$c321.test(input.charAt(peg$currPos))) {
									s1 = input.charAt(peg$currPos);
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c322);
									}
								}
								if (s1 !== peg$FAILED) {
									if (peg$c291.test(input.charAt(peg$currPos))) {
										s2 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s2 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c292);
										}
									}
									if (s2 !== peg$FAILED) {
										if (peg$c291.test(input.charAt(peg$currPos))) {
											s3 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s3 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c292);
											}
										}
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}
								if (s0 === peg$FAILED) {
									s0 = peg$currPos;
									if (peg$c291.test(input.charAt(peg$currPos))) {
										s1 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s1 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c292);
										}
									}
									if (s1 !== peg$FAILED) {
										if (peg$c291.test(input.charAt(peg$currPos))) {
											s2 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s2 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c292);
											}
										}
										if (s2 !== peg$FAILED) {
											s1 = [s1, s2];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
									if (s0 === peg$FAILED) {
										if (peg$c291.test(input.charAt(peg$currPos))) {
											s0 = input.charAt(peg$currPos);
											peg$currPos++;
										} else {
											s0 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c292);
											}
										}
									}
								}

								return s0;
							}

							function peg$parseUnicodeEscape() {
								var s0, s1, s2, s3, s4, s5;

								s0 = peg$currPos;
								s1 = [];
								if (input.charCodeAt(peg$currPos) === 117) {
									s2 = peg$c323;
									peg$currPos++;
								} else {
									s2 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c324);
									}
								}
								if (s2 !== peg$FAILED) {
									while (s2 !== peg$FAILED) {
										s1.push(s2);
										if (input.charCodeAt(peg$currPos) === 117) {
											s2 = peg$c323;
											peg$currPos++;
										} else {
											s2 = peg$FAILED;
											if (peg$silentFails === 0) {
												peg$fail(peg$c324);
											}
										}
									}
								} else {
									s1 = peg$FAILED;
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseHexDigit();
									if (s2 !== peg$FAILED) {
										s3 = peg$parseHexDigit();
										if (s3 !== peg$FAILED) {
											s4 = peg$parseHexDigit();
											if (s4 !== peg$FAILED) {
												s5 = peg$parseHexDigit();
												if (s5 !== peg$FAILED) {
													s1 = [s1, s2, s3, s4, s5];
													s0 = s1;
												} else {
													peg$currPos = s0;
													s0 = peg$FAILED;
												}
											} else {
												peg$currPos = s0;
												s0 = peg$FAILED;
											}
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseAT() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 64) {
									s1 = peg$c325;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c326);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseAND() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 38) {
									s1 = peg$c327;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c328);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (peg$c329.test(input.charAt(peg$currPos))) {
										s3 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c330);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseANDAND() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c331) {
									s1 = peg$c331;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c332);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseANDEQU() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c333) {
									s1 = peg$c333;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c334);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseBANG() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 33) {
									s1 = peg$c335;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c336);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (input.charCodeAt(peg$currPos) === 61) {
										s3 = peg$c337;
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c338);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseBSR() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 3) === peg$c339) {
									s1 = peg$c339;
									peg$currPos += 3;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c340);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (input.charCodeAt(peg$currPos) === 61) {
										s3 = peg$c337;
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c338);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseBSREQU() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 4) === peg$c341) {
									s1 = peg$c341;
									peg$currPos += 4;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c342);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseCOLON() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 58) {
									s1 = peg$c343;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c344);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseCOMMA() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 44) {
									s1 = peg$c345;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c346);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseDEC() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c347) {
									s1 = peg$c347;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c348);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseDIV() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 47) {
									s1 = peg$c349;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c350);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (input.charCodeAt(peg$currPos) === 61) {
										s3 = peg$c337;
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c338);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseDIVEQU() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c351) {
									s1 = peg$c351;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c352);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseDOT() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 46) {
									s1 = peg$c293;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c294);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseELLIPSIS() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 3) === peg$c353) {
									s1 = peg$c353;
									peg$currPos += 3;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c354);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseEQU() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 61) {
									s1 = peg$c337;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c338);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (input.charCodeAt(peg$currPos) === 61) {
										s3 = peg$c337;
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c338);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseEQUAL() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c355) {
									s1 = peg$c355;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c356);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseGE() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c357) {
									s1 = peg$c357;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c358);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseGT() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 62) {
									s1 = peg$c359;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c360);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (peg$c361.test(input.charAt(peg$currPos))) {
										s3 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c362);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseHAT() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 94) {
									s1 = peg$c363;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c364);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (input.charCodeAt(peg$currPos) === 61) {
										s3 = peg$c337;
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c338);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseHATEQU() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c365) {
									s1 = peg$c365;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c366);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseINC() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c367) {
									s1 = peg$c367;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c368);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseLBRK() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 91) {
									s1 = peg$c369;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c370);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseLE() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c371) {
									s1 = peg$c371;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c372);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseLPAR() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 40) {
									s1 = peg$c373;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c374);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseLPOINT() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 60) {
									s1 = peg$c375;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c376);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseLT() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 60) {
									s1 = peg$c375;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c376);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (peg$c377.test(input.charAt(peg$currPos))) {
										s3 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c378);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseLWING() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 123) {
									s1 = peg$c379;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c380);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseMINUS() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 45) {
									s1 = peg$c381;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c382);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (peg$c383.test(input.charAt(peg$currPos))) {
										s3 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c384);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseMINUSEQU() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c385) {
									s1 = peg$c385;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c386);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseMOD() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 37) {
									s1 = peg$c387;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c388);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (input.charCodeAt(peg$currPos) === 61) {
										s3 = peg$c337;
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c338);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseMODEQU() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c389) {
									s1 = peg$c389;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c390);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseNOTEQUAL() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c391) {
									s1 = peg$c391;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c392);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseOR() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 124) {
									s1 = peg$c393;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c394);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (peg$c395.test(input.charAt(peg$currPos))) {
										s3 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c396);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseOREQU() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c397) {
									s1 = peg$c397;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c398);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseOROR() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c399) {
									s1 = peg$c399;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c400);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parsePLUS() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 43) {
									s1 = peg$c401;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c402);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (peg$c403.test(input.charAt(peg$currPos))) {
										s3 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c404);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parsePLUSEQU() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c405) {
									s1 = peg$c405;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c406);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseQUERY() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 63) {
									s1 = peg$c407;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c408);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseRBRK() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 93) {
									s1 = peg$c409;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c410);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseRPAR() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 41) {
									s1 = peg$c411;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c412);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseRPOINT() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 62) {
									s1 = peg$c359;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c360);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseRWING() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 125) {
									s1 = peg$c413;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c414);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSEMI() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 59) {
									s1 = peg$c415;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c416);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSL() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c417) {
									s1 = peg$c417;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c418);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (input.charCodeAt(peg$currPos) === 61) {
										s3 = peg$c337;
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c338);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSLEQU() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 3) === peg$c419) {
									s1 = peg$c419;
									peg$currPos += 3;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c420);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSR() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c421) {
									s1 = peg$c421;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c422);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (peg$c361.test(input.charAt(peg$currPos))) {
										s3 = input.charAt(peg$currPos);
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c362);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSREQU() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 3) === peg$c423) {
									s1 = peg$c423;
									peg$currPos += 3;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c424);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSTAR() {
								var s0, s1, s2, s3;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 42) {
									s1 = peg$c425;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c426);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$currPos;
									peg$silentFails++;
									if (input.charCodeAt(peg$currPos) === 61) {
										s3 = peg$c337;
										peg$currPos++;
									} else {
										s3 = peg$FAILED;
										if (peg$silentFails === 0) {
											peg$fail(peg$c338);
										}
									}
									peg$silentFails--;
									if (s3 === peg$FAILED) {
										s2 = void 0;
									} else {
										peg$currPos = s2;
										s2 = peg$FAILED;
									}
									if (s2 !== peg$FAILED) {
										s3 = peg$parseSpacing();
										if (s3 !== peg$FAILED) {
											s1 = [s1, s2, s3];
											s0 = s1;
										} else {
											peg$currPos = s0;
											s0 = peg$FAILED;
										}
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseSTAREQU() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.substr(peg$currPos, 2) === peg$c427) {
									s1 = peg$c427;
									peg$currPos += 2;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c428);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseTILDA() {
								var s0, s1, s2;

								s0 = peg$currPos;
								if (input.charCodeAt(peg$currPos) === 126) {
									s1 = peg$c429;
									peg$currPos++;
								} else {
									s1 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c430);
									}
								}
								if (s1 !== peg$FAILED) {
									s2 = peg$parseSpacing();
									if (s2 !== peg$FAILED) {
										s1 = [s1, s2];
										s0 = s1;
									} else {
										peg$currPos = s0;
										s0 = peg$FAILED;
									}
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parseEOT() {
								var s0, s1;

								s0 = peg$currPos;
								peg$silentFails++;
								s1 = peg$parse_();
								peg$silentFails--;
								if (s1 === peg$FAILED) {
									s0 = void 0;
								} else {
									peg$currPos = s0;
									s0 = peg$FAILED;
								}

								return s0;
							}

							function peg$parse_() {
								var s0;

								if (input.length > peg$currPos) {
									s0 = input.charAt(peg$currPos);
									peg$currPos++;
								} else {
									s0 = peg$FAILED;
									if (peg$silentFails === 0) {
										peg$fail(peg$c431);
									}
								}

								return s0;
							}

							function extractOptional(optional, index, def) {
								def = typeof def !== 'undefined' ? def : null;
								return optional ? optional[index] : def;
							}

							function extractList(list, index) {
								var result = new Array(list.length),
									i;

								for (i = 0; i < list.length; i++) {
									result[i] = list[i][index];
								}

								return result;
							}

							function buildList(first, rest, index) {
								return [first].concat(extractList(rest, index));
							}

							function buildTree(first, rest, builder) {
								var result = first,
									i;

								for (i = 0; i < rest.length; i++) {
									result = builder(result, rest[i]);
								}

								return result;
							}

							function buildInfixExpr(first, rest) {
								return buildTree(first, rest, function (result, element) {
									return {
										node: 'InfixExpression',
										operator: element[0][0], // remove ending Spacing
										leftOperand: result,
										rightOperand: element[1]
									};
								});
							}

							function buildQualified(first, rest, index) {
								return buildTree(first, rest, function (result, element) {
									return {
										node: 'QualifiedName',
										qualifier: result,
										name: element[index]
									};
								});
							}

							function popQualified(tree) {
								return tree.node === 'QualifiedName'
									? { name: tree.name, expression: tree.qualifier }
									: { name: tree, expression: null };
							}

							function extractThrowsClassType(list) {
								return list.map(function (node) {
									return node.name;
								});
							}

							function extractExpressions(list) {
								return list.map(function (node) {
									return node.expression;
								});
							}

							function buildArrayTree(first, rest) {
								return buildTree(first, rest, function (result, element) {
									return {
										node: 'ArrayType',
										componentType: result
									};
								});
							}

							function optionalList(value) {
								return value !== null ? value : [];
							}

							function extractOptionalList(list, index) {
								return optionalList(extractOptional(list, index));
							}

							function skipNulls(list) {
								return list.filter(function (v) {
									return v !== null;
								});
							}

							function makePrimitive(code) {
								return {
									node: 'PrimitiveType',
									primitiveTypeCode: code
								};
							}

							function makeModifier(keyword) {
								return {
									node: 'Modifier',
									keyword: keyword
								};
							}

							function makeCatchFinally(catchClauses, finallyBlock) {
								return {
									catchClauses: catchClauses,
									finally: finallyBlock
								};
							}

							function buildTypeName(qual, args, rest) {
								var first =
									args === null
										? {
												node: 'SimpleType',
												name: qual
										  }
										: {
												node: 'ParameterizedType',
												type: {
													node: 'SimpleType',
													name: qual
												},
												typeArguments: args
										  };

								return buildTree(first, rest, function (result, element) {
									var args = element[2];
									return args === null
										? {
												node: 'QualifiedType',
												name: element[1],
												qualifier: result
										  }
										: {
												node: 'ParameterizedType',
												type: {
													node: 'QualifiedType',
													name: element[1],
													qualifier: result
												},
												typeArguments: args
										  };
								});
							}

							function mergeProps(obj, props) {
								var key;
								for (key in props) {
									if (props.hasOwnProperty(key)) {
										if (obj.hasOwnProperty(key)) {
											throw new Error(
												'Property ' +
													key +
													' exists ' +
													line() +
													'\n' +
													text() +
													'\nCurrent value: ' +
													JSON.stringify(obj[key], null, 2) +
													'\nNew value: ' +
													JSON.stringify(props[key], null, 2)
											);
										} else {
											obj[key] = props[key];
										}
									}
								}
								return obj;
							}

							function buildSelectorTree(arg, sel, sels) {
								function getMergeVal(o, v) {
									switch (o.node) {
										case 'SuperFieldAccess':
										case 'SuperMethodInvocation':
											return { qualifier: v };
										case 'ArrayAccess':
											return { array: v };
										default:
											return { expression: v };
									}
								}
								return buildTree(mergeProps(sel, getMergeVal(sel, arg)), sels, function (result, element) {
									return mergeProps(element, getMergeVal(element, result));
								});
							}

							function TODO() {
								throw new Error('TODO: not impl line ' + line() + '\n' + text());
							}

							peg$result = peg$startRuleFunction();

							if (peg$result !== peg$FAILED && peg$currPos === input.length) {
								return peg$result;
							} else {
								if (peg$result !== peg$FAILED && peg$currPos < input.length) {
									peg$fail(peg$endExpectation());
								}

								throw peg$buildStructuredError(
									peg$maxFailExpected,
									peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,
									peg$maxFailPos < input.length
										? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
										: peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
								);
							}
						}

						return {
							SyntaxError: peg$SyntaxError,
							parse: peg$parse
						};
					})();

					var p5_options = {
						globalScope: 'p5',
						globalVars: {
							// Map methods
							pushMatrix: 'push',
							popMatrix: 'pop',
							size: 'createCanvas',
							println: 'print',
							PVector: 'Vector',

							// Fix literal methods
							int$: 'int',
							float$: 'float',
							byte$: 'byte',
							char$: 'char',
							boolean$: 'boolean',

							// Methods
							alpha: true,
							blue: true,
							brightness: true,
							color: true,
							green: true,
							hue: true,
							lerpColor: true,
							lightness: true,
							red: true,
							saturation: true,
							background: true,
							clear: true,
							colorMode: true,
							fill: true,
							noFill: true,
							noStroke: true,
							stroke: true,
							arc: true,
							ellipse: true,
							line: true,
							point: true,
							quad: true,
							rect: true,
							triangle: true,
							ellipseMode: true,
							noSmooth: true,
							rectMode: true,
							smooth: true,
							strokeCap: true,
							strokeJoin: true,
							strokeWeight: true,
							bezier: true,
							bezierDetail: true,
							bezierPoint: true,
							bezierTangent: true,
							curve: true,
							curveDetail: true,
							curveTightness: true,
							curvePoint: true,
							curveTangent: true,
							beginContour: true,
							beginShape: true,
							bezierVertex: true,
							curveVertex: true,
							endContour: true,
							endShape: true,
							quadraticVertex: true,
							vertex: true,
							loadModel: true,
							model: true,
							plane: true,
							box: true,
							sphere: true,
							cylinder: true,
							cone: true,
							ellipsoid: true,
							torus: true,
							preload: true,
							setup: true,
							draw: true,
							remove: true,
							noLoop: true,
							loop: true,
							redraw: true,
							print: true,
							cursor: true,
							frameRate: true,
							noCursor: true,
							windowResized: true,
							fullscreen: true,
							pixelDensity: true,
							displayDensity: true,
							getURL: true,
							getURLPath: true,
							getURLParams: true,
							resizeCanvas: true,
							noCanvas: true,
							createGraphics: true,
							blendMode: true,
							setAttributes: true,
							applyMatrix: true,
							resetMatrix: true,
							rotate: true,
							rotateX: true,
							rotateY: true,
							rotateZ: true,
							scale: true,
							shearX: true,
							shearY: true,
							translate: true,
							createStringDict: true,
							createNumberDict: true,
							append: true,
							arrayCopy: true,
							concat: true,
							reverse: true,
							shorten: true,
							shuffle: true,
							sort: true,
							splice: true,
							subset: true,
							float: true,
							int: true,
							str: true,
							boolean: true,
							byte: true,
							char: true,
							unchar: true,
							hex: true,
							unhex: true,
							join: true,
							match: true,
							matchAll: true,
							nf: true,
							nfc: true,
							nfp: true,
							nfs: true,
							split: true,
							splitTokens: true,
							trim: true,
							setMoveThreshold: true,
							setShakeThreshold: true,
							deviceMoved: true,
							deviceTurned: true,
							deviceShaken: true,
							keyPressed: true,
							keyReleased: true,
							keyTyped: true,
							keyIsDown: true,
							mouseMoved: true,
							mouseDragged: true,
							mousePressed: true,
							mouseReleased: true,
							mouseClicked: true,
							doubleClicked: true,
							mouseWheel: true,
							touchStarted: true,
							touchMoved: true,
							touchEnded: true,
							createImage: true,
							saveCanvas: true,
							saveFrames: true,
							loadImage: true,
							image: true,
							tint: true,
							noTint: true,
							imageMode: true,
							blend: true,
							copy: true,
							filter: true,
							get: true,
							loadPixels: true,
							set: true,
							updatePixels: true,
							loadJSON: true,
							loadStrings: true,
							loadTable: true,
							loadXML: true,
							loadBytes: true,
							httpGet: true,
							httpPost: true,
							httpDo: true,
							createWriter: true,
							save: true,
							saveJSON: true,
							saveStrings: true,
							saveTable: true,
							day: true,
							hour: true,
							minute: true,
							millis: true,
							month: true,
							second: true,
							year: true,
							createVector: true,
							abs: true,
							ceil: true,
							constrain: true,
							dist: true,
							exp: true,
							floor: true,
							lerp: true,
							log: true,
							mag: true,
							map: true,
							max: true,
							min: true,
							norm: true,
							pow: true,
							round: true,
							sq: true,
							sqrt: true,
							noise: true,
							noiseDetail: true,
							noiseSeed: true,
							randomSeed: true,
							random: true,
							randomGaussian: true,
							acos: true,
							asin: true,
							atan: true,
							atan2: true,
							cos: true,
							sin: true,
							tan: true,
							degrees: true,
							radians: true,
							angleMode: true,
							textAlign: true,
							textLeading: true,
							textSize: true,
							textStyle: true,
							textWidth: true,
							textAscent: true,
							textDescent: true,
							loadFont: true,
							text: true,
							textFont: true,
							camera: true,
							perspective: true,
							ortho: true,
							orbitControl: true,
							ambientLight: true,
							directionalLight: true,
							pointLight: true,
							loadShader: true,
							createShader: true,
							shader: true,
							normalMaterial: true,
							texture: true,
							ambientMaterial: true,
							specularMaterial: true,

							// Classes
							Graphics: true,
							Vector3: true,

							// Constants
							P2D: true,
							WEBGL: true,
							ARROW: true,
							CROSS: true,
							HAND: true,
							MOVE: true,
							TEXT: true,
							WAIT: true,
							HALF_PI: true,
							PI: true,
							QUARTER_PI: true,
							TAU: true,
							TWO_PI: true,
							DEGREES: true,
							RADIANS: true,
							DEG_TO_RAD: true,
							RAD_TO_DEG: true,
							CORNER: true,
							CORNERS: true,
							RADIUS: true,
							RIGHT: true,
							LEFT: true,
							CENTER: true,
							TOP: true,
							BOTTOM: true,
							BASELINE: true,
							POINTS: true,
							LINES: true,
							LINE_STRIP: true,
							LINE_LOOP: true,
							TRIANGLES: true,
							TRIANGLE_FAN: true,
							TRIANGLE_STRIP: true,
							QUADS: true,
							QUAD_STRIP: true,
							CLOSE: true,
							OPEN: true,
							CHORD: true,
							PIE: true,
							PROJECT: true,
							SQUARE: true,
							ROUND: true,
							BEVEL: true,
							MITER: true,
							RGB: true,
							HSB: true,
							HSL: true,
							AUTO: true,
							ALT: true,
							BACKSPACE: true,
							CONTROL: true,
							DELETE: true,
							DOWN_ARROW: true,
							ENTER: true,
							ESCAPE: true,
							LEFT_ARROW: true,
							OPTION: true,
							RETURN: true,
							RIGHT_ARROW: true,
							SHIFT: true,
							TAB: true,
							UP_ARROW: true,
							BLEND: true,
							ADD: true,
							DARKEST: true,
							LIGHTEST: true,
							DIFFERENCE: true,
							EXCLUSION: true,
							MULTIPLY: true,
							SCREEN: true,
							REPLACE: true,
							OVERLAY: true,
							HARD_LIGHT: true,
							SOFT_LIGHT: true,
							DODGE: true,
							BURN: true,
							THRESHOLD: true,
							GRAY: true,
							OPAQUE: true,
							INVERT: true,
							POSTERIZE: true,
							DILATE: true,
							ERODE: true,
							BLUR: true,
							NORMAL: true,
							ITALIC: true,
							BOLD: true,
							LINEAR: true,
							QUADRATIC: true,
							BEZIER: true,
							CURVE: true,
							STROKE: true,
							FILL: true,
							TEXTURE: true,
							IMMEDIATE: true,
							NEAREST: true,
							REPEAT: true,
							CLAMP: true,
							MIRROR: true,
							LANDSCAPE: true,
							PORTRAIT: true,
							GRID: true,
							AXES: true,

							// Variables
							frameCount: true,
							focused: true,
							Color: true,
							displayWidth: true,
							displayHeight: true,
							windowWidth: true,
							windowHeight: true,
							width: true,
							height: true,
							deviceOrientation: true,
							accelerationX: true,
							accelerationY: true,
							accelerationZ: true,
							pAccelerationX: true,
							pAccelerationY: true,
							pAccelerationZ: true,
							rotationX: true,
							rotationY: true,
							rotationZ: true,
							pRotationX: true,
							pRotationY: true,
							pRotationZ: true,
							turnAxis: true,
							keyIsPressed: true,
							key: true,
							keyCode: true,
							mouseX: true,
							mouseY: true,
							pmouseX: true,
							pmouseY: true,
							winMouseX: true,
							winMouseY: true,
							pwinMouseX: true,
							pwinMouseY: true,
							mouseButton: true,
							mouseIsPressed: true,
							touches: true,
							pixels: true
						}
					};

					/**
					 * @module java-to-javascript
					 */

					// const beautify = require('js-beautify').js;
					const beautify$2 = beautify.js_beautify;

					const DEFAULT_OPTIONS = {
						globalVars: {},
						globalScope: null,
						separator: '\n\n'
					};
					const opts = {};

					const literalInitializers = {
						int: '0',
						float: '0',
						double: '0',
						short: '0',
						long: '0',
						char: "''",
						boolean: 'false'
					};

					const SEP = '$';

					const unhandledNode = (node, more = '') => {
						console.error(`Unhandled node: ${node.node}. ${more}`);
						return '';
					};

					const joinStatements = (stats) => `${stats.join(';')}${stats.length ? ';' : ''}`;

					let variableTypes = {};

					const varToString = ({ name, value, type, final }, noLet) => {
						if (value === undefined) value = literalInitializers[type] || 'null';
						variableTypes[name] = type;
						return `${noLet !== true ? (final ? 'const ' : 'let ') : ''}${name} = ${value}`;
					};

					const parseType = (type) => {
						if (type.node === 'ArrayType') return 'Array';
						// Doesn't matter what we return, we don't use it
						else if (type.node === 'SimpleType') return type.name.identifier;
						else if (type.node === 'PrimitiveType') return type.primitiveTypeCode;
						else if (type.node === 'ParameterizedType') return parseType(type.type);
						else return unhandledNode(type);
					};

					const parseModifiers = (modifiers) => {
						const mods = {};
						for (const mod of modifiers) {
							mods[mod.keyword] = true;
						}
						return mods;
					};

					const parseClass = (class_, isGlobal) => {
						const modifiers = parseModifiers(class_.modifiers);
						if (modifiers.abstract || class_.interface) return { abstract: true };

						const classData = {
							name: class_.name.identifier,
							superclass: class_.superclassType && parseType(class_.superclassType),
							classes: [],
							vars: [],
							methods: []
						};
						const classVarsMap = {};

						let asyncMethods = {
							Scanner: [
								'hasNext',
								'hasNextLine',
								'next',
								'nextLine',
								'nextInt',
								'nextShort',
								'nextLong',
								'nextFloat',
								'nextDouble'
							],
							Thread: ['sleep']
						};
						if (typeof QuintOS != 'undefined') {
							Object.assign(asyncMethods, {
								Sprite: ['move'],
								window: ['alert', 'delay', 'eraseRect', 'frame', 'play', 'prompt', 'text', 'textRect']
							});
						}
						if (!asyncMethods.window) asyncMethods.window = [];

						const assignParent = (name, isInConstructor) => {
							if (name in classVarsMap) {
								let v = classData.vars.find((x) => x.name == name);
								if (!isInConstructor && (!v || !v.static)) {
									return `this.${name}`;
								} else if (v.static) {
									return `${classData.name}.${name}`;
								} else {
									return name;
								}
							}
							const mapped = opts.globalVars[name];
							if (mapped) {
								const newName = typeof mapped === 'string' ? mapped : name;
								return opts.globalScope ? `${opts.globalScope}.${newName}` : newName;
							}
							return name;
						};

						const parseExpr = (expr) => {
							if (!expr) return undefined;

							switch (expr.node) {
								case 'ThisExpression':
									return 'this';
								case 'NullLiteral':
									return 'null';
								case 'BooleanLiteral':
									return expr.booleanValue;
								case 'NumberLiteral':
									let num = expr.token;
									num = num.replace(/_/g, '');
									if (/^0\d+$/.test(num)) num = '0o' + num.substring(1);
									else if (/[lfd]$/i.test(num)) num = num.slice(0, -1);
									return num;
								case 'StringLiteral':
									return expr.escapedValue.replace(/'/g, "\\'").replace(/"/g, "'");
								case 'CharacterLiteral':
									const char = expr.escapedValue.slice(1, -1);
									if (char.length === 1) return "'" + char + "'";
									else if (char.startsWith('\\u')) return parseInt(char.substring(2), 16).toString();
									else return unhandledNode(expr, 'Weird char: ' + char);
								case 'CastExpression':
									let exp = parseExpr(expr.expression);
									let type;
									if (expr.expression.node == 'SimpleName') {
										type = variableTypes[expr.expression.identifier];
									} else if (expr.expression.node == 'CharacterLiteral') {
										type = 'char';
									} else if (expr.expression.node == 'NumberLiteral') {
										type = 'double';
									} else if (expr.expression.node == 'StringLiteral') {
										type = 'String';
									}
									let castError = false;
									let cast = expr.type.primitiveTypeCode;
									if (cast == 'int') {
										// if cast to int
										if (type == 'String') {
											castError = true;
										} else if (type == 'char') {
											exp += '.charCodeAt(0)';
										} else {
											exp = 'Math.floor(' + exp + ')';
										}
									} else if (cast == 'char') {
										if (type == 'String') {
											castError = true;
										} else {
											exp = 'String.fromCharCode(' + exp + ')';
										}
									}
									if (castError) {
										let msg = `error: incompatible types: ${type} cannot be converted to ${cast}: ${exp}`;
										console.log(msg);
										System.err.println(msg);
										return '';
									}
									return exp;
								case 'ConditionalExpression':
									return `${parseExpr(expr.expression)} ? ${parseExpr(expr.thenExpression)} : ${parseExpr(
										expr.elseExpression
									)}`;
								case 'SimpleName':
									return assignParent(expr.identifier, expr.isInConstructor);
								case 'QualifiedName':
									return `${parseExpr(expr.qualifier)}.${expr.name.identifier}`;
								case 'FieldAccess':
									return `${parseExpr(expr.expression)}.${expr.name.identifier}`;
								case 'Assignment':
									return `${parseExpr(expr.leftHandSide)} ${expr.operator} ${parseExpr(expr.rightHandSide)}`;
								case 'InfixExpression':
									let op = expr.operator;
									if (op === '!=' || op === '==') op += '='; // triple equals in JS
									return `${parseExpr(expr.leftOperand)} ${op} ${parseExpr(expr.rightOperand)}`;
								case 'MethodInvocation':
									let str = '';
									if (expr.expression) {
										let exp = expr.expression;
										if (exp.expression) exp = exp.expression;
										let arr = asyncMethods[variableTypes[exp.identifier]];
										if (arr && arr.length && arr.includes(expr.name.identifier) && !expr.isInConstructor) {
											str += 'await ';
										}
										str += `${parseExpr(expr.expression)}.${expr.name.identifier}`;
										if (expr.name.identifier == 'length') return str;
									} else {
										if (asyncMethods.window.includes(expr.name.identifier) && !expr.isInConstructor) {
											str += 'await ';
										}
										str += `${assignParent(expr.name.identifier)}`;
									}
									return str + `(${expr.arguments.map(parseExpr)})`;
								case 'InstanceofExpression':
									return `${parseExpr(expr.leftOperand)} instanceof ${parseType(expr.rightOperand)}`;
								case 'SuperMethodInvocation':
									return `super.${expr.name.identifier}(${expr.arguments.map(parseExpr)})`;
								case 'ClassInstanceCreation':
									return `new ${parseType(expr.type)}(${expr.arguments.map(parseExpr)})`;
								case 'PostfixExpression':
									return `${parseExpr(expr.operand)}${expr.operator}`;
								case 'PrefixExpression':
									return `${expr.operator}${parseExpr(expr.operand)}`;
								case 'VariableDeclarationExpression':
									return `${parseFieldVars(expr).map(varToString)}`;
								case 'ArrayInitializer':
									return `[${expr.expressions.map(parseExpr)}]`;
								case 'ArrayCreation':
									return `new Array()`;
								case 'ArrayAccess':
									let arr = expr.array;
									// TODO support for three dimensional arrays
									if (arr.array) {
										return `${assignParent(arr.array.identifier)}[${parseExpr(arr.index)}][${parseExpr(expr.index)}]`;
									}
									if (arr.identifier) {
										return `${assignParent(arr.identifier)}[${parseExpr(expr.index)}]`;
									}
									// TODO support for third level subclasses
									if (arr.qualifier.qualifier) {
										return `${assignParent(arr.qualifier.qualifier.identifier)}.${arr.qualifier.name.identifier}.${
											arr.name.identifier
										}[${parseExpr(expr.index)}]`;
									}
									return `${assignParent(arr.qualifier.identifier)}.${arr.name.identifier}[${parseExpr(expr.index)}]`;
								case 'ParenthesizedExpression':
									return `(${parseExpr(expr.expression)})`;
								default:
									return unhandledNode(expr);
							}
						};

						const parseFieldVars = (field) => {
							const vars = [];
							const data = parseModifiers(field.modifiers);
							data.type = parseType(field.type);

							for (const frag of field.fragments) {
								if (frag.node === 'VariableDeclarationFragment') {
									vars.push(
										Object.assign(
											{
												name: frag.name.identifier,
												value: parseExpr(frag.initializer)
											},
											data
										)
									);
									variableTypes[frag.name.identifier] = data.type;
								} else unhandledNode(frag);
							}
							return vars;
						};

						const parseStatement = (stat) => {
							switch (stat.node) {
								case 'EmptyStatement':
									return '';
								case 'ExpressionStatement':
									return parseExpr(stat.expression);
								case 'VariableDeclarationStatement':
									return parseFieldVars(stat).map(varToString);
								case 'ReturnStatement':
									return `return ${parseExpr(stat.expression)}`;
								case 'SuperConstructorInvocation':
									// TODO stat.expression stat.typeArguments
									return `super(${stat.arguments.map(parseExpr)})`;
								case 'IfStatement':
									let ifBlock = `if(${parseExpr(stat.expression)}){${parseBlock(stat.thenStatement)}}`;
									if (stat.elseStatement) ifBlock += `else{${parseBlock(stat.elseStatement)}}`;
									return ifBlock;
								case 'WhileStatement':
									return `while(${parseExpr(stat.expression)}){${parseBlock(stat.body)}}`;
								case 'DoStatement':
									return `do{${parseBlock(stat.body)}}while(${parseExpr(stat.expression)})`;
								case 'ForStatement':
									let initializers = stat.initializers.map(parseExpr).join(',');
									if (stat.initializers.length && stat.initializers[0].node === 'VariableDeclarationExpression')
										initializers = 'let ' + initializers.replace(/(let|const) /g, '');
									return `for(${initializers};${parseExpr(stat.expression) || ''};${stat.updaters.map(
										parseExpr
									)}){${parseBlock(stat.body)}}`;
								case 'EnhancedForStatement':
									return `for(const ${stat.parameter.name.identifier} of ${parseExpr(stat.expression)}){${parseBlock(
										stat.body
									)}}`;
								case 'BreakStatement':
									return `break ${stat.label ? stat.label.identifier : ''}`;
								case 'ContinueStatement':
									return `continue ${stat.label ? stat.label.identifier : ''}`;
								case 'LabeledStatement':
									return `${stat.label.identifier}:${parseStatement(stat.body)}`;
								case 'SwitchCase':
									return `case ${parseExpr(stat.expression)}:`;
								case 'SwitchStatement':
									let switchStats = '';
									for (const _stat of stat.statements) {
										const statStr = parseStatement(_stat);
										switchStats += statStr + (statStr.endsWith(':') ? '' : ';');
									}
									return `switch(${parseExpr(stat.expression)}){${switchStats}}`;
								case 'AssertStatement':
									return `if(!(${parseExpr(stat.expression)}))throw ${
										stat.message ? parseExpr(stat.message) : "'Assertion Failed'"
									}`;
								case 'ThrowStatement':
									return `throw ${parseExpr(stat.expression)}`;
								case 'TryStatement':
									let tryBlock = `try{${parseBlock(stat.body)}}`;
									for (const clause of stat.catchClauses)
										tryBlock += ` catch(${clause.exception.name.identifier}){${parseBlock(clause.body)}}`; // TODO handle exception types?
									if (stat.finally) tryBlock += `finally{${parseBlock(stat.finally)}}`;
									return tryBlock;
								default:
									return unhandledNode(stat);
							}
						};

						const parseBlock = (block, method) => {
							const semicolon = (str) => `${str}${str.endsWith('}') ? '' : ';'}`;

							if (block.node !== 'Block') return semicolon(parseStatement(block));

							const statements = [];

							for (const stat of block.statements) {
								if (method && stat.node == 'ExpressionStatement') {
									stat.expression.isInConstructor = method.constructor;
								}
								const str = parseStatement(stat);
								const arr = Array.isArray(str) ? str : [str];
								statements.push(...arr.map(semicolon));
								if (method && !method.isAsync && !method.constructor && statements.join('').includes('await')) {
									asyncMethods.window.push(method.name.identifier);
									method.isAsync = true;
								}
							}

							return statements.join('');
						};

						const parseMethod = (method) => {
							const data = Object.assign(
								{
									name: method.name.identifier,
									parameters: []
								},
								parseModifiers(method.modifiers)
							);

							if (method.constructor) {
								data.isConstructor = true;
								data.name = 'constructor';
								data.static = false;
								for (let stat of method.body.statements) {
									if (stat.expression.rightHandSide) {
										stat.expression.rightHandSide.isInConstructor = true;
									}
								}
							}

							for (const param of method.parameters) {
								if (param.node === 'SingleVariableDeclaration') data.parameters.push(param.name.identifier);
								else unhandledNode(block);
							}

							data.block = parseBlock(method.body, method);

							if (data.block.includes('await')) data.isAsync = true;

							return data;
						};

						for (const dec of class_.bodyDeclarations) {
							if (dec.node === 'FieldDeclaration') {
								classData.vars.push(...parseFieldVars(dec));
							} else if (dec.node === 'MethodDeclaration' && !dec.constructor && isGlobal !== true) {
								classVarsMap[dec.name.identifier] = true;
							}
						}

						if (isGlobal !== true) {
							for (const var_ of classData.vars) classVarsMap[var_.name] = true;
						}

						for (const dec of class_.bodyDeclarations) {
							if (dec.node === 'TypeDeclaration') classData.classes.push(parseClass(dec));
							else if (dec.node === 'MethodDeclaration') classData.methods.push(parseMethod(dec));
							else if (dec.node !== 'FieldDeclaration') unhandledNode(dec);
						}

						return classData;
					};

					const classToJs = ({ name: className, vars, superclass, methods, abstract, classes }) => {
						if (abstract) return '';

						const initVars = [];
						const classProps = [];
						const staticVars = [];

						for (const cl of classes) {
							staticVars.push(`${classToJs(cl)}\n${className}.${cl.name}=${cl.name};`);
						}

						for (const var_ of vars) {
							if (var_.value === undefined) var_.value = literalInitializers[var_.type] || 'null';
							if (var_.static) {
								staticVars.push(`${className}.${var_.name}=${var_.value};`);
							} else {
								if (typeof var_.value == 'string') {
									for (const vv of vars) {
										var_.value = var_.value.replaceAll(vv.name, 'this.' + vv.name);
									}
								}
								initVars.push(`this.${var_.name}=${var_.value};`);
							}
						}

						let addedConstructor = false;

						const addMethod = ({ name, parameters, block, isConstructor, isAsync, static: static_ }, addInitVars) => {
							if (isConstructor) addedConstructor = true;
							if (static_) staticVars.push(`${className}.${name}=(${parameters})=>{${block}};`);
							else {
								const preblock =
									isConstructor && addInitVars && initVars.length
										? initVars.join('') + (block ? opts.separator : '')
										: '';
								let method = `${name}(${parameters}){${preblock}${block}}`;
								if (isAsync) method = 'async ' + method;
								classProps.push(method);
							}
						};

						const methodMap = {};
						for (const meth of methods) {
							const safeName = meth.name + '$$';
							if (!(safeName in methodMap)) methodMap[safeName] = {};
							methodMap[safeName][meth.parameters.length] = meth;
						}
						for (const safeName in methodMap) {
							const name = safeName.slice(0, -2);
							const paramMap = methodMap[safeName];
							const paramCounts = Object.keys(paramMap);

							const first = paramMap[paramCounts[0]];
							if (paramCounts.length === 1) {
								addMethod(first, true);
							} else {
								let cases = '';
								for (const paramCount of paramCounts) {
									const meth = paramMap[paramCount];
									meth.name = `${name}${SEP}${paramCount}`;
									cases += `case ${paramCount}:return ${meth.static ? className : 'this'}.${meth.name}(...args$);`;
									addMethod(meth);
								}
								if (first.static)
									staticVars.push(`${className}.${name}=(...args${SEP})=>{switch(args${SEP}.length){${cases}}};`);
								else classProps.push(`${name}(...args${SEP}){switch(args${SEP}.length){${cases}}}`);
							}
							if (name == 'main') staticVars.push(`jdk.main = ${className}.main;`);
						}

						if (!addedConstructor && initVars.length) classProps.unshift(`constructor(){${initVars.join('')}}`);

						return `class ${className}${superclass ? ' extends ' + superclass : ''}{${classProps.join(
							''
						)}}${staticVars.join('')}`;
					};

					const globalsToJs = ({ vars, methods, classes }) => {
						const join = [];

						join.push(joinStatements(vars.map(varToString)));

						join.push(
							methods
								.map(
									({ name, parameters, block }) =>
										`${
											opts.globalScope && name in opts.globalVars ? `${opts.globalScope}.` : 'const '
										}${name} = (${parameters}) => {${block}};`
								)
								.join(opts.separator)
						);

						join.push(classes.map(classToJs).join(opts.separator));

						return join.join(opts.separator);
					};

					const fixP5 = (str) => {
						return str
							.replace(/(int|float|byte|char|boolean)\s*\(/g, '$1$$(') // Temporarily change name of literal method calls e.g. int(x) -> int$(x)
							.replace(/[^"](#[a-f0-9]{6,8})[^"]/gi, "'$1'") // Replace silly hex notation with string
							.replace(/new\s+PVector\s*\(/g, 'createVector('); // use p5 vector initializer
					};

					/**
					 * Convert Java string to JavaScript string
					 * @param {string} javaString - Java file contents
					 * @param {object} [options]
					 * @param {object} [options.globalVars] - Object keys are added to the `globalScope` object. If the object value is a string, the variable is renamed to that string
					 * @param {string} [options.globalScope] - If specified, variables in `globalVars` are appended to `globalScope` object
					 * @param {boolean} [options.p5] - Sets `globalScope` to `'p5'`, adds [p5 variable mappings](./p5_globals.js) to `globalVars`, and allows for global methods and variables
					 * @param {boolean} [options.ugly] - Don't beautify JavaScript code
					 * @param {function} [progress] - Callback on progress of conversion. Args are progress number (0 to 1), and a message string
					 * @return {string} - Converted JavaScript
					 */
					const javaToJavascript = (javaString, options = {}, progress) => {
						if (typeof javaString !== 'string') {
							throw 'java-to-javascript: First argument must be a string';
						}

						// Reset opts parameters
						Object.assign(opts, DEFAULT_OPTIONS);

						if (options.globalVars) opts.globalVars = options.globalVars;
						if (options.globalScope) opts.globalScope = options.globalScope;
						if (options.ugly) opts.separator = '';
						if (options.p5) {
							Object.assign(opts.globalVars, p5_options.globalVars, opts.globalVars);
							if (!opts.globalScope) opts.globalScope = 'p5';
						}

						if (progress) progress(0, 'Parsing Java');

						if (options.p5) javaString = `class JavaJsTemp__ {${fixP5(javaString)}}`;

						let javaAST$$1;
						try {
							javaAST$$1 = javaAST.parse(javaString);
						} catch (e) {
							let line = e.location.start.line;
							if (e.location) throw `on line ${line}: \n\n${javaString.split('\n')[line - 1].trim()}\n\n${e.stack}`;
							else throw e;
						}

						if (progress) progress(0.5, 'Converting to JavaScript');

						let jsString;
						if (options.p5) {
							jsString = globalsToJs(parseClass(javaAST$$1.types[0], true));
						} else {
							jsString = javaAST$$1.types.map((globalClass) => classToJs(parseClass(globalClass))).join(opts.separator);
						}

						if (progress) progress(0.75, 'Beautifying');

						if (!options.ugly) {
							jsString =
								beautify$2(jsString, {
									indent_size: 2
								}) + '\n';
						}

						if (progress) progress(1.0, 'Success');

						return jsString;
					};

					var lib = javaToJavascript;

					return lib;
				});

				/* beautify ignore:end */
			},
			{}
		]
	},
	{},
	[1]
);