File Manager

Editing File: /home/markqprx/iniasli.pro/public/build/assets/worker-php-47e5dfe7.js

"no use strict";
!(function(window) {
if (typeof window.window != "undefined" && window.document)
    return;
if (window.require && window.define)
    return;

if (!window.console) {
    window.console = function() {
        var msgs = Array.prototype.slice.call(arguments, 0);
        postMessage({type: "log", data: msgs});
    };
    window.console.error =
    window.console.warn = 
    window.console.log =
    window.console.trace = window.console;
}
window.window = window;
window.ace = window;

window.onerror = function(message, file, line, col, err) {
    postMessage({type: "error", data: {
        message: message,
        data: err && err.data,
        file: file,
        line: line, 
        col: col,
        stack: err && err.stack
    }});
};

window.require = function require(parentId, id) {
    if (!id) {
        id = parentId;
        parentId = null;
    }
    if (!id.charAt)
        throw new Error("worker.js require() accepts only (parentId, id) as arguments");

id = window.normalizeModule(parentId, id);

if (!deps.length)
        // If there is no dependencies, we inject "require", "exports" and
        // "module" as dependencies, to provide CommonJS compatibility.
        deps = ["require", "exports", "module"];

var req = function(childId) {
        return window.require(id, childId);
    };

window.initSender = function initSender() {

var main = window.main = null;
var sender = window.sender = null;

ace.define("ace/lib/oop",[], function(require, exports, module){"use strict";
exports.inherits = function (ctor, superCtor) {
    ctor.super_ = superCtor;
    ctor.prototype = Object.create(superCtor.prototype, {
        constructor: {
            value: ctor,
            enumerable: false,
            writable: true,
            configurable: true
        }
    });
};
exports.mixin = function (obj, mixin) {
    for (var key in mixin) {
        obj[key] = mixin[key];
    }
    return obj;
};
exports.implement = function (proto, mixin) {
    exports.mixin(proto, mixin);
};

});

ace.define("ace/apply_delta",[], function(require, exports, module){"use strict";
function throwDeltaError(delta, errorText) {
    console.log("Invalid Delta:", delta);
    throw "Invalid Delta: " + errorText;
}
function positionInDocument(docLines, position) {
    return position.row >= 0 && position.row < docLines.length &&
        position.column >= 0 && position.column <= docLines[position.row].length;
}
function validateDelta(docLines, delta) {
    if (delta.action != "insert" && delta.action != "remove")
        throwDeltaError(delta, "delta.action must be 'insert' or 'remove'");
    if (!(delta.lines instanceof Array))
        throwDeltaError(delta, "delta.lines must be an Array");
    if (!delta.start || !delta.end)
        throwDeltaError(delta, "delta.start/end must be an present");
    var start = delta.start;
    if (!positionInDocument(docLines, delta.start))
        throwDeltaError(delta, "delta.start must be contained in document");
    var end = delta.end;
    if (delta.action == "remove" && !positionInDocument(docLines, end))
        throwDeltaError(delta, "delta.end must contained in document for 'remove' actions");
    var numRangeRows = end.row - start.row;
    var numRangeLastLineChars = (end.column - (numRangeRows == 0 ? start.column : 0));
    if (numRangeRows != delta.lines.length - 1 || delta.lines[numRangeRows].length != numRangeLastLineChars)
        throwDeltaError(delta, "delta.range must match delta lines");
}
exports.applyDelta = function (docLines, delta, doNotValidate) {
    var row = delta.start.row;
    var startColumn = delta.start.column;
    var line = docLines[row] || "";
    switch (delta.action) {
        case "insert":
            var lines = delta.lines;
            if (lines.length === 1) {
                docLines[row] = line.substring(0, startColumn) + delta.lines[0] + line.substring(startColumn);
            }
            else {
                var args = [row, 1].concat(delta.lines);
                docLines.splice.apply(docLines, args);
                docLines[row] = line.substring(0, startColumn) + docLines[row];
                docLines[row + delta.lines.length - 1] += line.substring(startColumn);
            }
            break;
        case "remove":
            var endColumn = delta.end.column;
            var endRow = delta.end.row;
            if (row === endRow) {
                docLines[row] = line.substring(0, startColumn) + line.substring(endColumn);
            }
            else {
                docLines.splice(row, endRow - row + 1, line.substring(0, startColumn) + docLines[endRow].substring(endColumn));
            }
            break;
    }
};

});

ace.define("ace/lib/event_emitter",[], function(require, exports, module){"use strict";
var EventEmitter = {};
var stopPropagation = function () { this.propagationStopped = true; };
var preventDefault = function () { this.defaultPrevented = true; };
EventEmitter._emit =
    EventEmitter._dispatchEvent = function (eventName, e) {
        this._eventRegistry || (this._eventRegistry = {});
        this._defaultHandlers || (this._defaultHandlers = {});
        var listeners = this._eventRegistry[eventName] || [];
        var defaultHandler = this._defaultHandlers[eventName];
        if (!listeners.length && !defaultHandler)
            return;
        if (typeof e != "object" || !e)
            e = {};
        if (!e.type)
            e.type = eventName;
        if (!e.stopPropagation)
            e.stopPropagation = stopPropagation;
        if (!e.preventDefault)
            e.preventDefault = preventDefault;
        listeners = listeners.slice();
        for (var i = 0; i < listeners.length; i++) {
            listeners[i](e, this);
            if (e.propagationStopped)
                break;
        }
        if (defaultHandler && !e.defaultPrevented)
            return defaultHandler(e, this);
    };
EventEmitter._signal = function (eventName, e) {
    var listeners = (this._eventRegistry || {})[eventName];
    if (!listeners)
        return;
    listeners = listeners.slice();
    for (var i = 0; i < listeners.length; i++)
        listeners[i](e, this);
};
EventEmitter.once = function (eventName, callback) {
    var _self = this;
    this.on(eventName, function newCallback() {
        _self.off(eventName, newCallback);
        callback.apply(null, arguments);
    });
    if (!callback) {
        return new Promise(function (resolve) {
            callback = resolve;
        });
    }
};
EventEmitter.setDefaultHandler = function (eventName, callback) {
    var handlers = this._defaultHandlers;
    if (!handlers)
        handlers = this._defaultHandlers = { _disabled_: {} };
    if (handlers[eventName]) {
        var old = handlers[eventName];
        var disabled = handlers._disabled_[eventName];
        if (!disabled)
            handlers._disabled_[eventName] = disabled = [];
        disabled.push(old);
        var i = disabled.indexOf(callback);
        if (i != -1)
            disabled.splice(i, 1);
    }
    handlers[eventName] = callback;
};
EventEmitter.removeDefaultHandler = function (eventName, callback) {
    var handlers = this._defaultHandlers;
    if (!handlers)
        return;
    var disabled = handlers._disabled_[eventName];
    if (handlers[eventName] == callback) {
        if (disabled)
            this.setDefaultHandler(eventName, disabled.pop());
    }
    else if (disabled) {
        var i = disabled.indexOf(callback);
        if (i != -1)
            disabled.splice(i, 1);
    }
};
EventEmitter.on =
    EventEmitter.addEventListener = function (eventName, callback, capturing) {
        this._eventRegistry = this._eventRegistry || {};
        var listeners = this._eventRegistry[eventName];
        if (!listeners)
            listeners = this._eventRegistry[eventName] = [];
        if (listeners.indexOf(callback) == -1)
            listeners[capturing ? "unshift" : "push"](callback);
        return callback;
    };
EventEmitter.off =
    EventEmitter.removeListener =
        EventEmitter.removeEventListener = function (eventName, callback) {
            this._eventRegistry = this._eventRegistry || {};
            var listeners = this._eventRegistry[eventName];
            if (!listeners)
                return;
            var index = listeners.indexOf(callback);
            if (index !== -1)
                listeners.splice(index, 1);
        };
EventEmitter.removeAllListeners = function (eventName) {
    if (!eventName)
        this._eventRegistry = this._defaultHandlers = undefined;
    if (this._eventRegistry)
        this._eventRegistry[eventName] = undefined;
    if (this._defaultHandlers)
        this._defaultHandlers[eventName] = undefined;
};
exports.EventEmitter = EventEmitter;

});

ace.define("ace/range",[], function(require, exports, module){"use strict";
var comparePoints = function (p1, p2) {
    return p1.row - p2.row || p1.column - p2.column;
};
var Range = /** @class */ (function () {
    function Range(startRow, startColumn, endRow, endColumn) {
        this.start = {
            row: startRow,
            column: startColumn
        };
        this.end = {
            row: endRow,
            column: endColumn
        };
    }
    Range.prototype.isEqual = function (range) {
        return this.start.row === range.start.row &&
            this.end.row === range.end.row &&
            this.start.column === range.start.column &&
            this.end.column === range.end.column;
    };
    Range.prototype.toString = function () {
        return ("Range: [" + this.start.row + "/" + this.start.column +
            "] -> [" + this.end.row + "/" + this.end.column + "]");
    };
    Range.prototype.contains = function (row, column) {
        return this.compare(row, column) == 0;
    };
    Range.prototype.compareRange = function (range) {
        var cmp, end = range.end, start = range.start;
        cmp = this.compare(end.row, end.column);
        if (cmp == 1) {
            cmp = this.compare(start.row, start.column);
            if (cmp == 1) {
                return 2;
            }
            else if (cmp == 0) {
                return 1;
            }
            else {
                return 0;
            }
        }
        else if (cmp == -1) {
            return -2;
        }
        else {
            cmp = this.compare(start.row, start.column);
            if (cmp == -1) {
                return -1;
            }
            else if (cmp == 1) {
                return 42;
            }
            else {
                return 0;
            }
        }
    };
    Range.prototype.comparePoint = function (p) {
        return this.compare(p.row, p.column);
    };
    Range.prototype.containsRange = function (range) {
        return this.comparePoint(range.start) == 0 && this.comparePoint(range.end) == 0;
    };
    Range.prototype.intersects = function (range) {
        var cmp = this.compareRange(range);
        return (cmp == -1 || cmp == 0 || cmp == 1);
    };
    Range.prototype.isEnd = function (row, column) {
        return this.end.row == row && this.end.column == column;
    };
    Range.prototype.isStart = function (row, column) {
        return this.start.row == row && this.start.column == column;
    };
    Range.prototype.setStart = function (row, column) {
        if (typeof row == "object") {
            this.start.column = row.column;
            this.start.row = row.row;
        }
        else {
            this.start.row = row;
            this.start.column = column;
        }
    };
    Range.prototype.setEnd = function (row, column) {
        if (typeof row == "object") {
            this.end.column = row.column;
            this.end.row = row.row;
        }
        else {
            this.end.row = row;
            this.end.column = column;
        }
    };
    Range.prototype.inside = function (row, column) {
        if (this.compare(row, column) == 0) {
            if (this.isEnd(row, column) || this.isStart(row, column)) {
                return false;
            }
            else {
                return true;
            }
        }
        return false;
    };
    Range.prototype.insideStart = function (row, column) {
        if (this.compare(row, column) == 0) {
            if (this.isEnd(row, column)) {
                return false;
            }
            else {
                return true;
            }
        }
        return false;
    };
    Range.prototype.insideEnd = function (row, column) {
        if (this.compare(row, column) == 0) {
            if (this.isStart(row, column)) {
                return false;
            }
            else {
                return true;
            }
        }
        return false;
    };
    Range.prototype.compare = function (row, column) {
        if (!this.isMultiLine()) {
            if (row === this.start.row) {
                return column < this.start.column ? -1 : (column > this.end.column ? 1 : 0);
            }
        }
        if (row < this.start.row)
            return -1;
        if (row > this.end.row)
            return 1;
        if (this.start.row === row)
            return column >= this.start.column ? 0 : -1;
        if (this.end.row === row)
            return column <= this.end.column ? 0 : 1;
        return 0;
    };
    Range.prototype.compareStart = function (row, column) {
        if (this.start.row == row && this.start.column == column) {
            return -1;
        }
        else {
            return this.compare(row, column);
        }
    };
    Range.prototype.compareEnd = function (row, column) {
        if (this.end.row == row && this.end.column == column) {
            return 1;
        }
        else {
            return this.compare(row, column);
        }
    };
    Range.prototype.compareInside = function (row, column) {
        if (this.end.row == row && this.end.column == column) {
            return 1;
        }
        else if (this.start.row == row && this.start.column == column) {
            return -1;
        }
        else {
            return this.compare(row, column);
        }
    };
    Range.prototype.clipRows = function (firstRow, lastRow) {
        if (this.end.row > lastRow)
            var end = { row: lastRow + 1, column: 0 };
        else if (this.end.row < firstRow)
            var end = { row: firstRow, column: 0 };
        if (this.start.row > lastRow)
            var start = { row: lastRow + 1, column: 0 };
        else if (this.start.row < firstRow)
            var start = { row: firstRow, column: 0 };
        return Range.fromPoints(start || this.start, end || this.end);
    };
    Range.prototype.extend = function (row, column) {
        var cmp = this.compare(row, column);
        if (cmp == 0)
            return this;
        else if (cmp == -1)
            var start = { row: row, column: column };
        else
            var end = { row: row, column: column };
        return Range.fromPoints(start || this.start, end || this.end);
    };
    Range.prototype.isEmpty = function () {
        return (this.start.row === this.end.row && this.start.column === this.end.column);
    };
    Range.prototype.isMultiLine = function () {
        return (this.start.row !== this.end.row);
    };
    Range.prototype.clone = function () {
        return Range.fromPoints(this.start, this.end);
    };
    Range.prototype.collapseRows = function () {
        if (this.end.column == 0)
            return new Range(this.start.row, 0, Math.max(this.start.row, this.end.row - 1), 0);
        else
            return new Range(this.start.row, 0, this.end.row, 0);
    };
    Range.prototype.toScreenRange = function (session) {
        var screenPosStart = session.documentToScreenPosition(this.start);
        var screenPosEnd = session.documentToScreenPosition(this.end);
        return new Range(screenPosStart.row, screenPosStart.column, screenPosEnd.row, screenPosEnd.column);
    };
    Range.prototype.moveBy = function (row, column) {
        this.start.row += row;
        this.start.column += column;
        this.end.row += row;
        this.end.column += column;
    };
    return Range;
}());
Range.fromPoints = function (start, end) {
    return new Range(start.row, start.column, end.row, end.column);
};
Range.comparePoints = comparePoints;
Range.comparePoints = function (p1, p2) {
    return p1.row - p2.row || p1.column - p2.column;
};
exports.Range = Range;

});

ace.define("ace/anchor",[], function(require, exports, module){"use strict";
var oop = require("./lib/oop");
var EventEmitter = require("./lib/event_emitter").EventEmitter;
var Anchor = /** @class */ (function () {
    function Anchor(doc, row, column) {
        this.$onChange = this.onChange.bind(this);
        this.attach(doc);
        if (typeof column == "undefined")
            this.setPosition(row.row, row.column);
        else
            this.setPosition(row, column);
    }
    Anchor.prototype.getPosition = function () {
        return this.$clipPositionToDocument(this.row, this.column);
    };
    Anchor.prototype.getDocument = function () {
        return this.document;
    };
    Anchor.prototype.onChange = function (delta) {
        if (delta.start.row == delta.end.row && delta.start.row != this.row)
            return;
        if (delta.start.row > this.row)
            return;
        var point = $getTransformedPoint(delta, { row: this.row, column: this.column }, this.$insertRight);
        this.setPosition(point.row, point.column, true);
    };
    Anchor.prototype.setPosition = function (row, column, noClip) {
        var pos;
        if (noClip) {
            pos = {
                row: row,
                column: column
            };
        }
        else {
            pos = this.$clipPositionToDocument(row, column);
        }
        if (this.row == pos.row && this.column == pos.column)
            return;
        var old = {
            row: this.row,
            column: this.column
        };
        this.row = pos.row;
        this.column = pos.column;
        this._signal("change", {
            old: old,
            value: pos
        });
    };
    Anchor.prototype.detach = function () {
        this.document.off("change", this.$onChange);
    };
    Anchor.prototype.attach = function (doc) {
        this.document = doc || this.document;
        this.document.on("change", this.$onChange);
    };
    Anchor.prototype.$clipPositionToDocument = function (row, column) {
        var pos = {};
        if (row >= this.document.getLength()) {
            pos.row = Math.max(0, this.document.getLength() - 1);
            pos.column = this.document.getLine(pos.row).length;
        }
        else if (row < 0) {
            pos.row = 0;
            pos.column = 0;
        }
        else {
            pos.row = row;
            pos.column = Math.min(this.document.getLine(pos.row).length, Math.max(0, column));
        }
        if (column < 0)
            pos.column = 0;
        return pos;
    };
    return Anchor;
}());
Anchor.prototype.$insertRight = false;
oop.implement(Anchor.prototype, EventEmitter);
function $pointsInOrder(point1, point2, equalPointsInOrder) {
    var bColIsAfter = equalPointsInOrder ? point1.column <= point2.column : point1.column < point2.column;
    return (point1.row < point2.row) || (point1.row == point2.row && bColIsAfter);
}
function $getTransformedPoint(delta, point, moveIfEqual) {
    var deltaIsInsert = delta.action == "insert";
    var deltaRowShift = (deltaIsInsert ? 1 : -1) * (delta.end.row - delta.start.row);
    var deltaColShift = (deltaIsInsert ? 1 : -1) * (delta.end.column - delta.start.column);
    var deltaStart = delta.start;
    var deltaEnd = deltaIsInsert ? deltaStart : delta.end; // Collapse insert range.
    if ($pointsInOrder(point, deltaStart, moveIfEqual)) {
        return {
            row: point.row,
            column: point.column
        };
    }
    if ($pointsInOrder(deltaEnd, point, !moveIfEqual)) {
        return {
            row: point.row + deltaRowShift,
            column: point.column + (point.row == deltaEnd.row ? deltaColShift : 0)
        };
    }
    return {
        row: deltaStart.row,
        column: deltaStart.column
    };
}
exports.Anchor = Anchor;

});

ace.define("ace/document",[], function(require, exports, module){"use strict";
var oop = require("./lib/oop");
var applyDelta = require("./apply_delta").applyDelta;
var EventEmitter = require("./lib/event_emitter").EventEmitter;
var Range = require("./range").Range;
var Anchor = require("./anchor").Anchor;
var Document = /** @class */ (function () {
    function Document(textOrLines) {
        this.$lines = [""];
        if (textOrLines.length === 0) {
            this.$lines = [""];
        }
        else if (Array.isArray(textOrLines)) {
            this.insertMergedLines({ row: 0, column: 0 }, textOrLines);
        }
        else {
            this.insert({ row: 0, column: 0 }, textOrLines);
        }
    }
    Document.prototype.setValue = function (text) {
        var len = this.getLength() - 1;
        this.remove(new Range(0, 0, len, this.getLine(len).length));
        this.insert({ row: 0, column: 0 }, text || "");
    };
    Document.prototype.getValue = function () {
        return this.getAllLines().join(this.getNewLineCharacter());
    };
    Document.prototype.createAnchor = function (row, column) {
        return new Anchor(this, row, column);
    };
    Document.prototype.$detectNewLine = function (text) {
        var match = text.match(/^.*?(\r\n|\r|\n)/m);
        this.$autoNewLine = match ? match[1] : "\n";
        this._signal("changeNewLineMode");
    };
    Document.prototype.getNewLineCharacter = function () {
        switch (this.$newLineMode) {
            case "windows":
                return "\r\n";
            case "unix":
                return "\n";
            default:
                return this.$autoNewLine || "\n";
        }
    };
    Document.prototype.setNewLineMode = function (newLineMode) {
        if (this.$newLineMode === newLineMode)
            return;
        this.$newLineMode = newLineMode;
        this._signal("changeNewLineMode");
    };
    Document.prototype.getNewLineMode = function () {
        return this.$newLineMode;
    };
    Document.prototype.isNewLine = function (text) {
        return (text == "\r\n" || text == "\r" || text == "\n");
    };
    Document.prototype.getLine = function (row) {
        return this.$lines[row] || "";
    };
    Document.prototype.getLines = function (firstRow, lastRow) {
        return this.$lines.slice(firstRow, lastRow + 1);
    };
    Document.prototype.getAllLines = function () {
        return this.getLines(0, this.getLength());
    };
    Document.prototype.getLength = function () {
        return this.$lines.length;
    };
    Document.prototype.getTextRange = function (range) {
        return this.getLinesForRange(range).join(this.getNewLineCharacter());
    };
    Document.prototype.getLinesForRange = function (range) {
        var lines;
        if (range.start.row === range.end.row) {
            lines = [this.getLine(range.start.row).substring(range.start.column, range.end.column)];
        }
        else {
            lines = this.getLines(range.start.row, range.end.row);
            lines[0] = (lines[0] || "").substring(range.start.column);
            var l = lines.length - 1;
            if (range.end.row - range.start.row == l)
                lines[l] = lines[l].substring(0, range.end.column);
        }
        return lines;
    };
    Document.prototype.insertLines = function (row, lines) {
        console.warn("Use of document.insertLines is deprecated. Use the insertFullLines method instead.");
        return this.insertFullLines(row, lines);
    };
    Document.prototype.removeLines = function (firstRow, lastRow) {
        console.warn("Use of document.removeLines is deprecated. Use the removeFullLines method instead.");
        return this.removeFullLines(firstRow, lastRow);
    };
    Document.prototype.insertNewLine = function (position) {
        console.warn("Use of document.insertNewLine is deprecated. Use insertMergedLines(position, ['', '']) instead.");
        return this.insertMergedLines(position, ["", ""]);
    };
    Document.prototype.insert = function (position, text) {
        if (this.getLength() <= 1)
            this.$detectNewLine(text);
        return this.insertMergedLines(position, this.$split(text));
    };
    Document.prototype.insertInLine = function (position, text) {
        var start = this.clippedPos(position.row, position.column);
        var end = this.pos(position.row, position.column + text.length);
        this.applyDelta({
            start: start,
            end: end,
            action: "insert",
            lines: [text]
        }, true);
        return this.clonePos(end);
    };
    Document.prototype.clippedPos = function (row, column) {
        var length = this.getLength();
        if (row === undefined) {
            row = length;
        }
        else if (row < 0) {
            row = 0;
        }
        else if (row >= length) {
            row = length - 1;
            column = undefined;
        }
        var line = this.getLine(row);
        if (column == undefined)
            column = line.length;
        column = Math.min(Math.max(column, 0), line.length);
        return { row: row, column: column };
    };
    Document.prototype.clonePos = function (pos) {
        return { row: pos.row, column: pos.column };
    };
    Document.prototype.pos = function (row, column) {
        return { row: row, column: column };
    };
    Document.prototype.$clipPosition = function (position) {
        var length = this.getLength();
        if (position.row >= length) {
            position.row = Math.max(0, length - 1);
            position.column = this.getLine(length - 1).length;
        }
        else {
            position.row = Math.max(0, position.row);
            position.column = Math.min(Math.max(position.column, 0), this.getLine(position.row).length);
        }
        return position;
    };
    Document.prototype.insertFullLines = function (row, lines) {
        row = Math.min(Math.max(row, 0), this.getLength());
        var column = 0;
        if (row < this.getLength()) {
            lines = lines.concat([""]);
            column = 0;
        }
        else {
            lines = [""].concat(lines);
            row--;
            column = this.$lines[row].length;
        }
        this.insertMergedLines({ row: row, column: column }, lines);
    };
    Document.prototype.insertMergedLines = function (position, lines) {
        var start = this.clippedPos(position.row, position.column);
        var end = {
            row: start.row + lines.length - 1,
            column: (lines.length == 1 ? start.column : 0) + lines[lines.length - 1].length
        };
        this.applyDelta({
            start: start,
            end: end,
            action: "insert",
            lines: lines
        });
        return this.clonePos(end);
    };
    Document.prototype.remove = function (range) {
        var start = this.clippedPos(range.start.row, range.start.column);
        var end = this.clippedPos(range.end.row, range.end.column);
        this.applyDelta({
            start: start,
            end: end,
            action: "remove",
            lines: this.getLinesForRange({ start: start, end: end })
        });
        return this.clonePos(start);
    };
    Document.prototype.removeInLine = function (row, startColumn, endColumn) {
        var start = this.clippedPos(row, startColumn);
        var end = this.clippedPos(row, endColumn);
        this.applyDelta({
            start: start,
            end: end,
            action: "remove",
            lines: this.getLinesForRange({ start: start, end: end })
        }, true);
        return this.clonePos(start);
    };
    Document.prototype.removeFullLines = function (firstRow, lastRow) {
        firstRow = Math.min(Math.max(0, firstRow), this.getLength() - 1);
        lastRow = Math.min(Math.max(0, lastRow), this.getLength() - 1);
        var deleteFirstNewLine = lastRow == this.getLength() - 1 && firstRow > 0;
        var deleteLastNewLine = lastRow < this.getLength() - 1;
        var startRow = (deleteFirstNewLine ? firstRow - 1 : firstRow);
        var startCol = (deleteFirstNewLine ? this.getLine(startRow).length : 0);
        var endRow = (deleteLastNewLine ? lastRow + 1 : lastRow);
        var endCol = (deleteLastNewLine ? 0 : this.getLine(endRow).length);
        var range = new Range(startRow, startCol, endRow, endCol);
        var deletedLines = this.$lines.slice(firstRow, lastRow + 1);
        this.applyDelta({
            start: range.start,
            end: range.end,
            action: "remove",
            lines: this.getLinesForRange(range)
        });
        return deletedLines;
    };
    Document.prototype.removeNewLine = function (row) {
        if (row < this.getLength() - 1 && row >= 0) {
            this.applyDelta({
                start: this.pos(row, this.getLine(row).length),
                end: this.pos(row + 1, 0),
                action: "remove",
                lines: ["", ""]
            });
        }
    };
    Document.prototype.replace = function (range, text) {
        if (!(range instanceof Range))
            range = Range.fromPoints(range.start, range.end);
        if (text.length === 0 && range.isEmpty())
            return range.start;
        if (text == this.getTextRange(range))
            return range.end;
        this.remove(range);
        var end;
        if (text) {
            end = this.insert(range.start, text);
        }
        else {
            end = range.start;
        }
        return end;
    };
    Document.prototype.applyDeltas = function (deltas) {
        for (var i = 0; i < deltas.length; i++) {
            this.applyDelta(deltas[i]);
        }
    };
    Document.prototype.revertDeltas = function (deltas) {
        for (var i = deltas.length - 1; i >= 0; i--) {
            this.revertDelta(deltas[i]);
        }
    };
    Document.prototype.applyDelta = function (delta, doNotValidate) {
        var isInsert = delta.action == "insert";
        if (isInsert ? delta.lines.length <= 1 && !delta.lines[0]
            : !Range.comparePoints(delta.start, delta.end)) {
            return;
        }
        if (isInsert && delta.lines.length > 20000) {
            this.$splitAndapplyLargeDelta(delta, 20000);
        }
        else {
            applyDelta(this.$lines, delta, doNotValidate);
            this._signal("change", delta);
        }
    };
    Document.prototype.$safeApplyDelta = function (delta) {
        var docLength = this.$lines.length;
        if (delta.action == "remove" && delta.start.row < docLength && delta.end.row < docLength
            || delta.action == "insert" && delta.start.row <= docLength) {
            this.applyDelta(delta);
        }
    };
    Document.prototype.$splitAndapplyLargeDelta = function (delta, MAX) {
        var lines = delta.lines;
        var l = lines.length - MAX + 1;
        var row = delta.start.row;
        var column = delta.start.column;
        for (var from = 0, to = 0; from < l; from = to) {
            to += MAX - 1;
            var chunk = lines.slice(from, to);
            chunk.push("");
            this.applyDelta({
                start: this.pos(row + from, column),
                end: this.pos(row + to, column = 0),
                action: delta.action,
                lines: chunk
            }, true);
        }
        delta.lines = lines.slice(from);
        delta.start.row = row + from;
        delta.start.column = column;
        this.applyDelta(delta, true);
    };
    Document.prototype.revertDelta = function (delta) {
        this.$safeApplyDelta({
            start: this.clonePos(delta.start),
            end: this.clonePos(delta.end),
            action: (delta.action == "insert" ? "remove" : "insert"),
            lines: delta.lines.slice()
        });
    };
    Document.prototype.indexToPosition = function (index, startRow) {
        var lines = this.$lines || this.getAllLines();
        var newlineLength = this.getNewLineCharacter().length;
        for (var i = startRow || 0, l = lines.length; i < l; i++) {
            index -= lines[i].length + newlineLength;
            if (index < 0)
                return { row: i, column: index + lines[i].length + newlineLength };
        }
        return { row: l - 1, column: index + lines[l - 1].length + newlineLength };
    };
    Document.prototype.positionToIndex = function (pos, startRow) {
        var lines = this.$lines || this.getAllLines();
        var newlineLength = this.getNewLineCharacter().length;
        var index = 0;
        var row = Math.min(pos.row, lines.length);
        for (var i = startRow || 0; i < row; ++i)
            index += lines[i].length + newlineLength;
        return index + pos.column;
    };
    Document.prototype.$split = function (text) {
        return text.split(/\r\n|\r|\n/);
    };
    return Document;
}());
Document.prototype.$autoNewLine = "";
Document.prototype.$newLineMode = "auto";
oop.implement(Document.prototype, EventEmitter);
exports.Document = Document;

});

ace.define("ace/lib/deep_copy",[], function(require, exports, module){exports.deepCopy = function deepCopy(obj) {
    if (typeof obj !== "object" || !obj)
        return obj;
    var copy;
    if (Array.isArray(obj)) {
        copy = [];
        for (var key = 0; key < obj.length; key++) {
            copy[key] = deepCopy(obj[key]);
        }
        return copy;
    }
    if (Object.prototype.toString.call(obj) !== "[object Object]")
        return obj;
    copy = {};
    for (var key in obj)
        copy[key] = deepCopy(obj[key]);
    return copy;
};

});

ace.define("ace/lib/lang",[], function(require, exports, module){"use strict";
exports.last = function (a) {
    return a[a.length - 1];
};
exports.stringReverse = function (string) {
    return string.split("").reverse().join("");
};
exports.stringRepeat = function (string, count) {
    var result = '';
    while (count > 0) {
        if (count & 1)
            result += string;
        if (count >>= 1)
            string += string;
    }
    return result;
};
var trimBeginRegexp = /^\s\s*/;
var trimEndRegexp = /\s\s*$/;
exports.stringTrimLeft = function (string) {
    return string.replace(trimBeginRegexp, '');
};
exports.stringTrimRight = function (string) {
    return string.replace(trimEndRegexp, '');
};
exports.copyObject = function (obj) {
    var copy = {};
    for (var key in obj) {
        copy[key] = obj[key];
    }
    return copy;
};
exports.copyArray = function (array) {
    var copy = [];
    for (var i = 0, l = array.length; i < l; i++) {
        if (array[i] && typeof array[i] == "object")
            copy[i] = this.copyObject(array[i]);
        else
            copy[i] = array[i];
    }
    return copy;
};
exports.deepCopy = require("./deep_copy").deepCopy;
exports.arrayToMap = function (arr) {
    var map = {};
    for (var i = 0; i < arr.length; i++) {
        map[arr[i]] = 1;
    }
    return map;
};
exports.createMap = function (props) {
    var map = Object.create(null);
    for (var i in props) {
        map[i] = props[i];
    }
    return map;
};
exports.arrayRemove = function (array, value) {
    for (var i = 0; i <= array.length; i++) {
        if (value === array[i]) {
            array.splice(i, 1);
        }
    }
};
exports.escapeRegExp = function (str) {
    return str.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1');
};
exports.escapeHTML = function (str) {
    return ("" + str).replace(/&/g, "&#38;").replace(/"/g, "&#34;").replace(/'/g, "&#39;").replace(/</g, "&#60;");
};
exports.getMatchOffsets = function (string, regExp) {
    var matches = [];
    string.replace(regExp, function (str) {
        matches.push({
            offset: arguments[arguments.length - 2],
            length: str.length
        });
    });
    return matches;
};
exports.deferredCall = function (fcn) {
    var timer = null;
    var callback = function () {
        timer = null;
        fcn();
    };
    var deferred = function (timeout) {
        deferred.cancel();
        timer = setTimeout(callback, timeout || 0);
        return deferred;
    };
    deferred.schedule = deferred;
    deferred.call = function () {
        this.cancel();
        fcn();
        return deferred;
    };
    deferred.cancel = function () {
        clearTimeout(timer);
        timer = null;
        return deferred;
    };
    deferred.isPending = function () {
        return timer;
    };
    return deferred;
};
exports.delayedCall = function (fcn, defaultTimeout) {
    var timer = null;
    var callback = function () {
        timer = null;
        fcn();
    };
    var _self = function (timeout) {
        if (timer == null)
            timer = setTimeout(callback, timeout || defaultTimeout);
    };
    _self.delay = function (timeout) {
        timer && clearTimeout(timer);
        timer = setTimeout(callback, timeout || defaultTimeout);
    };
    _self.schedule = _self;
    _self.call = function () {
        this.cancel();
        fcn();
    };
    _self.cancel = function () {
        timer && clearTimeout(timer);
        timer = null;
    };
    _self.isPending = function () {
        return timer;
    };
    return _self;
};
exports.supportsLookbehind = function () {
    try {
        new RegExp('(?<=.)');
    }
    catch (e) {
        return false;
    }
    return true;
};
exports.supportsUnicodeFlag = function () {
    try {
        new RegExp('^.$', 'u');
    }
    catch (error) {
        return false;
    }
    return true;
};

});

ace.define("ace/worker/mirror",[], function(require, exports, module) {
"use strict";

doc.applyDelta(d, true);
            }
        }
        if (_self.$timeout)
            return deferredUpdate.schedule(_self.$timeout);
        _self.onUpdate();
    });
};

});

ace.define("ace/mode/php/php",[], function (require, exports, module) {

var PHP = {Constants: {}};

PHP.Constants.T_THROW = 317
	PHP.Constants.T_INCLUDE = 272
	PHP.Constants.T_INCLUDE_ONCE = 273
	PHP.Constants.T_EVAL = 274
	PHP.Constants.T_REQUIRE = 275
	PHP.Constants.T_REQUIRE_ONCE = 276
	PHP.Constants.T_LOGICAL_OR = 277
	PHP.Constants.T_LOGICAL_XOR = 278
	PHP.Constants.T_LOGICAL_AND = 279
	PHP.Constants.T_PRINT = 280
	PHP.Constants.T_YIELD = 281
	PHP.Constants.T_DOUBLE_ARROW = 386
	PHP.Constants.T_YIELD_FROM = 282
	PHP.Constants.T_PLUS_EQUAL = 352
	PHP.Constants.T_MINUS_EQUAL = 353
	PHP.Constants.T_MUL_EQUAL = 354
	PHP.Constants.T_DIV_EQUAL = 355
	PHP.Constants.T_CONCAT_EQUAL = 356
	PHP.Constants.T_MOD_EQUAL = 357
	PHP.Constants.T_AND_EQUAL = 358
	PHP.Constants.T_OR_EQUAL = 359
	PHP.Constants.T_XOR_EQUAL = 360
	PHP.Constants.T_SL_EQUAL = 361
	PHP.Constants.T_SR_EQUAL = 362
	PHP.Constants.T_POW_EQUAL = 402
	PHP.Constants.T_COALESCE_EQUAL = 363
	PHP.Constants.T_COALESCE = 400
	PHP.Constants.T_BOOLEAN_OR = 364
	PHP.Constants.T_BOOLEAN_AND = 365
	PHP.Constants.T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG = 404
	PHP.Constants.T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG = 403
	PHP.Constants.T_IS_EQUAL = 366
	PHP.Constants.T_IS_NOT_EQUAL = 367
	PHP.Constants.T_IS_IDENTICAL = 368
	PHP.Constants.T_IS_NOT_IDENTICAL = 369
	PHP.Constants.T_SPACESHIP = 372
	PHP.Constants.T_IS_SMALLER_OR_EQUAL = 370
	PHP.Constants.T_IS_GREATER_OR_EQUAL = 371
	PHP.Constants.T_SL = 373
	PHP.Constants.T_SR = 374
	PHP.Constants.T_INSTANCEOF = 283
	PHP.Constants.T_INC = 375
	PHP.Constants.T_DEC = 376
	PHP.Constants.T_INT_CAST = 377
	PHP.Constants.T_DOUBLE_CAST = 378
	PHP.Constants.T_STRING_CAST = 379
	PHP.Constants.T_ARRAY_CAST = 380
	PHP.Constants.T_OBJECT_CAST = 381
	PHP.Constants.T_BOOL_CAST = 382
	PHP.Constants.T_UNSET_CAST = 383
	PHP.Constants.T_POW = 401
	PHP.Constants.T_NEW = 284
	PHP.Constants.T_CLONE = 285
	PHP.Constants.T_EXIT = 286
	PHP.Constants.T_IF = 287
	PHP.Constants.T_ELSEIF = 288
	PHP.Constants.T_ELSE = 289
	PHP.Constants.T_ENDIF = 290
	PHP.Constants.T_LNUMBER = 260
	PHP.Constants.T_DNUMBER = 261
	PHP.Constants.T_STRING = 262
	PHP.Constants.T_STRING_VARNAME = 270
	PHP.Constants.T_VARIABLE = 266
	PHP.Constants.T_NUM_STRING = 271
	PHP.Constants.T_INLINE_HTML = 267
	PHP.Constants.T_ENCAPSED_AND_WHITESPACE = 268
	PHP.Constants.T_CONSTANT_ENCAPSED_STRING = 269
	PHP.Constants.T_ECHO = 291
	PHP.Constants.T_DO = 292
	PHP.Constants.T_WHILE = 293
	PHP.Constants.T_ENDWHILE = 294
	PHP.Constants.T_FOR = 295
	PHP.Constants.T_ENDFOR = 296
	PHP.Constants.T_FOREACH = 297
	PHP.Constants.T_ENDFOREACH = 298
	PHP.Constants.T_DECLARE = 299
	PHP.Constants.T_ENDDECLARE = 300
	PHP.Constants.T_AS = 301
	PHP.Constants.T_SWITCH = 302
	PHP.Constants.T_MATCH = 306
	PHP.Constants.T_ENDSWITCH = 303
	PHP.Constants.T_CASE = 304
	PHP.Constants.T_DEFAULT = 305
	PHP.Constants.T_BREAK = 307
	PHP.Constants.T_CONTINUE = 308
	PHP.Constants.T_GOTO = 309
	PHP.Constants.T_FUNCTION = 310
	PHP.Constants.T_FN = 311
	PHP.Constants.T_CONST = 312
	PHP.Constants.T_RETURN = 313
	PHP.Constants.T_TRY = 314
	PHP.Constants.T_CATCH = 315
	PHP.Constants.T_FINALLY = 316
	PHP.Constants.T_THROW = 317
	PHP.Constants.T_USE = 318
	PHP.Constants.T_INSTEADOF = 319
	PHP.Constants.T_GLOBAL = 320
	PHP.Constants.T_STATIC = 321
	PHP.Constants.T_ABSTRACT = 322
	PHP.Constants.T_FINAL = 323
	PHP.Constants.T_PRIVATE = 324
	PHP.Constants.T_PROTECTED = 325
	PHP.Constants.T_PUBLIC = 326
	PHP.Constants.T_READONLY = 327
	PHP.Constants.T_VAR = 328
	PHP.Constants.T_UNSET = 329
	PHP.Constants.T_ISSET = 330
	PHP.Constants.T_EMPTY = 331
	PHP.Constants.T_HALT_COMPILER = 332
	PHP.Constants.T_CLASS = 333
	PHP.Constants.T_TRAIT = 334
	PHP.Constants.T_INTERFACE = 335
	PHP.Constants.T_ENUM = 336
	PHP.Constants.T_EXTENDS = 337
	PHP.Constants.T_IMPLEMENTS = 338
	PHP.Constants.T_OBJECT_OPERATOR = 384
	PHP.Constants.T_NULLSAFE_OBJECT_OPERATOR = 385
	PHP.Constants.T_DOUBLE_ARROW = 386
	PHP.Constants.T_LIST = 340
	PHP.Constants.T_ARRAY = 341
	PHP.Constants.T_CALLABLE = 342
	PHP.Constants.T_CLASS_C = 346
	PHP.Constants.T_TRAIT_C = 347
	PHP.Constants.T_METHOD_C = 348
	PHP.Constants.T_FUNC_C = 349
	PHP.Constants.T_LINE = 343
	PHP.Constants.T_FILE = 344
	PHP.Constants.T_START_HEREDOC = 393
	PHP.Constants.T_END_HEREDOC = 394
	PHP.Constants.T_DOLLAR_OPEN_CURLY_BRACES = 395
	PHP.Constants.T_CURLY_OPEN = 396
	PHP.Constants.T_PAAMAYIM_NEKUDOTAYIM = 397
	PHP.Constants.T_NAMESPACE = 339
	PHP.Constants.T_NS_C = 350
	PHP.Constants.T_DIR = 345
	PHP.Constants.T_NS_SEPARATOR = 398
	PHP.Constants.T_ELLIPSIS = 399
	PHP.Constants.T_NAME_FULLY_QUALIFIED = 263
	PHP.Constants.T_NAME_QUALIFIED = 265
	PHP.Constants.T_NAME_RELATIVE = 264
	PHP.Constants.T_ATTRIBUTE = 351
	PHP.Constants.T_ENUM = 336
	PHP.Constants.T_BAD_CHARACTER = 405
	PHP.Constants.T_COMMENT = 387
	PHP.Constants.T_DOC_COMMENT = 388
	PHP.Constants.T_OPEN_TAG = 389
	PHP.Constants.T_OPEN_TAG_WITH_ECHO = 390
	PHP.Constants.T_CLOSE_TAG = 391
	PHP.Constants.T_WHITESPACE = 392

PHP.Lexer = function (src, ini) {
		var heredoc, heredocEndAllowed,

stateStack = ['INITIAL'], stackPos = 0,
			swapState = function (state) {
				stateStack[stackPos] = state;
			},
			pushState = function (state) {
				stateStack[++stackPos] = state;
			},
			popState = function () {
				--stackPos;
			},

shortOpenTag = ini === undefined || /^(on|true|1)$/i.test(ini.short_open_tag),
			openTag = shortOpenTag
				? /^(\<\?php(?:\r\n|[ \t\r\n])|<\?|\<script language\=('|")?php('|")?\>)/i
				: /^(\<\?php(?:\r\n|[ \t\r\n])|\<script language\=('|")?php('|")?\>)/i,
			inlineHtml = shortOpenTag
				? /[^<]*(?:<(?!\?|script language\=('|")?php('|")?\>)[^<]*)*/i
				: /[^<]*(?:<(?!\?=|\?php[ \t\r\n]|script language\=('|")?php('|")?\>)[^<]*)*/i,
			labelRegexPart = '[a-zA-Z_\\x7f-\\uffff][a-zA-Z0-9_\\x7f-\\uffff]*',
			stringRegexPart = function (quote) {
				return '[^' + quote + '\\\\${]*(?:(?:\\\\[\\s\\S]|\\$(?!\\{|[a-zA-Z_\\x7f-\\uffff])|\\{(?!\\$))[^' + quote + '\\\\${]*)*';
			},

sharedStringTokens = [
				{
					value: PHP.Constants.T_VARIABLE,
					re: new RegExp('^\\$' + labelRegexPart + '(?=\\[)'),
					func: function () {
						pushState('VAR_OFFSET');
					}
				},
				{
					value: PHP.Constants.T_VARIABLE,
					re: new RegExp('^\\$' + labelRegexPart + '(?=->' + labelRegexPart + ')'),
					func: function () {
						pushState('LOOKING_FOR_PROPERTY');
					}
				},
				{
					value: PHP.Constants.T_DOLLAR_OPEN_CURLY_BRACES,
					re: new RegExp('^\\$\\{(?=' + labelRegexPart + '[\\[}])'),
					func: function () {
						pushState('LOOKING_FOR_VARNAME');
					}
				},
				{
					value: PHP.Constants.T_VARIABLE,
					re: new RegExp('^\\$' + labelRegexPart)
				},
				{
					value: PHP.Constants.T_DOLLAR_OPEN_CURLY_BRACES,
					re: /^\$\{/,
					func: function () {
						pushState('IN_SCRIPTING');
					}
				},
				{
					value: PHP.Constants.T_CURLY_OPEN,
					re: /^\{(?=\$)/,
					func: function () {
						pushState('IN_SCRIPTING');
					}
				}
			],
			data = {
				'INITIAL': [
					{
						value: PHP.Constants.T_OPEN_TAG_WITH_ECHO,
						re: /^<\?=/i,
						func: function () {
							swapState('IN_SCRIPTING');
						}
					},
					{
						value: PHP.Constants.T_OPEN_TAG,
						re: openTag,
						func: function () {
							swapState('IN_SCRIPTING');
						}
					},
					{
						value: PHP.Constants.T_INLINE_HTML,
						re: inlineHtml
					},
				],
				'IN_SCRIPTING': [
					{
						value: PHP.Constants.T_WHITESPACE,
						re: /^[ \n\r\t]+/
					},
					{
						value: PHP.Constants.T_ABSTRACT,
						re: /^abstract\b/i
					},
					{
						value: PHP.Constants.T_LOGICAL_AND,
						re: /^and\b/i
					},
					{
						value: PHP.Constants.T_ARRAY,
						re: /^array\b/i
					},
					{
						value: PHP.Constants.T_AS,
						re: /^as\b/i
					},
					{
						value: PHP.Constants.T_BREAK,
						re: /^break\b/i
					},
					{
						value: PHP.Constants.T_CALLABLE,
						re: /^callable\b/i
					},
					{
						value: PHP.Constants.T_CASE,
						re: /^case\b/i
					},
					{
						value: PHP.Constants.T_CATCH,
						re: /^catch\b/i
					},
					{
						value: PHP.Constants.T_CLASS,
						re: /^class\b/i,
					},
					{
						value: PHP.Constants.T_CLONE,
						re: /^clone\b/i
					},
					{
						value: PHP.Constants.T_CONST,
						re: /^const\b/i
					},
					{
						value: PHP.Constants.T_CONTINUE,
						re: /^continue\b/i
					},
					{
						value: PHP.Constants.T_DECLARE,
						re: /^declare\b/i
					},
					{
						value: PHP.Constants.T_DEFAULT,
						re: /^default\b/i
					},
					{
						value: PHP.Constants.T_DO,
						re: /^do\b/i
					},
					{
						value: PHP.Constants.T_ECHO,
						re: /^echo\b/i
					},
					{
						value: PHP.Constants.T_ELSE,
						re: /^else\b/i
					},
					{
						value: PHP.Constants.T_ELSEIF,
						re: /^elseif\b/i
					},
					{
						value: PHP.Constants.T_ENUM,
						re: /^enum\b/i
					},
					{
						value: PHP.Constants.T_ENDDECLARE,
						re: /^enddeclare\b/i
					},
					{
						value: PHP.Constants.T_ENDFOR,
						re: /^endfor\b/i
					},
					{
						value: PHP.Constants.T_ENDFOREACH,
						re: /^endforeach\b/i
					},
					{
						value: PHP.Constants.T_ENDIF,
						re: /^endif\b/i
					},
					{
						value: PHP.Constants.T_ENDSWITCH,
						re: /^endswitch\b/i
					},
					{
						value: PHP.Constants.T_ENDWHILE,
						re: /^endwhile\b/i
					},
					{
						value: PHP.Constants.T_ENUM,
						re: /^enum\b/i
					},
					{
						value: PHP.Constants.T_EMPTY,
						re: /^empty\b/i
					},
					{
						value: PHP.Constants.T_EVAL,
						re: /^eval\b/i
					},
					{
						value: PHP.Constants.T_EXIT,
						re: /^(?:exit|die)\b/i
					},
					{
						value: PHP.Constants.T_EXTENDS,
						re: /^extends\b/i
					},
					{
						value: PHP.Constants.T_FINAL,
						re: /^final\b/i
					},
					{
						value: PHP.Constants.T_FINALLY,
						re: /^finally\b/i
					},
					{
						value: PHP.Constants.T_FN,
						re: /^fn\b/i
					},
					{
						value: PHP.Constants.T_FOR,
						re: /^for\b/i
					},
					{
						value: PHP.Constants.T_FOREACH,
						re: /^foreach\b/i
					},
					{
						value: PHP.Constants.T_FUNCTION,
						re: /^function\b/i
					},
					{
						value: PHP.Constants.T_GLOBAL,
						re: /^global\b/i
					},
					{
						value: PHP.Constants.T_GOTO,
						re: /^goto\b/i
					},
					{
						value: PHP.Constants.T_IF,
						re: /^if\b/i
					},
					{
						value: PHP.Constants.T_IMPLEMENTS,
						re: /^implements\b/i
					},
					{
						value: PHP.Constants.T_INCLUDE,
						re: /^include\b/i
					},
					{
						value: PHP.Constants.T_INCLUDE_ONCE,
						re: /^include_once\b/i
					},
					{
						value: PHP.Constants.T_INSTANCEOF,
						re: /^instanceof\b/i
					},
					{
						value: PHP.Constants.T_INSTEADOF,
						re: /^insteadof\b/i
					},
					{
						value: PHP.Constants.T_INTERFACE,
						re: /^interface\b/i
					},
					{
						value: PHP.Constants.T_ISSET,
						re: /^isset\b/i
					},
					{
						value: PHP.Constants.T_LIST,
						re: /^list\b/i
					},
					{
						value: PHP.Constants.T_MATCH,
						re: /^match\b/i
					},
					{
						value: PHP.Constants.T_NEW,
						re: /^new\b/i
					},
					{
						value: PHP.Constants.T_LOGICAL_OR,
						re: /^or\b/i
					},
					{
						value: PHP.Constants.T_PRINT,
						re: /^print\b/i
					},
					{
						value: PHP.Constants.T_PRIVATE,
						re: /^private\b/i
					},
					{
						value: PHP.Constants.T_PROTECTED,
						re: /^protected\b/i
					},
					{
						value: PHP.Constants.T_PUBLIC,
						re: /^public\b/i
					},
					{
						value: PHP.Constants.T_READONLY,
						re: /^readonly\b/i
					},
					{
						value: PHP.Constants.T_REQUIRE,
						re: /^require\b/i
					},
					{
						value: PHP.Constants.T_REQUIRE_ONCE,
						re: /^require_once\b/i
					},
					{
						value: PHP.Constants.T_STATIC,
						re: /^static\b/i
					},
					{
						value: PHP.Constants.T_SWITCH,
						re: /^switch\b/i
					},
					{
						value: PHP.Constants.T_THROW,
						re: /^throw\b/i
					},
					{
						value: PHP.Constants.T_TRAIT,
						re: /^trait\b/i,
					},
					{
						value: PHP.Constants.T_TRY,
						re: /^try\b/i
					},
					{
						value: PHP.Constants.T_UNSET,
						re: /^unset\b/i
					},
					{
						value: PHP.Constants.T_USE,
						re: /^use\b/i
					},
					{
						value: PHP.Constants.T_VAR,
						re: /^var\b/i
					},
					{
						value: PHP.Constants.T_WHILE,
						re: /^while\b/i
					},
					{
						value: PHP.Constants.T_LOGICAL_XOR,
						re: /^xor\b/i
					},
					{
						value: PHP.Constants.T_YIELD_FROM,
						re: /^yield\s+from\b/i
					},
					{
						value: PHP.Constants.T_YIELD,
						re: /^yield\b/i
					},
					{
						value: PHP.Constants.T_RETURN,
						re: /^return\b/i
					},
					{
						value: PHP.Constants.T_METHOD_C,
						re: /^__METHOD__\b/i
					},
					{
						value: PHP.Constants.T_LINE,
						re: /^__LINE__\b/i
					},
					{
						value: PHP.Constants.T_FILE,
						re: /^__FILE__\b/i
					},
					{
						value: PHP.Constants.T_FUNC_C,
						re: /^__FUNCTION__\b/i
					},
					{
						value: PHP.Constants.T_NS_C,
						re: /^__NAMESPACE__\b/i
					},
					{
						value: PHP.Constants.T_TRAIT_C,
						re: /^__TRAIT__\b/i
					},
					{
						value: PHP.Constants.T_DIR,
						re: /^__DIR__\b/i
					},
					{
						value: PHP.Constants.T_CLASS_C,
						re: /^__CLASS__\b/i
					},
					{
						value: PHP.Constants.T_AND_EQUAL,
						re: /^&=/
					},
					{
						value: PHP.Constants.T_ARRAY_CAST,
						re: /^$[ \t]*array[ \t]*$/i
					},
					{
						value: PHP.Constants.T_BOOL_CAST,
						re: /^$[ \t]*(?:bool|boolean)[ \t]*$/i
					},
					{
						value: PHP.Constants.T_DOUBLE_CAST,
						re: /^$[ \t]*(?:real|float|double)[ \t]*$/i
					},
					{
						value: PHP.Constants.T_INT_CAST,
						re: /^$[ \t]*(?:int|integer)[ \t]*$/i
					},
					{
						value: PHP.Constants.T_OBJECT_CAST,
						re: /^$[ \t]*object[ \t]*$/i
					},
					{
						value: PHP.Constants.T_STRING_CAST,
						re: /^$[ \t]*(?:binary|string)[ \t]*$/i
					},
					{
						value: PHP.Constants.T_UNSET_CAST,
						re: /^$[ \t]*unset[ \t]*$/i
					},
					{
						value: PHP.Constants.T_BOOLEAN_AND,
						re: /^&&/
					},
					{
						value: PHP.Constants.T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG,
						re: /^&(?=[$])/
					},
					{
						value: PHP.Constants.T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG,
						re: /^(&)(?=[^\$|^&])/
					},
					{
						value: PHP.Constants.T_BOOLEAN_OR,
						re: /^\|\|/
					},
					{
						value: PHP.Constants.T_CLOSE_TAG,
						re: /^(?:\?>|<\/script>)(\r\n|\r|\n)?/i,
						func: function () {
							swapState('INITIAL');
						}
					},
					{
						value: PHP.Constants.T_DOUBLE_ARROW,
						re: /^=>/
					},
					{
						value: PHP.Constants.T_PAAMAYIM_NEKUDOTAYIM,
						re: /^::/
					},
					{
						value: PHP.Constants.T_INC,
						re: /^\+\+/
					},
					{
						value: PHP.Constants.T_DEC,
						re: /^--/
					},
					{
						value: PHP.Constants.T_CONCAT_EQUAL,
						re: /^\.=/
					},
					{
						value: PHP.Constants.T_DIV_EQUAL,
						re: /^\/=/
					},
					{
						value: PHP.Constants.T_XOR_EQUAL,
						re: /^\^=/
					},
					{
						value: PHP.Constants.T_MUL_EQUAL,
						re: /^\*=/
					},
					{
						value: PHP.Constants.T_MOD_EQUAL,
						re: /^%=/
					},
					{
						value: PHP.Constants.T_SL_EQUAL,
						re: /^<<=/
					},
					{
						value: PHP.Constants.T_START_HEREDOC,
						re: new RegExp('^[bB]?<<<[ \\t]*\'(' + labelRegexPart + ')\'(?:\\r\\n|\\r|\\n)'),
						func: function (result) {
							heredoc = result[1];
							swapState('NOWDOC');
						}
					},
					{
						value: PHP.Constants.T_START_HEREDOC,
						re: new RegExp('^[bB]?<<<[ \\t]*("?)(' + labelRegexPart + ')\\1(?:\\r\\n|\\r|\\n)'),
						func: function (result) {
							heredoc = result[2];
							heredocEndAllowed = true;
							swapState('HEREDOC');
						}
					},
					{
						value: PHP.Constants.T_SL,
						re: /^<</
					},
					{
						value: PHP.Constants.T_SPACESHIP,
						re: /^<=>/
					},
					{
						value: PHP.Constants.T_IS_SMALLER_OR_EQUAL,
						re: /^<=/
					},
					{
						value: PHP.Constants.T_SR_EQUAL,
						re: /^>>=/
					},
					{
						value: PHP.Constants.T_SR,
						re: /^>>/
					},
					{
						value: PHP.Constants.T_IS_GREATER_OR_EQUAL,
						re: /^>=/
					},
					{
						value: PHP.Constants.T_OR_EQUAL,
						re: /^\|=/
					},
					{
						value: PHP.Constants.T_PLUS_EQUAL,
						re: /^\+=/
					},
					{
						value: PHP.Constants.T_MINUS_EQUAL,
						re: /^-=/
					},
					{
						value: PHP.Constants.T_OBJECT_OPERATOR,
						re: new RegExp('^->(?=[ \n\r\t]*' + labelRegexPart + ')'),
						func: function () {
							pushState('LOOKING_FOR_PROPERTY');
						}
					},
					{
						value: PHP.Constants.T_OBJECT_OPERATOR,
						re: /^->/i
					},
					{
						value: PHP.Constants.T_ELLIPSIS,
						re: /^\.\.\./
					},
					{
						value: PHP.Constants.T_POW_EQUAL,
						re: /^\*\*=/
					},
					{
						value: PHP.Constants.T_POW,
						re: /^\*\*/
					},
					{
						value: PHP.Constants.T_COALESCE_EQUAL,
						re: /^\?\?=/
					},
					{
						value: PHP.Constants.T_COALESCE,
						re: /^\?\?/
					},
					{
						value: PHP.Constants.T_NULLSAFE_OBJECT_OPERATOR,
						re: /^\?->/
					},
					{
						value: PHP.Constants.T_NAME_FULLY_QUALIFIED,
						re: /^\\\w+(?:\\\w+)*/
					},
					{
						value: PHP.Constants.T_NAME_QUALIFIED,
						re: /^\w+\\\w+(?:\\\w+)*/
					},
					{
						value: PHP.Constants.T_NAME_RELATIVE,
						re: /^namespace\\\w+(?:\\\w+)*/
					},
					{
						value: PHP.Constants.T_NAMESPACE,
						re: /^namespace\b/i
					},
					{
						value: PHP.Constants.T_ATTRIBUTE,
						re: /^#\[([\S\s]*?)]/
					},
					{
						value: PHP.Constants.T_COMMENT,
						re: /^\/\*([\S\s]*?)(?:\*\/|$)/
					},
					{
						value: PHP.Constants.T_COMMENT,
						re: /^(?:\/\/|#)[^\r\n?]*(?:\?(?!>)[^\r\n?]*)*(?:\r\n|\r|\n)?/
					},
					{
						value: PHP.Constants.T_IS_IDENTICAL,
						re: /^===/
					},
					{
						value: PHP.Constants.T_IS_EQUAL,
						re: /^==/
					},
					{
						value: PHP.Constants.T_IS_NOT_IDENTICAL,
						re: /^!==/
					},
					{
						value: PHP.Constants.T_IS_NOT_EQUAL,
						re: /^(!=|<>)/
					},
					{
						value: PHP.Constants.T_DNUMBER,
						re: /^(?:[0-9]+\.[0-9]*|\.[0-9]+)(?:[eE][+-]?[0-9]+)?/
					},
					{
						value: PHP.Constants.T_DNUMBER,
						re: /^[0-9]+[eE][+-]?[0-9]+/
					},
					{
						value: PHP.Constants.T_LNUMBER,
						re: /^(?:0x[0-9A-F]+|0b[01]+|[0-9]+)/i
					},
					{
						value: PHP.Constants.T_VARIABLE,
						re: new RegExp('^\\$' + labelRegexPart)
					},
					{
						value: PHP.Constants.T_CONSTANT_ENCAPSED_STRING,
						re: /^[bB]?'[^'\\]*(?:\\[\s\S][^'\\]*)*'/,
					},
					{
						value: PHP.Constants.T_CONSTANT_ENCAPSED_STRING,
						re: new RegExp('^[bB]?"' + stringRegexPart('"') + '"')
					},
					{
						value: -1,
						re: /^[bB]?"/,
						func: function () {
							swapState('DOUBLE_QUOTES');
						}
					},
					{
						value: -1,
						re: /^`/,
						func: function () {
							swapState('BACKTICKS');
						}
					},
					{
						value: PHP.Constants.T_NS_SEPARATOR,
						re: /^\\/
					},
					{
						value: PHP.Constants.T_STRING,
						re: /^[a-zA-Z_\x7f-\uffff][a-zA-Z0-9_\x7f-\uffff]*/
					},
					{
						value: -1,
						re: /^\{/,
						func: function () {
							pushState('IN_SCRIPTING');
						}
					},
					{
						value: -1,
						re: /^\}/,
						func: function () {
							if (stackPos > 0) {
								popState();
							}
						}
					},
					{
						value: -1,
						re: /^[\[\];:?()!.,><=+-/*|&@^%"'$~]/
					}
				],
				'DOUBLE_QUOTES': sharedStringTokens.concat([
					{
						value: -1,
						re: /^"/,
						func: function () {
							swapState('IN_SCRIPTING');
						}
					},
					{
						value: PHP.Constants.T_ENCAPSED_AND_WHITESPACE,
						re: new RegExp('^' + stringRegexPart('"'))
					}
				]),
				'BACKTICKS': sharedStringTokens.concat([
					{
						value: -1,
						re: /^`/,
						func: function () {
							swapState('IN_SCRIPTING');
						}
					},
					{
						value: PHP.Constants.T_ENCAPSED_AND_WHITESPACE,
						re: new RegExp('^' + stringRegexPart('`'))
					}
				]),
				'VAR_OFFSET': [
					{
						value: -1,
						re: /^\]/,
						func: function () {
							popState();
						}
					},
					{
						value: PHP.Constants.T_NUM_STRING,
						re: /^(?:0x[0-9A-F]+|0b[01]+|[0-9]+)/i
					},
					{
						value: PHP.Constants.T_VARIABLE,
						re: new RegExp('^\\$' + labelRegexPart)
					},
					{
						value: PHP.Constants.T_STRING,
						re: new RegExp('^' + labelRegexPart)
					},
					{
						value: -1,
						re: /^[;:,.\[()|^&+-/*=%!~$<>?@{}"`]/
					}
				],
				'LOOKING_FOR_PROPERTY': [
					{
						value: PHP.Constants.T_OBJECT_OPERATOR,
						re: /^->/
					},
					{
						value: PHP.Constants.T_STRING,
						re: new RegExp('^' + labelRegexPart),
						func: function () {
							popState();
						}
					},
					{
						value: PHP.Constants.T_WHITESPACE,
						re: /^[ \n\r\t]+/
					}
				],
				'LOOKING_FOR_VARNAME': [
					{
						value: PHP.Constants.T_STRING_VARNAME,
						re: new RegExp('^' + labelRegexPart + '(?=[\\[}])'),
						func: function () {
							swapState('IN_SCRIPTING');
						}
					}
				],
				'NOWDOC': [
					{
						value: PHP.Constants.T_END_HEREDOC,
						matchFunc: function (src) {
							var re = new RegExp('^' + heredoc + '(?=;?[\\r\\n])');
							if (src.match(re)) {
								return [src.substr(0, heredoc.length)];
							} else {
								return null;
							}
						},
						func: function () {
							swapState('IN_SCRIPTING');
						}
					},
					{
						value: PHP.Constants.T_ENCAPSED_AND_WHITESPACE,
						matchFunc: function (src) {
							var re = new RegExp('[\\r\\n]' + heredoc + '(?=;?[\\r\\n])');
							var result = re.exec(src);
							var end = result ? result.index + 1 : src.length;
							return [src.substring(0, end)];
						}
					}
				],
				'HEREDOC': sharedStringTokens.concat([
					{
						value: PHP.Constants.T_END_HEREDOC,
						matchFunc: function (src) {
							if (!heredocEndAllowed) {
								return null;
							}
							var re = new RegExp('^' + heredoc + '(?=;?[\\r\\n])');
							if (src.match(re)) {
								return [src.substr(0, heredoc.length)];
							} else {
								return null;
							}
						},
						func: function () {
							swapState('IN_SCRIPTING');
						}
					},
					{
						value: PHP.Constants.T_ENCAPSED_AND_WHITESPACE,
						matchFunc: function (src) {
							var end = src.length;
							var re = new RegExp('^' + stringRegexPart(''));
							var result = re.exec(src);
							if (result) {
								end = result[0].length;
							}
							re = new RegExp('([\\r\\n])' + heredoc + '(?=;?[\\r\\n])');
							result = re.exec(src.substring(0, end));
							if (result) {
								end = result.index + 1;
								heredocEndAllowed = true;
							} else {
								heredocEndAllowed = false;
							}
							if (end == 0) {
								return null;
							}
							return [src.substring(0, end)];
						}
					}
				])
			};

var results = [],
			line = 1,
			cancel = true;

if (src === null) {
			return results;
		}

if (typeof src !== "string") {
			src = src.toString();
		}

while (src.length > 0 && cancel === true) {
			var state = stateStack[stackPos];
			var tokens = data[state];
			cancel = tokens.some(function (token) {
				var result = token.matchFunc !== undefined
					? token.matchFunc(src)
					: src.match(token.re);
				if (result !== null) {
					if (result[0].length == 0) {
						throw new Error("empty match");
					}

if (token.func !== undefined) {
						token.func(result);
					}

if (token.value === -1) {
						results.push(result[0]);
					} else {
						var resultString = result[0];
						results.push([
							parseInt(token.value, 10),
							resultString,
							line
						]);
						line += resultString.split('\n').length - 1;
					}

src = src.substring(result[0].length);

return true;
				}
				return false;
			});
		}

return results;
	};

PHP.Parser = function (preprocessedTokens, evaluate) {

var yybase = this.yybase,
			yydefault = this.yydefault,
			yycheck = this.yycheck,
			yyaction = this.yyaction,
			yylen = this.yylen,
			yygbase = this.yygbase,
			yygcheck = this.yygcheck,
			yyp = this.yyp,
			yygoto = this.yygoto,
			yylhs = this.yylhs,
			terminals = this.terminals,
			translate = this.translate,
			yygdefault = this.yygdefault;

this.pos = -1;
		this.line = 1;

this.tokenMap = this.createTokenMap();

this.dropTokens = {};
		this.dropTokens[PHP.Constants.T_WHITESPACE] = 1;
		this.dropTokens[PHP.Constants.T_OPEN_TAG] = 1;
		var tokens = [];
		preprocessedTokens.forEach(function (token, index) {
			if (typeof token === "object" && token[0] === PHP.Constants.T_OPEN_TAG_WITH_ECHO) {
				tokens.push([
					PHP.Constants.T_OPEN_TAG,
					token[1],
					token[2]
				]);
				tokens.push([
					PHP.Constants.T_ECHO,
					token[1],
					token[2]
				]);
			} else {
				tokens.push(token);
			}
		});
		this.tokens = tokens;
		var tokenId = this.TOKEN_NONE;
		this.startAttributes = {
			'startLine': 1
		};

this.endAttributes = {};
		var attributeStack = [this.startAttributes];
		var state = 0;
		var stateStack = [state];
		this.yyastk = [];
		this.stackPos = 0;

var yyn;

var origTokenId;

for (; ;) {

if (yybase[state] === 0) {
				yyn = yydefault[state];
			} else {
				if (tokenId === this.TOKEN_NONE) {
					origTokenId = this.getNextToken();
					tokenId = (origTokenId >= 0 && origTokenId < this.TOKEN_MAP_SIZE) ? translate[origTokenId] : this.TOKEN_INVALID;

attributeStack[this.stackPos] = this.startAttributes;
				}

if (((yyn = yybase[state] + tokenId) >= 0
						&& yyn < this.YYLAST && yycheck[yyn] === tokenId
						|| (state < this.YY2TBLSTATE
							&& (yyn = yybase[state + this.YYNLSTATES] + tokenId) >= 0
							&& yyn < this.YYLAST
							&& yycheck[yyn] === tokenId))
					&& (yyn = yyaction[yyn]) !== this.YYDEFAULT) {
					if (yyn > 0) {
						++this.stackPos;

stateStack[this.stackPos] = state = yyn;
						this.yyastk[this.stackPos] = this.tokenValue;
						attributeStack[this.stackPos] = this.startAttributes;
						tokenId = this.TOKEN_NONE;

if (yyn < this.YYNLSTATES)
							continue;
						yyn -= this.YYNLSTATES;
					} else {
						yyn = -yyn;
					}
				} else {
					yyn = yydefault[state];
				}
			}

for (; ;) {

if (yyn === 0) {
					return this.yyval;
				} else if (yyn !== this.YYUNEXPECTED) {
					for (var attr in this.endAttributes) {
						attributeStack[this.stackPos - yylen[yyn]][attr] = this.endAttributes[attr];
					}
					this.stackPos -= yylen[yyn];
					yyn = yylhs[yyn];
					if ((yyp = yygbase[yyn] + stateStack[this.stackPos]) >= 0
						&& yyp < this.YYGLAST
						&& yygcheck[yyp] === yyn) {
						state = yygoto[yyp];
					} else {
						state = yygdefault[yyn];
					}

++this.stackPos;

stateStack[this.stackPos] = state;
					this.yyastk[this.stackPos] = this.yyval;
					attributeStack[this.stackPos] = this.startAttributes;
				} else {
					if (evaluate !== true) {

var expected = [];

for (var i = 0; i < this.TOKEN_MAP_SIZE; ++i) {
							if ((yyn = yybase[state] + i) >= 0 && yyn < this.YYLAST && yycheck[yyn] == i
								|| state < this.YY2TBLSTATE
								&& (yyn = yybase[state + this.YYNLSTATES] + i)
								&& yyn < this.YYLAST && yycheck[yyn] == i
							) {
								if (yyaction[yyn] != this.YYUNEXPECTED) {
									if (expected.length == 4) {
										expected = [];
										break;
									}

expected.push(this.terminals[i]);
								}
							}
						}

var expectedString = '';
						if (expected.length) {
							expectedString = ', expecting ' + expected.join(' or ');
						}
						throw new PHP.ParseError('syntax error, unexpected ' + terminals[tokenId] + expectedString, this.startAttributes['startLine']);
					} else {
						return this.startAttributes['startLine'];
					}

}

if (state < this.YYNLSTATES)
					break;
				yyn = state - this.YYNLSTATES;
			}
		}
	};

PHP.ParseError = function (msg, line) {
		this.message = msg;
		this.line = line;
	};

PHP.Parser.prototype.getNextToken = function () {

this.startAttributes = {};
		this.endAttributes = {};

var token,
			tmp;

while (this.tokens[++this.pos] !== undefined) {
			token = this.tokens[this.pos];

if (typeof token === "string") {
				this.startAttributes['startLine'] = this.line;
				this.endAttributes['endLine'] = this.line;
				if ('b"' === token) {
					this.tokenValue = 'b"';
					return '"'.charCodeAt(0);
				} else {
					this.tokenValue = token;
					return token.charCodeAt(0);
				}
			} else {

this.line += ((tmp = token[1].match(/\n/g)) === null) ? 0 : tmp.length;

if (PHP.Constants.T_COMMENT === token[0]) {

if (!Array.isArray(this.startAttributes['comments'])) {
						this.startAttributes['comments'] = [];
					}

this.startAttributes['comments'].push({
						type: "comment",
						comment: token[1],
						line: token[2]
					});

}
				else if (PHP.Constants.T_ATTRIBUTE === token[0]) {
					this.tokenValue = token[1];
					this.startAttributes['startLine'] = token[2];
					this.endAttributes['endLine'] = this.line;
				} else if (PHP.Constants.T_DOC_COMMENT === token[0]) {
					this.startAttributes['comments'].push(new PHPParser_Comment_Doc(token[1], token[2]));
				} else if (this.dropTokens[token[0]] === undefined) {
					this.tokenValue = token[1];
					this.startAttributes['startLine'] = token[2];
					this.endAttributes['endLine'] = this.line;

return this.tokenMap[token[0]];
				}
			}
		}

this.startAttributes['startLine'] = this.line;
		return 0;
	};

PHP.Parser.prototype.tokenName = function (token) {
		var constants = ["T_THROW","T_INCLUDE","T_INCLUDE_ONCE","T_EVAL","T_REQUIRE","T_REQUIRE_ONCE","T_LOGICAL_OR","T_LOGICAL_XOR","T_LOGICAL_AND","T_PRINT","T_YIELD","T_DOUBLE_ARROW","T_YIELD_FROM","T_PLUS_EQUAL","T_MINUS_EQUAL","T_MUL_EQUAL","T_DIV_EQUAL","T_CONCAT_EQUAL","T_MOD_EQUAL","T_AND_EQUAL","T_OR_EQUAL","T_XOR_EQUAL","T_SL_EQUAL","T_SR_EQUAL","T_POW_EQUAL","T_COALESCE_EQUAL","T_COALESCE","T_BOOLEAN_OR","T_BOOLEAN_AND","T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG","T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG","T_IS_EQUAL","T_IS_NOT_EQUAL","T_IS_IDENTICAL","T_IS_NOT_IDENTICAL","T_SPACESHIP","T_IS_SMALLER_OR_EQUAL","T_IS_GREATER_OR_EQUAL","T_SL","T_SR","T_INSTANCEOF","T_INC","T_DEC","T_INT_CAST","T_DOUBLE_CAST","T_STRING_CAST","T_ARRAY_CAST","T_OBJECT_CAST","T_BOOL_CAST","T_UNSET_CAST","T_POW","T_NEW","T_CLONE","T_EXIT","T_IF","T_ELSEIF","T_ELSE","T_ENDIF","T_LNUMBER","T_DNUMBER","T_STRING","T_STRING_VARNAME","T_VARIABLE","T_NUM_STRING","T_INLINE_HTML","T_ENCAPSED_AND_WHITESPACE","T_CONSTANT_ENCAPSED_STRING","T_ECHO","T_DO","T_WHILE","T_ENDWHILE","T_FOR","T_ENDFOR","T_FOREACH","T_ENDFOREACH","T_DECLARE","T_ENDDECLARE","T_AS","T_SWITCH","T_MATCH","T_ENDSWITCH","T_CASE","T_DEFAULT","T_BREAK","T_CONTINUE","T_GOTO","T_FUNCTION","T_FN","T_CONST","T_RETURN","T_TRY","T_CATCH","T_FINALLY","T_THROW","T_USE","T_INSTEADOF","T_GLOBAL","T_STATIC","T_ABSTRACT","T_FINAL","T_PRIVATE","T_PROTECTED","T_PUBLIC","T_READONLY","T_VAR","T_UNSET","T_ISSET","T_EMPTY","T_HALT_COMPILER","T_CLASS","T_TRAIT","T_INTERFACE","T_ENUM","T_EXTENDS","T_IMPLEMENTS","T_OBJECT_OPERATOR","T_NULLSAFE_OBJECT_OPERATOR","T_DOUBLE_ARROW","T_LIST","T_ARRAY","T_CALLABLE","T_CLASS_C","T_TRAIT_C","T_METHOD_C","T_FUNC_C","T_LINE","T_FILE","T_START_HEREDOC","T_END_HEREDOC","T_DOLLAR_OPEN_CURLY_BRACES","T_CURLY_OPEN","T_PAAMAYIM_NEKUDOTAYIM","T_NAMESPACE","T_NS_C","T_DIR","T_NS_SEPARATOR","T_ELLIPSIS","T_NAME_FULLY_QUALIFIED","T_NAME_QUALIFIED","T_NAME_RELATIVE","T_ATTRIBUTE","T_ENUM","T_BAD_CHARACTER","T_COMMENT","T_DOC_COMMENT","T_OPEN_TAG","T_OPEN_TAG_WITH_ECHO","T_CLOSE_TAG","T_WHITESPACE"];
		var current = "UNKNOWN";
		constants.some(function (constant) {
			if (PHP.Constants[constant] === token) {
				current = constant;
				return true;
			} else {
				return false;
			}
		});

return current;
	};

PHP.Parser.prototype.createTokenMap = function () {
		var tokenMap = {},
			name,
			i;
		for (i = 256; i < 1000; ++i) {
			if (PHP.Constants.T_OPEN_TAG_WITH_ECHO === i) {
				tokenMap[i] = PHP.Constants.T_ECHO;
			} else if (PHP.Constants.T_CLOSE_TAG === i) {
				tokenMap[i] = 59;
			} else if ('UNKNOWN' !== (name = this.tokenName(i))) {
				tokenMap[i] = this[name];
			}
		}
		return tokenMap;
	};

PHP.Parser.prototype.TOKEN_NONE    = -1;
	PHP.Parser.prototype.TOKEN_INVALID = 175;

PHP.Parser.prototype.TOKEN_MAP_SIZE = 403;

PHP.Parser.prototype.YYLAST       = 1196;
	PHP.Parser.prototype.YY2TBLSTATE  = 420;
	PHP.Parser.prototype.YYGLAST      = 545;
	PHP.Parser.prototype.YYNLSTATES   = 710;
	PHP.Parser.prototype.YYUNEXPECTED = 32767;
	PHP.Parser.prototype.YYDEFAULT    = -32766;
	PHP.Parser.prototype.YYERRTOK = 256;
	PHP.Parser.prototype.T_THROW = 257;
	PHP.Parser.prototype.T_INCLUDE = 258;
	PHP.Parser.prototype.T_INCLUDE_ONCE = 259;
	PHP.Parser.prototype.T_EVAL = 260;
	PHP.Parser.prototype.T_REQUIRE = 261;
	PHP.Parser.prototype.T_REQUIRE_ONCE = 262;
	PHP.Parser.prototype.T_LOGICAL_OR = 263;
	PHP.Parser.prototype.T_LOGICAL_XOR = 264;
	PHP.Parser.prototype.T_LOGICAL_AND = 265;
	PHP.Parser.prototype.T_PRINT = 266;
	PHP.Parser.prototype.T_YIELD = 267;
	PHP.Parser.prototype.T_DOUBLE_ARROW = 268;
	PHP.Parser.prototype.T_YIELD_FROM = 269;
	PHP.Parser.prototype.T_PLUS_EQUAL = 270;
	PHP.Parser.prototype.T_MINUS_EQUAL = 271;
	PHP.Parser.prototype.T_MUL_EQUAL = 272;
	PHP.Parser.prototype.T_DIV_EQUAL = 273;
	PHP.Parser.prototype.T_CONCAT_EQUAL = 274;
	PHP.Parser.prototype.T_MOD_EQUAL = 275;
	PHP.Parser.prototype.T_AND_EQUAL = 276;
	PHP.Parser.prototype.T_OR_EQUAL = 277;
	PHP.Parser.prototype.T_XOR_EQUAL = 278;
	PHP.Parser.prototype.T_SL_EQUAL = 279;
	PHP.Parser.prototype.T_SR_EQUAL = 280;
	PHP.Parser.prototype.T_POW_EQUAL = 281;
	PHP.Parser.prototype.T_COALESCE_EQUAL = 282;
	PHP.Parser.prototype.T_COALESCE = 283;
	PHP.Parser.prototype.T_BOOLEAN_OR = 284;
	PHP.Parser.prototype.T_BOOLEAN_AND = 285;
	PHP.Parser.prototype.T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG = 286;
	PHP.Parser.prototype.T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG = 287;
	PHP.Parser.prototype.T_IS_EQUAL = 288;
	PHP.Parser.prototype.T_IS_NOT_EQUAL = 289;
	PHP.Parser.prototype.T_IS_IDENTICAL = 290;
	PHP.Parser.prototype.T_IS_NOT_IDENTICAL = 291;
	PHP.Parser.prototype.T_SPACESHIP = 292;
	PHP.Parser.prototype.T_IS_SMALLER_OR_EQUAL = 293;
	PHP.Parser.prototype.T_IS_GREATER_OR_EQUAL = 294;
	PHP.Parser.prototype.T_SL = 295;
	PHP.Parser.prototype.T_SR = 296;
	PHP.Parser.prototype.T_INSTANCEOF = 297;
	PHP.Parser.prototype.T_INC = 298;
	PHP.Parser.prototype.T_DEC = 299;
	PHP.Parser.prototype.T_INT_CAST = 300;
	PHP.Parser.prototype.T_DOUBLE_CAST = 301;
	PHP.Parser.prototype.T_STRING_CAST = 302;
	PHP.Parser.prototype.T_ARRAY_CAST = 303;
	PHP.Parser.prototype.T_OBJECT_CAST = 304;
	PHP.Parser.prototype.T_BOOL_CAST = 305;
	PHP.Parser.prototype.T_UNSET_CAST = 306;
	PHP.Parser.prototype.T_POW = 307;
	PHP.Parser.prototype.T_NEW = 308;
	PHP.Parser.prototype.T_CLONE = 309;
	PHP.Parser.prototype.T_EXIT = 310;
	PHP.Parser.prototype.T_IF = 311;
	PHP.Parser.prototype.T_ELSEIF = 312;
	PHP.Parser.prototype.T_ELSE = 313;
	PHP.Parser.prototype.T_ENDIF = 314;
	PHP.Parser.prototype.T_LNUMBER = 315;
	PHP.Parser.prototype.T_DNUMBER = 316;
	PHP.Parser.prototype.T_STRING = 317;
	PHP.Parser.prototype.T_STRING_VARNAME = 318;
	PHP.Parser.prototype.T_VARIABLE = 319;
	PHP.Parser.prototype.T_NUM_STRING = 320;
	PHP.Parser.prototype.T_INLINE_HTML = 321;
	PHP.Parser.prototype.T_ENCAPSED_AND_WHITESPACE = 322;
	PHP.Parser.prototype.T_CONSTANT_ENCAPSED_STRING = 323;
	PHP.Parser.prototype.T_ECHO = 324;
	PHP.Parser.prototype.T_DO = 325;
	PHP.Parser.prototype.T_WHILE = 326;
	PHP.Parser.prototype.T_ENDWHILE = 327;
	PHP.Parser.prototype.T_FOR = 328;
	PHP.Parser.prototype.T_ENDFOR = 329;
	PHP.Parser.prototype.T_FOREACH = 330;
	PHP.Parser.prototype.T_ENDFOREACH = 331;
	PHP.Parser.prototype.T_DECLARE = 332;
	PHP.Parser.prototype.T_ENDDECLARE = 333;
	PHP.Parser.prototype.T_AS = 334;
	PHP.Parser.prototype.T_SWITCH = 335;
	PHP.Parser.prototype.T_MATCH = 336;
	PHP.Parser.prototype.T_ENDSWITCH = 337;
	PHP.Parser.prototype.T_CASE = 338;
	PHP.Parser.prototype.T_DEFAULT = 339;
	PHP.Parser.prototype.T_BREAK = 340;
	PHP.Parser.prototype.T_CONTINUE = 341;
	PHP.Parser.prototype.T_GOTO = 342;
	PHP.Parser.prototype.T_FUNCTION = 343;
	PHP.Parser.prototype.T_FN = 344;
	PHP.Parser.prototype.T_CONST = 345;
	PHP.Parser.prototype.T_RETURN = 346;
	PHP.Parser.prototype.T_TRY = 347;
	PHP.Parser.prototype.T_CATCH = 348;
	PHP.Parser.prototype.T_FINALLY = 349;
	PHP.Parser.prototype.T_USE = 350;
	PHP.Parser.prototype.T_INSTEADOF = 351;
	PHP.Parser.prototype.T_GLOBAL = 352;
	PHP.Parser.prototype.T_STATIC = 353;
	PHP.Parser.prototype.T_ABSTRACT = 354;
	PHP.Parser.prototype.T_FINAL = 355;
	PHP.Parser.prototype.T_PRIVATE = 356;
	PHP.Parser.prototype.T_PROTECTED = 357;
	PHP.Parser.prototype.T_PUBLIC = 358;
	PHP.Parser.prototype.T_READONLY = 359;
	PHP.Parser.prototype.T_VAR = 360;
	PHP.Parser.prototype.T_UNSET = 361;
	PHP.Parser.prototype.T_ISSET = 362;
	PHP.Parser.prototype.T_EMPTY = 363;
	PHP.Parser.prototype.T_HALT_COMPILER = 364;
	PHP.Parser.prototype.T_CLASS = 365;
	PHP.Parser.prototype.T_TRAIT = 366;
	PHP.Parser.prototype.T_INTERFACE = 367;
	PHP.Parser.prototype.T_ENUM = 368;
	PHP.Parser.prototype.T_EXTENDS = 369;
	PHP.Parser.prototype.T_IMPLEMENTS = 370;
	PHP.Parser.prototype.T_OBJECT_OPERATOR = 371;
	PHP.Parser.prototype.T_NULLSAFE_OBJECT_OPERATOR = 372;
	PHP.Parser.prototype.T_LIST = 373;
	PHP.Parser.prototype.T_ARRAY = 374;
	PHP.Parser.prototype.T_CALLABLE = 375;
	PHP.Parser.prototype.T_CLASS_C = 376;
	PHP.Parser.prototype.T_TRAIT_C = 377;
	PHP.Parser.prototype.T_METHOD_C = 378;
	PHP.Parser.prototype.T_FUNC_C = 379;
	PHP.Parser.prototype.T_LINE = 380;
	PHP.Parser.prototype.T_FILE = 381;
	PHP.Parser.prototype.T_START_HEREDOC = 382;
	PHP.Parser.prototype.T_END_HEREDOC = 383;
	PHP.Parser.prototype.T_DOLLAR_OPEN_CURLY_BRACES = 384;
	PHP.Parser.prototype.T_CURLY_OPEN = 385;
	PHP.Parser.prototype.T_PAAMAYIM_NEKUDOTAYIM = 386;
	PHP.Parser.prototype.T_NAMESPACE = 387;
	PHP.Parser.prototype.T_NS_C = 388;
	PHP.Parser.prototype.T_DIR = 389;
	PHP.Parser.prototype.T_NS_SEPARATOR = 390;
	PHP.Parser.prototype.T_ELLIPSIS = 391;
	PHP.Parser.prototype.T_NAME_FULLY_QUALIFIED = 392;
	PHP.Parser.prototype.T_NAME_QUALIFIED = 393;
	PHP.Parser.prototype.T_NAME_RELATIVE = 394;
	PHP.Parser.prototype.T_ATTRIBUTE = 395;
	PHP.Parser.prototype.T_BAD_CHARACTER = 396;
	PHP.Parser.prototype.T_COMMENT = 397;
	PHP.Parser.prototype.T_DOC_COMMENT = 398;
	PHP.Parser.prototype.T_OPEN_TAG = 399;
	PHP.Parser.prototype.T_OPEN_TAG_WITH_ECHO = 400;
	PHP.Parser.prototype.T_CLOSE_TAG = 401;
	PHP.Parser.prototype.T_WHITESPACE = 402;
	PHP.Parser.prototype.terminals = [
		"EOF",
		"error",
		"T_THROW",
		"T_INCLUDE",
		"T_INCLUDE_ONCE",
		"T_EVAL",
		"T_REQUIRE",
		"T_REQUIRE_ONCE",
		"','",
		"T_LOGICAL_OR",
		"T_LOGICAL_XOR",
		"T_LOGICAL_AND",
		"T_PRINT",
		"T_YIELD",
		"T_DOUBLE_ARROW",
		"T_YIELD_FROM",
		"'='",
		"T_PLUS_EQUAL",
		"T_MINUS_EQUAL",
		"T_MUL_EQUAL",
		"T_DIV_EQUAL",
		"T_CONCAT_EQUAL",
		"T_MOD_EQUAL",
		"T_AND_EQUAL",
		"T_OR_EQUAL",
		"T_XOR_EQUAL",
		"T_SL_EQUAL",
		"T_SR_EQUAL",
		"T_POW_EQUAL",
		"T_COALESCE_EQUAL",
		"'?'",
		"':'",
		"T_COALESCE",
		"T_BOOLEAN_OR",
		"T_BOOLEAN_AND",
		"'|'",
		"'^'",
		"T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG",
		"T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG",
		"T_IS_EQUAL",
		"T_IS_NOT_EQUAL",
		"T_IS_IDENTICAL",
		"T_IS_NOT_IDENTICAL",
		"T_SPACESHIP",
		"'<'",
		"T_IS_SMALLER_OR_EQUAL",
		"'>'",
		"T_IS_GREATER_OR_EQUAL",
		"T_SL",
		"T_SR",
		"'+'",
		"'-'",
		"'.'",
		"'*'",
		"'/'",
		"'%'",
		"'!'",
		"T_INSTANCEOF",
		"'~'",
		"T_INC",
		"T_DEC",
		"T_INT_CAST",
		"T_DOUBLE_CAST",
		"T_STRING_CAST",
		"T_ARRAY_CAST",
		"T_OBJECT_CAST",
		"T_BOOL_CAST",
		"T_UNSET_CAST",
		"'@'",
		"T_POW",
		"'['",
		"T_NEW",
		"T_CLONE",
		"T_EXIT",
		"T_IF",
		"T_ELSEIF",
		"T_ELSE",
		"T_ENDIF",
		"T_LNUMBER",
		"T_DNUMBER",
		"T_STRING",
		"T_STRING_VARNAME",
		"T_VARIABLE",
		"T_NUM_STRING",
		"T_INLINE_HTML",
		"T_ENCAPSED_AND_WHITESPACE",
		"T_CONSTANT_ENCAPSED_STRING",
		"T_ECHO",
		"T_DO",
		"T_WHILE",
		"T_ENDWHILE",
		"T_FOR",
		"T_ENDFOR",
		"T_FOREACH",
		"T_ENDFOREACH",
		"T_DECLARE",
		"T_ENDDECLARE",
		"T_AS",
		"T_SWITCH",
		"T_MATCH",
		"T_ENDSWITCH",
		"T_CASE",
		"T_DEFAULT",
		"T_BREAK",
		"T_CONTINUE",
		"T_GOTO",
		"T_FUNCTION",
		"T_FN",
		"T_CONST",
		"T_RETURN",
		"T_TRY",
		"T_CATCH",
		"T_FINALLY",
		"T_USE",
		"T_INSTEADOF",
		"T_GLOBAL",
		"T_STATIC",
		"T_ABSTRACT",
		"T_FINAL",
		"T_PRIVATE",
		"T_PROTECTED",
		"T_PUBLIC",
		"T_READONLY",
		"T_VAR",
		"T_UNSET",
		"T_ISSET",
		"T_EMPTY",
		"T_HALT_COMPILER",
		"T_CLASS",
		"T_TRAIT",
		"T_INTERFACE",
		"T_ENUM",
		"T_EXTENDS",
		"T_IMPLEMENTS",
		"T_OBJECT_OPERATOR",
		"T_NULLSAFE_OBJECT_OPERATOR",
		"T_LIST",
		"T_ARRAY",
		"T_CALLABLE",
		"T_CLASS_C",
		"T_TRAIT_C",
		"T_METHOD_C",
		"T_FUNC_C",
		"T_LINE",
		"T_FILE",
		"T_START_HEREDOC",
		"T_END_HEREDOC",
		"T_DOLLAR_OPEN_CURLY_BRACES",
		"T_CURLY_OPEN",
		"T_PAAMAYIM_NEKUDOTAYIM",
		"T_NAMESPACE",
		"T_NS_C",
		"T_DIR",
		"T_NS_SEPARATOR",
		"T_ELLIPSIS",
		"T_NAME_FULLY_QUALIFIED",
		"T_NAME_QUALIFIED",
		"T_NAME_RELATIVE",
		"T_ATTRIBUTE",
		"';'",
		"']'",
		"'{'",
		"'}'",
		"'('",
		"')'",
		"'`'",
		"'\"'",
		"'$'",
		"T_BAD_CHARACTER",
		"T_COMMENT",
		"T_DOC_COMMENT",
		"T_OPEN_TAG",
		"T_OPEN_TAG_WITH_ECHO",
		"T_CLOSE_TAG",
		"T_WHITESPACE"
		, "???"
	];
	PHP.Parser.prototype.translate = [
		0,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,   56,  166,  175,  167,   55,  175,  175,
		163,  164,   53,   50,    8,   51,   52,   54,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,   31,  159,
		44,   16,   46,   30,   68,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,   70,  175,  160,   36,  175,  165,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  161,   35,  162,   58,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,  175,  175,  175,  175,
		175,  175,  175,  175,  175,  175,    1,    2,    3,    4,
		5,    6,    7,    9,   10,   11,   12,   13,   14,   15,
		17,   18,   19,   20,   21,   22,   23,   24,   25,   26,
		27,   28,   29,   32,   33,   34,   37,   38,   39,   40,
		41,   42,   43,   45,   47,   48,   49,   57,   59,   60,
		61,   62,   63,   64,   65,   66,   67,   69,   71,   72,
		73,   74,   75,   76,   77,   78,   79,   80,   81,   82,
		83,   84,   85,   86,   87,   88,   89,   90,   91,   92,
		93,   94,   95,   96,   97,   98,   99,  100,  101,  102,
		103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
		113,  114,  115,  116,  117,  118,  119,  120,  121,  122,
		123,  124,  125,  126,  127,  128,  129,  130,  131,  132,
		133,  134,  135,  136,  137,  138,  139,  140,  141,  142,
		143,  144,  145,  146,  147,  148,  149,  150,  151,  152,
		153,  154,  155,  156,  157,  158,  168,  169,  170,  171,
		172,  173,  174
	];

PHP.Parser.prototype.yyaction = [
		132,  133,  134,  569,  135,  136,    0,  722,  723,  724,
		137,   37,  834,  911,  835,  469,-32766,-32766,-32766,-32767,
		-32767,-32767,-32767,  101,  102,  103,  104,  105, 1068, 1069,
		1070, 1067, 1066, 1065, 1071,  716,  715,-32766,-32766,-32766,
		-32766,-32766,-32766,-32766,-32766,-32766,-32767,-32767,-32767,-32767,
		-32767,  545,  546,-32766,-32766,  725,-32766,-32766,-32766,  998,
		999,  806,  922,  447,  448,  449,  370,  371,    2,  267,
		138,  396,  729,  730,  731,  732,  414,-32766,  420,-32766,
		-32766,-32766,-32766,-32766,  990,  733,  734,  735,  736,  737,
		738,  739,  740,  741,  742,  743,  763,  570,  764,  765,
		766,  767,  755,  756,  336,  337,  758,  759,  744,  745,
		746,  748,  749,  750,  346,  790,  791,  792,  793,  794,
		795,  751,  752,  571,  572,  784,  775,  773,  774,  787,
		770,  771,  283,  420,  573,  574,  769,  575,  576,  577,
		578,  579,  580,  598, -575,  470,   14,  798,  772,  581,
		582, -575,  139,-32766,-32766,-32766,  132,  133,  134,  569,
		135,  136, 1017,  722,  723,  724,  137,   37, 1060,-32766,
		-32766,-32766, 1303,  696,-32766, 1304,-32766,-32766,-32766,-32766,
		-32766,-32766,-32766, 1068, 1069, 1070, 1067, 1066, 1065, 1071,
		-32766,  716,  715,  372,  371, 1258,-32766,-32766,-32766, -572,
		106,  107,  108,  414,  270,  891, -572,  240, 1193, 1192,
		1194,  725,-32766,-32766,-32766, 1046,  109,-32766,-32766,-32766,
		-32766,  986,  985,  984,  987,  267,  138,  396,  729,  730,
		731,  732,   12,-32766,  420,-32766,-32766,-32766,-32766,  998,
		999,  733,  734,  735,  736,  737,  738,  739,  740,  741,
		742,  743,  763,  570,  764,  765,  766,  767,  755,  756,
		336,  337,  758,  759,  744,  745,  746,  748,  749,  750,
		346,  790,  791,  792,  793,  794,  795,  751,  752,  571,
		572,  784,  775,  773,  774,  787,  770,  771,  881,  321,
		573,  574,  769,  575,  576,  577,  578,  579,  580,-32766,
		82,   83,   84, -575,  772,  581,  582, -575,  148,  747,
		717,  718,  719,  720,  721, 1278,  722,  723,  724,  760,
		761,   36, 1277,   85,   86,   87,   88,   89,   90,   91,
		92,   93,   94,   95,   96,   97,   98,   99,  100,  101,
		102,  103,  104,  105,  106,  107,  108,  996,  270,  150,
		-32766,-32766,-32766,  455,  456,   81,   34, -264, -572, 1016,
		109,  320, -572,  893,  725,  682,  803,  128,  998,  999,
		592,-32766, 1044,-32766,-32766,-32766,  809,  151,  726,  727,
		728,  729,  730,  731,  732,  -88, 1198,  796,  278, -526,
		283,-32766,-32766,-32766,  733,  734,  735,  736,  737,  738,
		739,  740,  741,  742,  743,  763,  786,  764,  765,  766,
		767,  755,  756,  757,  785,  758,  759,  744,  745,  746,
		748,  749,  750,  789,  790,  791,  792,  793,  794,  795,
		751,  752,  753,  754,  784,  775,  773,  774,  787,  770,
		771,  144,  804,  762,  768,  769,  776,  777,  779,  778,
		780,  781, -314, -526, -526, -193, -192,  772,  783,  782,
		49,   50,   51,  500,   52,   53,  239,  807, -526,  -86,
		54,   55, -111,   56,  996,  253,-32766, -111,  800, -111,
		-526,  541, -532, -352,  300, -352,  304, -111, -111, -111,
		-111, -111, -111, -111, -111,  998,  999,  998,  999,  153,
		-32766,-32766,-32766, 1191,  807,  126,  306, 1293,   57,   58,
		103,  104,  105, -111,   59, 1218,   60,  246,  247,   61,
		62,   63,   64,   65,   66,   67,   68, -525,   27,  268,
		69,  436,  501, -328,  808,  -86, 1224, 1225,  502, 1189,
		807, 1198, 1230,  293, 1222,   41,   24,  503,   74,  504,
		953,  505,  320,  506,  802,  154,  507,  508,  279,  684,
		280,   43,   44,  437,  367,  366,  891,   45,  509,   35,
		249,  -16, -566,  358,  332,  318, -566, 1198, 1193, 1192,
		1194, -527,  510,  511,  512,  333, -524, 1274,   48,  716,
		715, -525, -525,  334,  513,  514,  807, 1212, 1213, 1214,
		1215, 1209, 1210,  292,  360,  284, -525,  285, -314, 1216,
		1211, -193, -192, 1193, 1192, 1194,  293,  891, -525,  364,
		-531,   70,  807,  316,  317,  320,   31,  110,  111,  112,
		113,  114,  115,  116,  117,  118,  119,  120,  121,  122,
		-153, -153, -153,  638,   25, -527, -527,  687,  379,  881,
		-524, -524,  296,  297,  891, -153,  432, -153,  807, -153,
		-527, -153,  716,  715,  433, -524,  798,  363, -111, 1105,
		1107,  365, -527,  434,  891,  140,  435, -524,  954,  127,
		-524,  320, -111, -111,  688,  813,  381, -529,   11,  834,
		155,  835,  867, -111, -111, -111, -111,   47,  293,-32766,
		881,  654,  655,   74,  689, 1191, 1045,  320,  708,  149,
		399,  157,-32766,-32766,-32766,   32,-32766,  -79,-32766,  123,
		-32766,  716,  715,-32766,  893,  891,  682, -153,-32766,-32766,
		-32766,  716,  715,  891,-32766,-32766,  124,  881,  129,   74,
		-32766,  411,  130,  320, -524, -524,  143,  141,  -75,-32766,
		158, -529, -529,  320,   27,  691,  159,  881,  160, -524,
		161,  294,  295,  698,  368,  369,  807,  -73,-32766,  -72,
		1222, -524,  373,  374, 1191,  893,  -71,  682, -529,   73,
		-70,-32766,-32766,-32766,  -69,-32766,  -68,-32766,  125,-32766,
		630,  631,-32766,  -67,  -66,  -47,  -51,-32766,-32766,-32766,
		-18,  147,  271,-32766,-32766,  277,  697,  700,  881,-32766,
		411,  890,  893,  146,  682,  282,  881,  907,-32766,  281,
		513,  514,  286, 1212, 1213, 1214, 1215, 1209, 1210,  326,
		131,  145,  939,  287,  682, 1216, 1211,  109,  270,-32766,
		798,  807,-32766,  662,  639, 1191,  657,   72,  675, 1075,
		317,  320,-32766,-32766,-32766, 1305,-32766,  301,-32766,  628,
		-32766,  431,  543,-32766,-32766,  923,  555,  924,-32766,-32766,
		-32766, 1229,  549,-32766,-32766,-32766,   -4,  891, -490, 1191,
		-32766,  411,  644,  893,  299,  682,-32766,-32766,-32766,-32766,
		-32766,  893,-32766,  682,-32766,   13, 1231,-32766,  452,  480,
		645,  909,-32766,-32766,-32766,-32766,  658, -480,-32766,-32766,
		0, 1191,    0,    0,-32766,  411,    0,  298,-32766,-32766,
		-32766,  305,-32766,-32766,-32766,    0,-32766,    0,  806,-32766,
		0,    0,    0,  475,-32766,-32766,-32766,-32766,    0,    7,
		-32766,-32766,   16, 1191,  561,  596,-32766,  411, 1219,  891,
		-32766,-32766,-32766,  362,-32766,-32766,-32766,  818,-32766, -267,
		881,-32766,   39,  293,    0,    0,-32766,-32766,-32766,   40,
		705,  706,-32766,-32766,  872,  963,  940,  947,-32766,  411,
		937,  948,  365,  870,  427,  891,  935,-32766, 1049,  291,
		1244, 1052, 1053, -111, -111, 1050, 1051, 1057, -560, 1262,
		1296,  633,    0,  826, -111, -111, -111, -111,   33,  315,
		-32766,  361,  683,  686,  690,  692, 1191,  693,  694,  695,
		699,  685,  320,-32766,-32766,-32766,    9,-32766,  702,-32766,
		868,-32766,  881, 1300,-32766,  893, 1302,  682,   -4,-32766,
		-32766,-32766,  829,  828,  837,-32766,-32766,  916, -242, -242,
		-242,-32766,  411,  955,  365,   27,  836, 1301,  915,  917,
		-32766,  914, 1177,  900,  910, -111, -111,  807,  881,  898,
		945, 1222,  946, 1299, 1256,  867, -111, -111, -111, -111,
		1245, 1263, 1269, 1272, -241, -241, -241, -558, -532, -531,
		365, -530,    1,   28,   29,   38,   42,   46,   71,    0,
		75, -111, -111,   76,   77,   78,   79,  893,   80,  682,
		-242,  867, -111, -111, -111, -111,  142,  152,  156,  245,
		322,  347,  514,  348, 1212, 1213, 1214, 1215, 1209, 1210,
		349,  350,  351,  352,  353,  354, 1216, 1211,  355,  356,
		357,  359,  428,  893, -265,  682, -241, -264,   72,    0,
		18,  317,  320,   19,   20,   21,   23,  398,  471,  472,
		479,  482,  483,  484,  485,  489,  490,  491,  498,  669,
		1202, 1145, 1220, 1019, 1018, 1181, -269, -103,   17,   22,
		26,  290,  397,  589,  593,  620,  674, 1149, 1197, 1146,
		1275,    0, -494, 1162,    0, 1223
	];

PHP.Parser.prototype.yycheck = [
		2,    3,    4,    5,    6,    7,    0,    9,   10,   11,
		12,   13,  106,    1,  108,   31,    9,   10,   11,   44,
		45,   46,   47,   48,   49,   50,   51,   52,  116,  117,
		118,  119,  120,  121,  122,   37,   38,   30,  116,   32,
		33,   34,   35,   36,   37,   38,   39,   40,   41,   42,
		43,  117,  118,    9,   10,   57,    9,   10,   11,  137,
		138,  155,  128,  129,  130,  131,  106,  107,    8,   71,
		72,   73,   74,   75,   76,   77,  116,   30,   80,   32,
		33,   34,   35,   36,    1,   87,   88,   89,   90,   91,
		92,   93,   94,   95,   96,   97,   98,   99,  100,  101,
		102,  103,  104,  105,  106,  107,  108,  109,  110,  111,
		112,  113,  114,  115,  116,  117,  118,  119,  120,  121,
		122,  123,  124,  125,  126,  127,  128,  129,  130,  131,
		132,  133,   30,   80,  136,  137,  138,  139,  140,  141,
		142,  143,  144,   51,    1,  161,  101,   80,  150,  151,
		152,    8,  154,    9,   10,   11,    2,    3,    4,    5,
		6,    7,  164,    9,   10,   11,   12,   13,  123,    9,
		10,   11,   80,  161,   30,   83,   32,   33,   34,   35,
		36,   37,   38,  116,  117,  118,  119,  120,  121,  122,
		30,   37,   38,  106,  107,    1,    9,   10,   11,    1,
		53,   54,   55,  116,   57,    1,    8,   14,  155,  156,
		157,   57,    9,   10,   11,  162,   69,   30,  116,   32,
		33,  119,  120,  121,  122,   71,   72,   73,   74,   75,
		76,   77,    8,   30,   80,   32,   33,   34,   35,  137,
		138,   87,   88,   89,   90,   91,   92,   93,   94,   95,
		96,   97,   98,   99,  100,  101,  102,  103,  104,  105,
		106,  107,  108,  109,  110,  111,  112,  113,  114,  115,
		116,  117,  118,  119,  120,  121,  122,  123,  124,  125,
		126,  127,  128,  129,  130,  131,  132,  133,   84,   70,
		136,  137,  138,  139,  140,  141,  142,  143,  144,    9,
		9,   10,   11,  160,  150,  151,  152,  164,  154,    2,
		3,    4,    5,    6,    7,    1,    9,   10,   11,   12,
		13,   30,    8,   32,   33,   34,   35,   36,   37,   38,
		39,   40,   41,   42,   43,   44,   45,   46,   47,   48,
		49,   50,   51,   52,   53,   54,   55,  116,   57,   14,
		9,   10,   11,  134,  135,  161,    8,  164,  160,    1,
		69,  167,  164,  159,   57,  161,   80,    8,  137,  138,
		1,   30,    1,   32,   33,   34,    1,   14,   71,   72,
		73,   74,   75,   76,   77,   31,    1,   80,   30,   70,
		30,    9,   10,   11,   87,   88,   89,   90,   91,   92,
		93,   94,   95,   96,   97,   98,   99,  100,  101,  102,
		103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
		113,  114,  115,  116,  117,  118,  119,  120,  121,  122,
		123,  124,  125,  126,  127,  128,  129,  130,  131,  132,
		133,    8,  156,  136,  137,  138,  139,  140,  141,  142,
		143,  144,    8,  134,  135,    8,    8,  150,  151,  152,
		2,    3,    4,    5,    6,    7,   97,   82,  149,   31,
		12,   13,  101,   15,  116,    8,  116,  106,   80,  108,
		161,   85,  163,  106,  113,  108,    8,  116,  117,  118,
		119,  120,  121,  122,  123,  137,  138,  137,  138,   14,
		9,   10,   11,   80,   82,   14,    8,   85,   50,   51,
		50,   51,   52,  128,   56,    1,   58,   59,   60,   61,
		62,   63,   64,   65,   66,   67,   68,   70,   70,   71,
		72,   73,   74,  162,  159,   97,   78,   79,   80,  116,
		82,    1,  146,  158,   86,   87,   88,   89,  163,   91,
		31,   93,  167,   95,  156,   14,   98,   99,   35,  161,
		37,  103,  104,  105,  106,  107,    1,  109,  110,  147,
		148,   31,  160,  115,  116,    8,  164,    1,  155,  156,
		157,   70,  124,  125,  126,    8,   70,    1,   70,   37,
		38,  134,  135,    8,  136,  137,   82,  139,  140,  141,
		142,  143,  144,  145,    8,   35,  149,   37,  164,  151,
		152,  164,  164,  155,  156,  157,  158,    1,  161,    8,
		163,  163,   82,  165,  166,  167,   16,   17,   18,   19,
		20,   21,   22,   23,   24,   25,   26,   27,   28,   29,
		75,   76,   77,   75,   76,  134,  135,   31,    8,   84,
		134,  135,  134,  135,    1,   90,    8,   92,   82,   94,
		149,   96,   37,   38,    8,  149,   80,  149,  128,   59,
		60,  106,  161,    8,    1,  161,    8,  161,  159,  161,
		70,  167,  117,  118,   31,    8,  106,   70,  108,  106,
		14,  108,  127,  128,  129,  130,  131,   70,  158,   74,
		84,   75,   76,  163,   31,   80,  159,  167,  161,  101,
		102,   14,   87,   88,   89,   14,   91,   31,   93,   16,
		95,   37,   38,   98,  159,    1,  161,  162,  103,  104,
		105,   37,   38,    1,  109,  110,   16,   84,   16,  163,
		115,  116,   16,  167,  134,  135,   16,  161,   31,  124,
		16,  134,  135,  167,   70,   31,   16,   84,   16,  149,
		16,  134,  135,   31,  106,  107,   82,   31,   74,   31,
		86,  161,  106,  107,   80,  159,   31,  161,  161,  154,
		31,   87,   88,   89,   31,   91,   31,   93,  161,   95,
		111,  112,   98,   31,   31,   31,   31,  103,  104,  105,
		31,   31,   31,  109,  110,   31,   31,   31,   84,  115,
		116,   31,  159,   31,  161,   37,   84,   38,  124,   35,
		136,  137,   35,  139,  140,  141,  142,  143,  144,   35,
		31,   70,  159,   37,  161,  151,  152,   69,   57,   74,
		80,   82,   85,   77,   90,   80,   94,  163,   92,   82,
		166,  167,   87,   88,   89,   83,   91,  114,   93,  113,
		95,  128,   85,   98,  116,  128,  153,  128,  103,  104,
		105,  146,   89,   74,  109,  110,    0,    1,  149,   80,
		115,  116,   96,  159,  133,  161,   87,   88,   89,  124,
		91,  159,   93,  161,   95,   97,  146,   98,   97,   97,
		100,  154,  103,  104,  105,   74,  100,  149,  109,  110,
		-1,   80,   -1,   -1,  115,  116,   -1,  132,   87,   88,
		89,  132,   91,  124,   93,   -1,   95,   -1,  155,   98,
		-1,   -1,   -1,  102,  103,  104,  105,   74,   -1,  149,
		109,  110,  149,   80,   81,  153,  115,  116,  160,    1,
		87,   88,   89,  149,   91,  124,   93,  160,   95,  164,
		84,   98,  159,  158,   -1,   -1,  103,  104,  105,  159,
		159,  159,  109,  110,  159,  159,  159,  159,  115,  116,
		159,  159,  106,  159,  108,    1,  159,  124,  159,  113,
		160,  159,  159,  117,  118,  159,  159,  159,  163,  160,
		160,  160,   -1,  127,  128,  129,  130,  131,  161,  161,
		74,  161,  161,  161,  161,  161,   80,  161,  161,  161,
		161,  161,  167,   87,   88,   89,  150,   91,  162,   93,
		162,   95,   84,  162,   98,  159,  162,  161,  162,  103,
		104,  105,  162,  162,  162,  109,  110,  162,  100,  101,
		102,  115,  116,  162,  106,   70,  162,  162,  162,  162,
		124,  162,  162,  162,  162,  117,  118,   82,   84,  162,
		162,   86,  162,  162,  162,  127,  128,  129,  130,  131,
		162,  162,  162,  162,  100,  101,  102,  163,  163,  163,
		106,  163,  163,  163,  163,  163,  163,  163,  163,   -1,
		163,  117,  118,  163,  163,  163,  163,  159,  163,  161,
		162,  127,  128,  129,  130,  131,  163,  163,  163,  163,
		163,  163,  137,  163,  139,  140,  141,  142,  143,  144,
		163,  163,  163,  163,  163,  163,  151,  152,  163,  163,
		163,  163,  163,  159,  164,  161,  162,  164,  163,   -1,
		164,  166,  167,  164,  164,  164,  164,  164,  164,  164,
		164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
		164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
		164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
		164,   -1,  165,  165,   -1,  166
	];

PHP.Parser.prototype.yybase = [
		0,   -2,  154,  565,  876,  948,  984,  514,   53,  398,
		837,  307,  307,   67,  307,  307,  307,  653,  724,  724,
		732,  724,  616,  673,  204,  204,  204,  625,  625,  625,
		625,  694,  694,  831,  831,  863,  799,  765,  936,  936,
		936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
		936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
		936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
		936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
		936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
		936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
		936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
		936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
		936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
		936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
		936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
		936,  936,  936,  936,  936,  936,  936,  936,  936,  936,
		936,  936,  375,  519,  369,  701, 1017, 1023, 1019, 1024,
		1015, 1014, 1018, 1020, 1025,  911,  912,  782,  918,  919,
		920,  921, 1021,  841, 1016, 1022,  291,  291,  291,  291,
		291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
		291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
		291,  291,  290,  491,   44,  382,  382,  382,  382,  382,
		382,  382,  382,  382,  382,  382,  382,  382,  382,  382,
		382,  382,  382,  382,  382,  160,  160,  160,  187,  684,
		684,  341,  203,  610,   47,  985,  985,  985,  985,  985,
		985,  985,  985,  985,  985,  144,  144,    7,    7,    7,
		7,    7,  371,  -25,  -25,  -25,  -25,  540,  385,  102,
		576,  358,   45,  377,  460,  460,  360,  231,  231,  231,
		231,  231,  231,  -78,  -78,  -78,  -78,  -78,  -66,  319,
		457,  -94,  396,  423,  586,  586,  586,  586,  423,  423,
		423,  423,  750, 1029,  423,  423,  423,  511,  516,  516,
		518,  147,  147,  147,  516,  583,  777,  422,  583,  422,
		194,   92,  748,  -40,   87,  412,  748,  617,  627,  198,
		143,  773,  658,  773, 1013,  757,  764,  717,  838,  860,
		1026,  800,  908,  806,  910,  219,  686, 1012, 1012, 1012,
		1012, 1012, 1012, 1012, 1012, 1012, 1012, 1012,  855,  552,
		1013,  286,  855,  855,  855,  552,  552,  552,  552,  552,
		552,  552,  552,  552,  552,  679,  286,  568,  626,  286,
		794,  552,  375,  758,  375,  375,  375,  375,  958,  375,
		375,  375,  375,  375,  375,  970,  769,  -16,  375,  519,
		12,   12,  547,   83,   12,   12,   12,   12,  375,  375,
		375,  658,  781,  713,  666,  792,  448,  781,  781,  781,
		438,  444,  193,  447,  570,  523,  580,  760,  760,  767,
		929,  929,  760,  759,  760,  767,  934,  760,  929,  805,
		359,  648,  577,  611,  656,  929,  478,  760,  760,  760,
		760,  665,  760,  467,  433,  760,  760,  785,  774,  789,
		60,  929,  929,  929,  789,  596,  751,  751,  751,  811,
		812,  746,  771,  567,  498,  677,  348,  779,  771,  771,
		760,  640,  746,  771,  746,  771,  747,  771,  771,  771,
		746,  771,  759,  585,  771,  734,  668,  224,  771,    6,
		935,  937,  354,  940,  932,  941,  979,  942,  943,  851,
		956,  933,  945,  931,  930,  780,  703,  720,  790,  729,
		928,  768,  768,  768,  925,  768,  768,  768,  768,  768,
		768,  768,  768,  703,  788,  804,  733,  783,  960,  722,
		726,  725,  868, 1027, 1028,  737,  739,  958, 1006,  953,
		803,  730,  992,  967,  866,  848,  968,  969,  993, 1007,
		1008,  871,  761,  874,  880,  797,  971,  852,  768,  935,
		943,  933,  945,  931,  930,  763,  762,  753,  755,  749,
		745,  736,  738,  770, 1009,  924,  835,  830,  970,  926,
		703,  839,  986,  847,  994,  995,  850,  801,  772,  840,
		881,  972,  975,  976,  853, 1010,  810,  989,  795,  996,
		802,  882,  997,  998,  999, 1000,  885,  854,  856,  857,
		815,  754,  980,  786,  891,  335,  787,  796,  978,  363,
		957,  858,  894,  895, 1001, 1002, 1003,  896,  954,  816,
		990,  752,  991,  983,  817,  818,  485,  784,  778,  541,
		676,  897,  899,  900,  955,  775,  766,  821,  822, 1011,
		901,  697,  824,  740,  902, 1005,  742,  744,  756,  859,
		793,  743,  798,  977,  776,  827,  907,  829,  832,  833,
		1004,  836,    0,    0,    0,    0,    0,    0,    0,    0,
		0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
		0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
		0,  458,  458,  458,  458,  458,  458,  307,  307,  307,
		307,    0,    0,  307,    0,    0,    0,  458,  458,  458,
		458,  458,  458,  458,  458,  458,  458,  458,  458,  458,
		458,  458,  458,  458,  458,  458,  458,  458,  458,  458,
		458,  458,  458,  458,  458,  458,  458,  458,  458,  458,
		458,  458,  458,  458,  458,  458,  458,  458,  458,  458,
		458,  458,  458,  458,  458,  458,  458,  458,  458,  458,
		458,  458,  458,  458,  458,  458,  458,  458,  458,  458,
		458,  458,  458,  458,  458,  458,  458,  458,  458,  458,
		458,  458,  458,  458,  458,  458,  458,  458,  458,  458,
		458,  458,  458,  458,  458,  458,  458,  458,  458,  458,
		458,  458,  458,  458,  458,  458,  458,  458,  458,  458,
		458,  458,  458,  458,  458,  458,  458,  458,  458,  458,
		458,  458,  458,  458,  458,  458,  458,  458,  458,  458,
		458,  458,  458,  458,  458,  458,  458,  458,  458,  458,
		458,  458,  458,  458,  458,  458,  458,  458,  458,  458,
		458,  458,  291,  291,  291,  291,  291,  291,  291,  291,
		291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
		291,  291,  291,  291,  291,  291,    0,    0,    0,    0,
		0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
		0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
		0,    0,  291,  291,  291,  291,  291,  291,  291,  291,
		291,  291,  291,  291,  291,  291,  291,  291,  291,  291,
		291,  291,  291,  291,  291,  291,  291,  291,  291,  423,
		423,  291,  291,    0,  291,  423,  423,  423,  423,  423,
		423,  423,  423,  423,  423,  291,  291,  291,  291,  291,
		291,  291,  805,  147,  147,  147,  147,  423,  423,  423,
		423,  423,  -88,  -88,  147,  147,  423,  423,  423,  423,
		423,  423,  423,  423,  423,  423,  423,  423,    0,    0,
		0,  286,  422,    0,  759,  759,  759,  759,    0,    0,
		0,    0,  422,  422,    0,    0,    0,    0,    0,    0,
		0,    0,    0,    0,    0,  286,  422,    0,  286,    0,
		759,  759,  423,  805,  805,  314,  423,    0,    0,    0,
		0,  286,  759,  286,  552,  422,  552,  552,   12,  375,
		314,  608,  608,  608,  608,    0,  658,  805,  805,  805,
		805,  805,  805,  805,  805,  805,  805,  805,  759,    0,
		805,    0,  759,  759,  759,    0,    0,    0,    0,    0,
		0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
		759,    0,    0,  929,    0,    0,    0,    0,  760,    0,
		0,    0,    0,    0,    0,  760,  934,    0,    0,    0,
		0,    0,    0,  759,    0,    0,    0,    0,    0,    0,
		0,    0,  768,  801,    0,  801,    0,  768,  768,  768
	];

PHP.Parser.prototype.yydefault = [
		3,32767,  103,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,  101,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,  578,  578,  578,
		578,32767,32767,  246,  103,32767,32767,  454,  372,  372,
		372,32767,32767,  522,  522,  522,  522,  522,  522,32767,
		32767,32767,32767,32767,32767,  454,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,  101,32767,
		32767,32767,   37,    7,    8,   10,   11,   50,   17,  310,
		32767,32767,32767,32767,  103,32767,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,  571,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,  458,  437,  438,  440,
		441,  371,  523,  577,  313,  574,  370,  146,  325,  315,
		234,  316,  250,  459,  251,  460,  463,  464,  211,  279,
		367,  150,  401,  455,  403,  453,  457,  402,  377,  382,
		383,  384,  385,  386,  387,  388,  389,  390,  391,  392,
		393,  394,  375,  376,  456,  434,  433,  432,  399,32767,
		32767,  400,  404,  374,  407,32767,32767,32767,32767,32767,
		32767,32767,32767,  103,32767,  405,  406,  423,  424,  421,
		422,  425,32767,  426,  427,  428,  429,32767,32767,  302,
		32767,32767,  351,  349,  414,  415,  302,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,32767,  516,
		431,32767,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,32767,  103,32767,  101,  518,  396,  398,
		486,  409,  410,  408,  378,32767,  493,32767,  103,  495,
		32767,32767,32767,  112,32767,32767,32767,  517,32767,  524,
		524,32767,  479,  101,  194,32767,  194,  194,32767,32767,
		32767,32767,32767,32767,32767,  585,  479,  111,  111,  111,
		111,  111,  111,  111,  111,  111,  111,  111,32767,  194,
		111,32767,32767,32767,  101,  194,  194,  194,  194,  194,
		194,  194,  194,  194,  194,  189,32767,  260,  262,  103,
		539,  194,32767,  498,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,  491,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,  479,  419,  139,32767,  139,  524,  411,  412,  413,
		481,  524,  524,  524,  298,  281,32767,32767,32767,32767,
		496,  496,  101,  101,  101,  101,  491,32767,32767,  112,
		100,  100,  100,  100,  100,  104,  102,32767,32767,32767,
		32767,  100,32767,  102,  102,32767,32767,  217,  208,  215,
		102,32767,  543,  544,  215,  102,  219,  219,  219,  239,
		239,  470,  304,  102,  100,  102,  102,  196,  304,  304,
		32767,  102,  470,  304,  470,  304,  198,  304,  304,  304,
		470,  304,32767,  102,  304,  210,  100,  100,  304,32767,
		32767,32767,  481,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,  511,32767,  528,
		541,  417,  418,  420,  526,  442,  443,  444,  445,  446,
		447,  448,  450,  573,32767,  485,32767,32767,32767,32767,
		324,  583,32767,  583,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,  584,32767,  524,32767,32767,32767,32767,  416,    9,
		76,   43,   44,   52,   58,  502,  503,  504,  505,  499,
		500,  506,  501,32767,32767,  507,  549,32767,32767,  525,
		576,32767,32767,32767,32767,32767,32767,  139,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,  511,32767,
		137,32767,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,  524,32767,32767,32767,  300,  301,32767,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,  524,32767,32767,32767,  283,  284,32767,
		32767,32767,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,32767,  278,32767,32767,  366,32767,32767,32767,
		32767,  345,32767,32767,32767,32767,32767,32767,32767,32767,
		32767,32767,  152,  152,    3,    3,  327,  152,  152,  152,
		327,  152,  327,  327,  327,  152,  152,  152,  152,  152,
		152,  272,  184,  254,  257,  239,  239,  152,  337,  152
	];

PHP.Parser.prototype.yygoto = [
		194,  194,  670,  422,  643,  463, 1264, 1265, 1022,  416,
		308,  309,  329,  563,  314,  421,  330,  423,  622,  801,
		678,  637,  586,  651,  652,  653,  165,  165,  165,  165,
		218,  195,  191,  191,  175,  177,  213,  191,  191,  191,
		191,  191,  192,  192,  192,  192,  192,  192,  186,  187,
		188,  189,  190,  215,  213,  216,  521,  522,  412,  523,
		525,  526,  527,  528,  529,  530,  531,  532, 1091,  166,
		167,  168,  193,  169,  170,  171,  164,  172,  173,  174,
		176,  212,  214,  217,  235,  238,  241,  242,  244,  255,
		256,  257,  258,  259,  260,  261,  263,  264,  265,  266,
		274,  275,  311,  312,  313,  417,  418,  419,  568,  219,
		220,  221,  222,  223,  224,  225,  226,  227,  228,  229,
		230,  231,  232,  233,  178,  234,  179,  196,  197,  198,
		236,  186,  187,  188,  189,  190,  215, 1091,  199,  180,
		181,  182,  200,  196,  183,  237,  201,  199,  163,  202,
		203,  184,  204,  205,  206,  185,  207,  208,  209,  210,
		211,  323,  323,  323,  323,  827,  608,  608,  824,  547,
		538,  342, 1221, 1221, 1221, 1221, 1221, 1221, 1221, 1221,
		1221, 1221, 1239, 1239,  288,  288,  288,  288, 1239, 1239,
		1239, 1239, 1239, 1239, 1239, 1239, 1239, 1239,  388,  538,
		547,  556,  557,  395,  566,  588,  602,  603,  832,  825,
		880,  875,  876,  889,   15,  833,  877,  830,  878,  879,
		831,  799,  251,  251,  883,  919,  992, 1000, 1004, 1001,
		1005, 1237, 1237,  938, 1043, 1039, 1040, 1237, 1237, 1237,
		1237, 1237, 1237, 1237, 1237, 1237, 1237,  858,  248,  248,
		248,  248,  250,  252,  533,  533,  533,  533,  487,  590,
		488, 1190, 1190,  997, 1190,  997,  494, 1290, 1290,  560,
		997,  997,  997,  997,  997,  997,  997,  997,  997,  997,
		997,  997, 1261, 1261, 1290, 1261,  340, 1190,  930,  402,
		677, 1279, 1190, 1190, 1190, 1190,  959,  345, 1190, 1190,
		1190, 1271, 1271, 1271, 1271,  606,  640,  345,  345, 1273,
		1273, 1273, 1273,  820,  820,  805,  896,  884,  840,  885,
		897,  345,  345,    5,  345,    6, 1306,  384,  535,  535,
		559,  535,  415,  852,  597, 1257,  839,  540,  524,  524,
		345, 1289, 1289,  642,  524,  524,  524,  524,  524,  524,
		524,  524,  524,  524,  445,  805, 1140,  805, 1289,  932,
		932,  932,  932, 1063, 1064,  445,  926,  933,  386,  390,
		548,  587,  591, 1030, 1292,  331,  554, 1259, 1259, 1030,
		704,  621,  623,  823,  641, 1250,  319,  303,  660,  664,
		973,  668,  676,  969,  429,  553,  962,  936,  936,  934,
		936,  703,  601,  537,  971,  966,  343,  344,  663,  817,
		595,  609,  612,  613,  614,  615,  634,  635,  636,  680,
		439, 1186,  845,  454,  454,  439,  439, 1266, 1267,  820,
		901, 1079,  454,  394,  539,  551, 1183,  605,  540,  539,
		842,  551,  978,  272,  387,  618,  619,  981,  536,  536,
		844,  707,  646,  957,  567,  457,  458,  459,  838,  850,
		254,  254, 1297, 1298,  400,  401,  976,  976,  464,  649,
		1182,  650, 1028,  404,  405,  406, 1187,  661,  424, 1032,
		407,  564,  600,  815,  338,  424,  854,  848,  853,  841,
		1027, 1031, 1009, 1002, 1006, 1003, 1007, 1185,  941, 1188,
		1247, 1248,  943,    0, 1074,  439,  439,  439,  439,  439,
		439,  439,  439,  439,  439,  439,    0,  468,  439,  585,
		1056,  931,  681,  667,  667,    0,  495,  673, 1054, 1171,
		912,    0,    0, 1172, 1175,  913, 1176,    0,    0,    0,
		0,    0,    0, 1072,  857
	];

PHP.Parser.prototype.yygcheck = [
		42,   42,   72,   65,   65,  166,  166,  166,  119,   65,
		65,   65,   65,   65,   65,   65,   65,   65,   65,    7,
		9,   84,  122,   84,   84,   84,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   23,   23,   23,   23,   15,  104,  104,   26,   75,
		75,   93,  104,  104,  104,  104,  104,  104,  104,  104,
		104,  104,  160,  160,   24,   24,   24,   24,  160,  160,
		160,  160,  160,  160,  160,  160,  160,  160,   75,   75,
		75,   75,   75,   75,   75,   75,   75,   75,   15,   27,
		15,   15,   15,   15,   75,   15,   15,   15,   15,   15,
		15,    6,    5,    5,   15,   87,   87,   87,   87,   87,
		87,  161,  161,   49,   15,   15,   15,  161,  161,  161,
		161,  161,  161,  161,  161,  161,  161,   45,    5,    5,
		5,    5,    5,    5,  103,  103,  103,  103,  147,  103,
		147,   72,   72,   72,   72,   72,  147,  173,  173,  162,
		72,   72,   72,   72,   72,   72,   72,   72,   72,   72,
		72,   72,  122,  122,  173,  122,  169,   72,   89,   89,
		89,  171,   72,   72,   72,   72,   99,   14,   72,   72,
		72,    9,    9,    9,    9,   55,   55,   14,   14,  122,
		122,  122,  122,   22,   22,   12,   72,   64,   35,   64,
		72,   14,   14,   46,   14,   46,   14,   61,   19,   19,
		100,   19,   13,   35,   13,  122,   35,   14,  163,  163,
		14,  172,  172,   63,  163,  163,  163,  163,  163,  163,
		163,  163,  163,  163,   19,   12,  143,   12,  172,   19,
		19,   19,   19,  136,  136,   19,   19,   19,   58,   58,
		58,   58,   58,  122,  172,   29,   48,  122,  122,  122,
		48,   48,   48,   25,   48,   14,  159,  159,   48,   48,
		48,   48,   48,   48,  109,    9,   25,   25,   25,   25,
		25,   25,    9,   25,   25,   25,   93,   93,   14,   18,
		79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
		23,   20,   39,  141,  141,   23,   23,  168,  168,   22,
		17,   17,  141,   28,    9,    9,  152,   17,   14,    9,
		37,    9,   17,   24,    9,   83,   83,  106,   24,   24,
		17,   95,   17,   17,    9,    9,    9,    9,   17,    9,
		5,    5,    9,    9,   80,   80,  103,  103,  149,   80,
		17,   80,  121,   80,   80,   80,   20,   80,  113,  124,
		80,    2,    2,   20,   80,  113,   41,    9,   16,   16,
		16,   16,  113,  113,  113,  113,  113,   14,   16,   20,
		20,   20,   92,   -1,  139,   23,   23,   23,   23,   23,
		23,   23,   23,   23,   23,   23,   -1,   82,   23,    8,
		8,   16,    8,    8,    8,   -1,    8,    8,    8,   78,
		78,   -1,   -1,   78,   78,   78,   78,   -1,   -1,   -1,
		-1,   -1,   -1,   16,   16
	];

PHP.Parser.prototype.yygbase = [
		0,    0, -203,    0,    0,  221,  208,   10,  512,    7,
		0,    0,   24,    1,    5, -174,   47,  -23,  105,   61,
		38,    0,  -10,  158,  181,  379,  164,  205,  102,   84,
		0,    0,    0,    0,    0,  -43,    0,  107,    0,  104,
		0,   54,   -1,    0,    0,  235, -384,    0, -307,  210,
		0,    0,    0,    0,    0,  266,    0,    0,  324,    0,
		0,  286,    0,  103,  298, -236,    0,    0,    0,    0,
		0,    0,   -6,    0,    0, -167,    0,    0,  129,   62,
		-14,    0,   53,  -22, -669,    0,    0,  -52,    0,  -11,
		0,    0,   68, -299,    0,   52,    0,    0,    0,  262,
		288,    0,    0,  227,  -73,    0,   87,    0,    0,  118,
		0,    0,    0,  209,    0,    0,    0,    0,    0,    6,
		0,  108,   15,    0,   46,    0,    0,    0,    0,    0,
		0,    0,    0,    0,    0,    0,   91,    0,    0,   69,
		0,  390,    0,   86,    0,    0,    0, -224,    0,   37,
		0,    0,   77,    0,    0,    0,    0,    0,    0,   70,
		-57,   -8,  241,   99,    0,    0, -290,    0,   65,  257,
		0,  261,   39,  -35,    0,    0
	];

PHP.Parser.prototype.yygdefault = [
		-32768,  499,  711,    4,  712,  905,  788,  797,  583,  515,
		679,  339,  610,  413, 1255,  882, 1078,  565,  816, 1199,
		1207,  446,  819,  324,  701,  864,  865,  866,  391,  376,
		382,  389,  632,  611,  481,  851,  442,  843,  473,  846,
		441,  855,  162,  410,  497,  859,    3,  861,  542,  892,
		377,  869,  378,  656,  871,  550,  873,  874,  385,  392,
		393, 1083,  558,  607,  886,  243,  552,  887,  375,  888,
		895,  380,  383,  665,  453,  492,  486,  403, 1058,  594,
		629,  450,  467,  617,  616,  604,  466,  425,  408,  928,
		474,  451,  942,  341,  950,  709, 1090,  624,  476,  958,
		625,  965,  968,  516,  517,  465,  980,  269,  983,  477,
		1015,  647,  648,  995,  626,  627, 1013,  460,  584, 1021,
		443, 1029, 1243,  444, 1033,  262, 1036,  276,  409,  426,
		1041, 1042,    8, 1048,  671,  672,   10,  273,  496, 1073,
		666,  440, 1089,  430, 1159, 1161,  544,  478, 1179, 1178,
		659,  493, 1184, 1246,  438,  518,  461,  310,  519,  302,
		327,  307,  534,  289,  328,  520,  462, 1252, 1260,  325,
		30, 1280, 1291,  335,  562,  599
	];

PHP.Parser.prototype.yylhs = [
		0,    1,    3,    3,    2,    5,    5,    6,    6,    6,
		6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
		6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
		6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
		6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
		6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
		6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
		6,    6,    6,    6,    6,    6,    6,    6,    7,    7,
		7,    7,    7,    7,    7,    7,    8,    8,    9,   10,
		11,   11,   11,   12,   12,   13,   13,   14,   15,   15,
		16,   16,   17,   17,   18,   18,   21,   21,   22,   23,
		23,   24,   24,    4,    4,    4,    4,    4,    4,    4,
		4,    4,    4,    4,   29,   29,   30,   30,   32,   34,
		34,   28,   36,   36,   33,   38,   38,   35,   35,   37,
		37,   39,   39,   31,   40,   40,   41,   43,   44,   44,
		45,   46,   46,   48,   47,   47,   47,   47,   49,   49,
		49,   49,   49,   49,   49,   49,   49,   49,   49,   49,
		49,   49,   49,   49,   49,   49,   49,   49,   49,   49,
		49,   49,   25,   25,   68,   68,   71,   71,   70,   69,
		69,   62,   74,   74,   75,   75,   76,   76,   77,   77,
		78,   78,   26,   26,   27,   27,   27,   27,   86,   86,
		88,   88,   81,   81,   81,   82,   82,   85,   85,   83,
		83,   89,   90,   90,   56,   56,   64,   64,   67,   67,
		67,   66,   91,   91,   92,   57,   57,   57,   57,   93,
		93,   94,   94,   95,   95,   96,   97,   97,   98,   98,
		99,   99,   54,   54,   50,   50,  101,   52,   52,  102,
		51,   51,   53,   53,   63,   63,   63,   63,   79,   79,
		105,  105,  107,  107,  108,  108,  108,  108,  106,  106,
		106,  110,  110,  110,  110,   87,   87,  113,  113,  113,
		111,  111,  114,  114,  112,  112,  115,  115,  116,  116,
		116,  116,  109,  109,   80,   80,   80,   20,   20,   20,
		118,  117,  117,  119,  119,  119,  119,   59,  120,  120,
		121,   60,  123,  123,  124,  124,  125,  125,   84,  126,
		126,  126,  126,  126,  126,  131,  131,  132,  132,  133,
		133,  133,  133,  133,  134,  135,  135,  130,  130,  127,
		127,  129,  129,  137,  137,  136,  136,  136,  136,  136,
		136,  136,  128,  138,  138,  140,  139,  139,   61,  100,
		141,  141,   55,   55,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
		42,   42,   42,   42,   42,   42,   42,  148,  142,  142,
		147,  147,  150,  151,  151,  152,  153,  153,  153,   19,
		19,   72,   72,   72,   72,  143,  143,  143,  143,  155,
		155,  144,  144,  146,  146,  146,  149,  149,  160,  160,
		160,  160,  160,  160,  160,  160,  160,  161,  161,  104,
		163,  163,  163,  163,  145,  145,  145,  145,  145,  145,
		145,  145,   58,   58,  158,  158,  158,  158,  164,  164,
		154,  154,  154,  165,  165,  165,  165,  165,  165,   73,
		73,   65,   65,   65,   65,  122,  122,  122,  122,  168,
		167,  157,  157,  157,  157,  157,  157,  157,  156,  156,
		156,  166,  166,  166,  166,  103,  162,  170,  170,  169,
		169,  171,  171,  171,  171,  171,  171,  171,  171,  159,
		159,  159,  159,  173,  174,  172,  172,  172,  172,  172,
		172,  172,  172,  175,  175,  175,  175
	];

PHP.Parser.prototype.yylen = [
		1,    1,    2,    0,    1,    1,    1,    1,    1,    1,
		1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
		1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
		1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
		1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
		1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
		1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
		1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
		1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
		1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
		0,    1,    0,    1,    1,    2,    1,    3,    4,    1,
		2,    0,    1,    1,    1,    1,    1,    3,    5,    4,
		3,    4,    2,    3,    1,    1,    7,    6,    2,    3,
		1,    2,    3,    1,    2,    3,    1,    1,    3,    1,
		3,    1,    2,    2,    3,    1,    3,    2,    3,    1,
		3,    2,    0,    1,    1,    1,    1,    1,    3,    7,
		10,    5,    7,    9,    5,    3,    3,    3,    3,    3,
		3,    1,    2,    5,    7,    9,    6,    5,    6,    3,
		2,    1,    1,    1,    0,    2,    1,    3,    8,    0,
		4,    2,    1,    3,    0,    1,    0,    1,    0,    1,
		3,    1,    8,    9,    8,    7,    6,    8,    0,    2,
		0,    2,    1,    2,    2,    0,    2,    0,    2,    0,
		2,    2,    1,    3,    1,    4,    1,    4,    1,    1,
		4,    2,    1,    3,    3,    3,    4,    4,    5,    0,
		2,    4,    3,    1,    1,    7,    0,    2,    1,    3,
		3,    4,    1,    4,    0,    2,    5,    0,    2,    6,
		0,    2,    0,    3,    1,    2,    1,    1,    2,    0,
		1,    3,    0,    2,    1,    1,    1,    1,    6,    8,
		6,    1,    2,    1,    1,    1,    1,    1,    1,    1,
		3,    3,    3,    3,    3,    3,    3,    3,    1,    2,
		1,    1,    0,    1,    0,    2,    2,    2,    4,    3,
		1,    1,    3,    1,    2,    2,    3,    2,    3,    1,
		1,    2,    3,    1,    1,    3,    2,    0,    1,    5,
		5,   10,    3,    5,    1,    1,    3,    0,    2,    4,
		5,    4,    4,    4,    3,    1,    1,    1,    1,    1,
		1,    0,    1,    1,    2,    1,    1,    1,    1,    1,
		1,    1,    2,    1,    3,    1,    1,    3,    2,    2,
		3,    1,    0,    1,    1,    3,    3,    3,    4,    1,
		1,    2,    3,    3,    3,    3,    3,    3,    3,    3,
		3,    3,    3,    3,    3,    2,    2,    2,    2,    3,
		3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
		3,    3,    3,    3,    3,    3,    3,    2,    2,    2,
		2,    3,    3,    3,    3,    3,    3,    3,    3,    3,
		3,    3,    5,    4,    3,    4,    4,    2,    2,    4,
		2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
		2,    1,    3,    2,    1,    2,    4,    2,    2,    8,
		9,    8,    9,    9,   10,    9,   10,    8,    3,    2,
		0,    4,    2,    1,    3,    2,    2,    2,    4,    1,
		1,    1,    1,    1,    1,    1,    1,    3,    1,    1,
		1,    0,    3,    0,    1,    1,    0,    1,    1,    1,
		1,    1,    1,    1,    1,    1,    1,    3,    3,    3,
		4,    1,    1,    3,    1,    1,    1,    1,    1,    3,
		2,    3,    0,    1,    1,    3,    1,    1,    1,    1,
		1,    3,    1,    1,    4,    4,    1,    4,    4,    0,
		1,    1,    1,    3,    3,    1,    4,    2,    2,    1,
		3,    1,    4,    4,    3,    3,    3,    3,    1,    3,
		1,    1,    3,    1,    1,    4,    1,    1,    1,    3,
		1,    1,    2,    1,    3,    4,    3,    2,    0,    2,
		2,    1,    2,    1,    1,    1,    4,    3,    3,    3,
		3,    6,    3,    1,    1,    2,    1
	];

exports.PHP = PHP;
});

ace.define("ace/mode/php_worker",[], function(require, exports, module) {
"use strict";

var oop = require("../lib/oop");
var Mirror = require("../worker/mirror").Mirror;
var PHP = require("./php/php").PHP;

var PhpWorker = exports.PhpWorker = function(sender) {
    Mirror.call(this, sender);
    this.setTimeout(500);
};

oop.inherits(PhpWorker, Mirror);

(function() {
    this.setOptions = function(opts) {
        this.inlinePhp = opts && opts.inline;
    };
    
    this.onUpdate = function() {
        var value = this.doc.getValue();
        var errors = [];
        if (this.inlinePhp)
            value = "<?" + value + "?>";

this.sender.emit("annotate", errors);
    };

}).call(PhpWorker.prototype);

});

Back to Directory File Manager