/*
 Copyright 2008-2013
 Matthias Ehmann,
 Michael Gerhaeuser,
 Carsten Miller,
 Bianca Valentin,
 Alfred Wassermann,
 Peter Wilfahrt

 This file is part of JSXGraph.

 JSXGraph is free software dual licensed under the GNU LGPL or MIT License.

 You can redistribute it and/or modify it under the terms of the

 * GNU Lesser General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version
 OR
 * MIT License: https://github.com/jsxgraph/jsxgraph/blob/master/LICENSE.MIT

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

 You should have received a copy of the GNU Lesser General Public License and
 the MIT License along with JSXGraph. If not, see <http://www.gnu.org/licenses/>
 and <http://opensource.org/licenses/MIT/>.
 */


/*global JXG: true*/
/*jslint nomen: true, plusplus: true*/

/* depends:
 jxg
 base/constants
 base/coords
 math/numerics
 utils/type
 utils/color
 utils/base64
 utils/encoding
 utils/zip
 utils/xml
  elements:
   grid
   axis
   circle
   glider
   point
   line
   normal
   regularpolygon
   polygon
   intersection
   otherintersection
   midpoint
   text
   arrow
   transform
   mirrorpoint
   reflection
   arc
   ellipse
   conic
   sector
   perpendicular
   tangent
   polar
   circumcirclearc
   circumcirclesector
   semicircle
   angle
   bisector
   slider
   functiongraph
   segment
   integral
 */

(function () {

    "use strict";

    JXG.GeogebraReader = function (board, str) {
        var tree, content;

        content = this.prepareString(str);
        tree = JXG.XML.parse(content);

        this.tree = tree;
        this.board = board;
        this.ggbElements = [];

        // this needs to be accessible from eval'd strings so we have to keep it in board
        this.board.ggb = {};
        this.format = parseFloat(tree.getElementsByTagName('geogebra')[0].getAttribute('format'));
        this.decimals = parseInt(tree.getElementsByTagName('geogebra')[0].getElementsByTagName('kernel')[0].getElementsByTagName('decimals')[0].getAttribute('val'), 10);
    };

    JXG.extend(JXG.GeogebraReader.prototype, /** @lends JXG.GeogebraReader.prototype */ {
        /**
         * @param {String} type the type of expression
         * @param {String} m first input value
         * @param {String} n second input value
         * @returns {String|Array|Number} return the object, string or calculated value
         */
        ggbAct: function (type, m, n) {
            var s1, s2, a,
                regexValue = new RegExp('JXG\\.boards\\[\'' + this.board.id + '\'\\].select\\(\"(.+?)\"\\)\\.'),
                regexSelect = new RegExp('JXG\\.boards\\[\'' + this.board.id + '\'\\].select'),
                v1 = m,
                v2 = n;

            switch (type.toLowerCase()) {
            case 'end':
                return v1;
            case 'coord':
                s1 = (this.ggbElements[v1]) ? 'JXG.boards[\'' + this.board.id + '\'].select(\'' + v1 + '\')' : v1;
                s2 = (this.ggbElements[v2]) ? 'JXG.boards[\'' + this.board.id + '\'].select(\'' + v2 + '\')' : v2;
                return [s1, s2];
            case 'le': // smaller than
                return '( (' + v1 + ') <= (' + v2 + ') )';
            case 'ge': // greater than
                return '( (' + v1 + ') >= (' + v2 + ') )';
            case 'eq': // equal
                return '( (' + v1 + ') == (' + v2 + ') )';
            case 'neq': // not equal
                return '( (' + v1 + ') != (' + v2 + ') )';
            case 'lt': // smaller
                return '( (' + v1 + ') < (' + v2 + ') )';
            case 'gt': // greater
                return '( (' + v1 + ') > (' + v2 + ') )';
            case 'add':
                //Add: Vector + Vector
                if (this.isGGBVector(v1) && this.isGGBVector(v2)) {
                    return [1, v1[1] + '+' + v2[1], v1[2] + '+' + v2[2]];
                }

                // The first match (which is negated) is to check if we are looking at a blank element or a value from this element
                // If the select() call is followed by a '.', a property or a value is accessed, ergo we must not append .X() and .Y().
                if (JXG.isString(v1) && !v1.match(regexValue) && v1.match(regexSelect)) {
                    s1 = [v1 + '.X()', v1 + '.Y()'];
                } else {
                    s1 = v1;
                }

                if (JXG.isString(v2) && !v2.match(regexValue) && v2.match(regexSelect)) {
                    s2 = [v2 + '.X()', v2 + '.Y()'];
                } else {
                    s2 = v2;
                }

                //Add: Vector + Point
                if (this.isGGBVector(s1) && JXG.isArray(s2)) {
                    return [s1[1] + '+' + s2[0], s1[2] + '+' + s2[1]];
                }

                //Add: Vector + Point
                if (this.isGGBVector(s2) && JXG.isArray(s1)) {
                    return [s2[1] + '+' + s1[0], s2[2] + '+' + s1[1]];
                }

                if (JXG.isArray(s1) && JXG.isArray(s2)) {
                    return [s1[0] + ' + ' + s2[0], s1[1] + ' + ' + s2[1]];
                }

                if ((JXG.isNumber(s1) || JXG.isString(s1)) && (JXG.isNumber(s2) || JXG.isString(s2))) {
                    return s1 + ' + ' + s2;
                }

                if ((JXG.isNumber(s1) || JXG.isString(s1)) && JXG.isArray(s2)) {
                    return [s1 + ' + ' + s2[0], s1 + ' + ' + s2[1]];
                }

                if (JXG.isArray(s1) && (JXG.isNumber(s2) || JXG.isString(s2))) {
                    return [s1[0] + ' + ' + s2, s1[1] + ' + ' + s2];
                }

                return s1 + ' + ' + s2;
            case 'sub':
                if (this.isGGBVector(v1) && this.isGGBVector(v2)) { //Sub: Vector - Vector
                    return [1, v1[1] + '-' + v2[1], v1[2] + '-' + v2[2]];
                }

                if (JXG.isString(v1) && !v1.match(regexValue) && v1.match(regexSelect)) {
                    s1 = [v1 + '.X()', v1 + '.Y()'];
                } else {
                    s1 = v1;
                }

                if (JXG.isString(v2) && !v2.match(regexValue) && v2.match(regexSelect)) {
                    s2 = [v2 + '.X()', v2 + '.Y()'];
                } else {
                    s2 = v2;
                }

                //Add: Vector - Point
                if (this.isGGBVector(s1) && JXG.isArray(s2)) {
                    return [s1[1] + '-' + s2[0], s1[2] + '-' + s2[1]];
                }

                //Add: Punkt - Vector
                if (JXG.isArray(s1) && this.isGGBVector(s2)) {
                    return [s1[0] + '-(' + s2[1] + ')', s1[1] + '-(' + s2[2] + ')'];
                }

                if (JXG.isArray(s1) && JXG.isArray(s2)) {
                    return [ s1[0] + ' - ' + s2[0], s1[1] + ' - ' + s2[1] ];
                }

                if ((JXG.isNumber(s1) || JXG.isString(s1)) && (JXG.isNumber(s2) || JXG.isString(s2))) {
                    return s1 + ' - ' + s2;
                }

                if ((JXG.isNumber(s1) || JXG.isString(s1)) && JXG.isArray(s2)) {
                    return [s1 + ' - ' + s2[0], s1 + ' - ' + s2[1]];
                }

                if (JXG.isArray(s1) && (JXG.isNumber(s2) || JXG.isString(s2))) {
                    return [s1[0] + ' - ' + s2, s1[1] + ' - ' + s2];
                }

                return s1 + ' - ' + s2;
            case 'neg':
                return '!(' + v1 + ')';
            case 'pow':
                return 'Math.pow(' + v1 + ', ' + v2 + ')';
            case 'or':
                return '(' + v1 + '||' + v2 + ')';
            case 'and':
                return '(' + v1 + '&&' + v2 + ')';
            case 'mul':
                if (this.isGGBVector(v1) && !JXG.isArray(v2)) { // Mult: Vector * Skalar
                    return [1, '(' + v1[1] + ')*' + v2, '(' + v1[2] + ')*' + v2];
                }

                if (!JXG.isArray(v1) && this.isGGBVector(v2)) { // Mult: Skalar * Vector
                    return [1, '(' + v2[1] + ')*' + v1, '(' + v2[2] + ')*' + v1];
                }

                if (this.isGGBVector(v1) && this.isGGBVector(v2)) { //Mult: Vector * Vector
                    return '((' + v1[1] + ')*(' + v2[1] + ')+(' + v1[2] + ')*(' + v2[2] + '))';
                }

                if (JXG.isString(v1) && !v1.match(regexValue) && v1.match(regexSelect)) {
                    s1 = [v1 + '.X()', v1 + '.Y()'];
                } else {
                    s1 = v1;
                }

                if (JXG.isString(v2) && !v2.match(regexValue) && v2.match(regexSelect)) {
                    s2 = [v2 + '.X()', v2 + '.Y()'];
                } else {
                    s2 = v2;
                }

                if (JXG.isArray(s1) && JXG.isArray(s2)) {
                    return [s1[0] + ' * ' + s2[0], s1[1] + ' * ' + s2[1]];
                }

                if ((JXG.isNumber(s1) || JXG.isString(s1)) && (JXG.isNumber(s2) || JXG.isString(s2))) {
                    return s1 + ' * ' + s2;
                }

                if ((JXG.isNumber(s1) || JXG.isString(s1)) && JXG.isArray(s2)) {
                    return [s1 + ' * ' + s2[0], s1 + ' * ' + s2[1]];
                }

                if (JXG.isArray(s1) && (JXG.isNumber(s2) || JXG.isString(s2))) {
                    return [s1[0] + ' * ' + s2, s1[1] + ' * ' + s2];
                }

                return s1 + ' * ' + s2;
            case 'div':
                if (JXG.isString(v1) && !v1.match(regexValue) && v1.match(regexSelect)) {
                    s1 = [v1 + '.X()', v1 + '.Y()'];
                } else {
                    s1 = v1;
                }

                if (JXG.isString(v2) && !v2.match(regexValue) && v2.match(regexSelect)) {
                    s2 = [v2 + '.X()', v2 + '.Y()'];
                } else {
                    s2 = v2;
                }

                if (JXG.isArray(s1) && JXG.isArray(s2)) {
                    return [s1[0] + ' / ' + s2[0], s1[1] + ' / ' + s2[1]];
                }

                if ((JXG.isNumber(s1) || JXG.isString(s1)) && (JXG.isNumber(s2) || JXG.isString(s2))) {
                    return s1 + ' / ' + s2;
                }

                if ((JXG.isNumber(s1) || JXG.isString(s1)) && JXG.isArray(s2)) {
                    return [ s1 + ' / ' + s2[0], s1 + ' / ' + s2[1] ];
                }

                if (JXG.isArray(s1) && (JXG.isNumber(s2) || JXG.isString(s2))) {
                    return [s1[0] + ' / ' + s2, s1[1] + ' / ' + s2 ];
                }

                return s1 + ' / ' + s2;
            case 'negmult':
                if (this.isGGBVector(v1)) {
                    return [1, -1 + '*' + v1[1], -1 + '*' + v1[2]];
                }

                return -1 + '*' + v1;
            case 'bra':
                if (this.isGGBVector(v1)) {
                    return [1, '(' + v1[1] + ')', '(' + v1[2] + ')'];
                }

                return '(' + v1 + ')';
            case 'int':
                return parseInt(v1, 10);
            case 'float':
                return parseFloat(v1);
            case 'param':
                return v1;
            case 'html':
                return v1;
            case 'string':
                if (v2) {
                    return [v1, v2];
                }

                return v1;
            case 'command':
                v2 = v1.split('[');
                s1 = v2[0];
                s2 = (v2[1].split(']'))[0];
                if (s1.toLowerCase() === 'name') {
                    return 'JXG.boards[\'' + this.board.id + '\'].select(\'' + s2 + '\').getName()';
                }
                break;
            case 'var':
                if (v2) {
                    switch (v1.toLowerCase()) {
                    case 'x':
                        return v2 + '.X()';
                    case 'y':
                        return v2 + '.Y()';
                    case 'abs':
                    case 'acos':
                    case 'asin':
                    case 'atan':
                    case 'ceil':
                    case 'cos':
                    case 'exp':
                    case 'floor':
                    case 'log':
                    case 'max':
                    case 'min':
                    case 'pow':
                    case 'random':
                    case 'round':
                    case 'sin':
                    case 'sqrt':
                    case 'tan':
                        return 'Math.' + v1.toLowerCase() + '(' +  v2 + ')';
                    default:
                        return v1.toLowerCase() + '*(' + v2 + ')';
                    }
                } else {
                    if (v1 === 'PI') {
                        return 'Math.PI';
                    }

                    a = this.checkElement(v1);
                    if (JXG.exists(this.board.ggb[v1])) {
                        return 'JXG.boards[\'' + this.board.id + '\'].ggb["' + v1 + '"]()';
                    }

                    if (JXG.exists(a.Value)) {
                        return 'JXG.boards[\'' + this.board.id + '\'].select("' + v1 + '").Value()';
                    }

                    if (JXG.exists(a.Area)) {
                        return 'JXG.boards[\'' + this.board.id + '\'].select("' + v1 + '").Area()';
                    }

                    if (JXG.exists(a.plaintextStr)) {
                        return '1.0*JXG.boards[\'' + this.board.id + '\'].select("' + v1 + '").plaintextStr';
                    }

                    if (a.type === JXG.OBJECT_TYPE_VECTOR) {
                        return [1, 'JXG.boards[\'' + this.board.id + '\'].select("' + v1 + '").point2.X()-JXG.boards[\'' + this.board.id + '\'].select("' + v1 + '").point1.X()', 'JXG.boards[\'' + this.board.id + '\'].select("' + v1 + '").point2.Y()-JXG.boards[\'' + this.board.id + '\'].select("' + v1 + '").point1.Y()'];
                    }

                    if (a.elementClass === JXG.OBJECT_CLASS_LINE) {
                        return 'JXG.boards[\'' + this.board.id + '\'].select("' + v1 + '").point1.Dist(JXG.boards[\'' + this.board.id + '\'].select("' + v1 + '").point2)';
                    }

                    return 'JXG.boards[\'' + this.board.id + '\'].select("' + v1 + '")';
                }
            }
        },

        /**
         * JS/CC parser to convert the input expression to a working javascript function.
         * @param {String} exp String which contains the function, expression or information
         * @param {Object} el Element that needs to be updated
         */
        ggbParse: function (exp, el) {
            var i, error_count,
                error_offsets = [],
                error_lookaheads = [],
                errstr = '',
                str = exp,
                dbg_withtrace = false,
                dbg_string = '',
                ggbr = this,
                element = el ? this.board.select(this.ggbElements[el].id) : false;

            if (element) {
                JXG.debug("Update element: " + element.name + "(" + element.id + ")");
            }

            /*
             This parser was generated with: The LALR(1) parser and lexical analyzer generator for JavaScript, written in JavaScript
             In the version 0.30 on http://jscc.jmksf.com/

             It is based on the default template driver for JS/CC generated parsers running as
             browser-based JavaScript/ECMAScript applications and was strongly modified.

             The parser was written 2007, 2008 by Jan Max Meyer, J.M.K S.F. Software Technologies
             This is in the public domain.
             */

            /***** begin replace *****/
            function dbg_print(text) {
                dbg_string += text + '\n';
            }

            function lex(info) {
                var state = 0,
                    match = -1,
                    match_pos = 0,
                    start = 0,
                    pos = info.offset + 1;

                do {
                    pos -= 1;
                    state = 0;
                    match = -2;
                    start = pos;

                    if (info.src.length <= start) {
                        return 28;
                    }

                    do {
                        switch (state) {
                        case 0:
                            if (info.src.charCodeAt(pos) === 9 || info.src.charCodeAt(pos) === 32) {
                                state = 1;
                            } else if (info.src.charCodeAt(pos) === 33) {
                                state = 2;
                            } else if (info.src.charCodeAt(pos) === 40) {
                                state = 3;
                            } else if (info.src.charCodeAt(pos) === 41) {
                                state = 4;
                            } else if (info.src.charCodeAt(pos) === 42) {
                                state = 5;
                            } else if (info.src.charCodeAt(pos) === 43) {
                                state = 6;
                            } else if (info.src.charCodeAt(pos) === 44) {
                                state = 7;
                            } else if (info.src.charCodeAt(pos) === 45) {
                                state = 8;
                            } else if (info.src.charCodeAt(pos) === 47) {
                                state = 9;
                            } else if ((info.src.charCodeAt(pos) >= 48 && info.src.charCodeAt(pos) <= 57)) {
                                state = 10;
                            } else if (info.src.charCodeAt(pos) === 60) {
                                state = 11;
                            } else if (info.src.charCodeAt(pos) === 62) {
                                state = 12;
                            } else if ((info.src.charCodeAt(pos) >= 65 && info.src.charCodeAt(pos) <= 90) || (info.src.charCodeAt(pos) >= 97 && info.src.charCodeAt(pos) <= 122)) {
                                state = 13;
                            } else if (info.src.charCodeAt(pos) === 94) {
                                state = 14;
                            } else if (info.src.charCodeAt(pos) === 34) {
                                state = 26;
                            } else if (info.src.charCodeAt(pos) === 38) {
                                state = 28;
                            } else if (info.src.charCodeAt(pos) === 46) {
                                state = 29;
                            } else if (info.src.charCodeAt(pos) === 61) {
                                state = 30;
                            } else if (info.src.charCodeAt(pos) === 95) {
                                state = 31;
                            } else if (info.src.charCodeAt(pos) === 124) {
                                state = 32;
                            } else {
                                state = -1;
                            }
                            break;

                        case 1:
                            state = -1;
                            match = 1;
                            match_pos = pos;
                            break;

                        case 2:
                            if (info.src.charCodeAt(pos) === 61) {
                                state = 15;
                            } else {
                                state = -1;
                            }
                            match = 23;
                            match_pos = pos;
                            break;

                        case 3:
                            state = -1;
                            match = 2;
                            match_pos = pos;
                            break;

                        case 4:
                            state = -1;
                            match = 3;
                            match_pos = pos;
                            break;

                        case 5:
                            state = -1;
                            match = 13;
                            match_pos = pos;
                            break;

                        case 6:
                            state = -1;
                            match = 11;
                            match_pos = pos;
                            break;

                        case 7:
                            state = -1;
                            match = 16;
                            match_pos = pos;
                            break;

                        case 8:
                            state = -1;
                            match = 12;
                            match_pos = pos;
                            break;

                        case 9:
                            state = -1;
                            match = 14;
                            match_pos = pos;
                            break;

                        case 10:
                            if ((info.src.charCodeAt(pos) >= 48 && info.src.charCodeAt(pos) <= 57)) {
                                state = 10;
                            } else if (info.src.charCodeAt(pos) === 46) {
                                state = 18;
                            } else {
                                state = -1;
                            }
                            match = 4;
                            match_pos = pos;
                            break;

                        case 11:
                            if (info.src.charCodeAt(pos) === 61) {
                                state = 19;
                            } else {
                                state = -1;
                            }
                            match = 21;
                            match_pos = pos;
                            break;

                        case 12:
                            if (info.src.charCodeAt(pos) === 61) {
                                state = 21;
                            } else {
                                state = -1;
                            }
                            match = 22;
                            match_pos = pos;
                            break;

                        case 13:
                            if ((info.src.charCodeAt(pos) >= 65 && info.src.charCodeAt(pos) <= 90) || (info.src.charCodeAt(pos) >= 97 && info.src.charCodeAt(pos) <= 122)) {
                                state = 13;
                            } else if ((info.src.charCodeAt(pos) >= 48 && info.src.charCodeAt(pos) <= 57)) {
                                state = 27;
                            } else if (info.src.charCodeAt(pos) === 91) {
                                state = 34;
                            } else if (info.src.charCodeAt(pos) === 95) {
                                state = 35;
                            } else {
                                state = -1;
                            }
                            match = 7;
                            match_pos = pos;
                            break;

                        case 14:
                            state = -1;
                            match = 15;
                            match_pos = pos;
                            break;

                        case 15:
                            state = -1;
                            match = 20;
                            match_pos = pos;
                            break;

                        case 16:
                            state = -1;
                            match = 9;
                            match_pos = pos;
                            break;

                        case 17:
                            state = -1;
                            match = 25;
                            match_pos = pos;
                            break;

                        case 18:
                            if ((info.src.charCodeAt(pos) >= 48 && info.src.charCodeAt(pos) <= 57)) {
                                state = 18;
                            } else {
                                state = -1;
                            }
                            match = 5;
                            match_pos = pos;
                            break;

                        case 19:
                            state = -1;
                            match = 17;
                            match_pos = pos;
                            break;

                        case 20:
                            state = -1;
                            match = 19;
                            match_pos = pos;
                            break;

                        case 21:
                            state = -1;
                            match = 18;
                            match_pos = pos;
                            break;

                        case 22:
                            state = -1;
                            match = 24;
                            match_pos = pos;
                            break;

                        case 23:
                            state = -1;
                            match = 8;
                            match_pos = pos;
                            break;

                        case 24:
                            if ((info.src.charCodeAt(pos) >= 48 && info.src.charCodeAt(pos) <= 57) || (info.src.charCodeAt(pos) >= 65 && info.src.charCodeAt(pos) <= 90) || (info.src.charCodeAt(pos) >= 97 && info.src.charCodeAt(pos) <= 122)) {
                                state = 24;
                            } else {
                                state = -1;
                            }
                            match = 6;
                            match_pos = pos;
                            break;

                        case 25:
                            state = -1;
                            match = 10;
                            match_pos = pos;
                            break;

                        case 26:
                            if (info.src.charCodeAt(pos) === 34) {
                                state = 16;
                            } else if (info.src.charCodeAt(pos) === 32 || info.src.charCodeAt(pos) === 46 || (info.src.charCodeAt(pos) >= 48 && info.src.charCodeAt(pos) <= 57) || info.src.charCodeAt(pos) === 61 || (info.src.charCodeAt(pos) >= 65 && info.src.charCodeAt(pos) <= 90) || (info.src.charCodeAt(pos) >= 97 && info.src.charCodeAt(pos) <= 122) || info.src.charCodeAt(pos) === 223 || info.src.charCodeAt(pos) === 228 || info.src.charCodeAt(pos) === 246 || info.src.charCodeAt(pos) === 252) {
                                state = 26;
                            } else {
                                state = -1;
                            }
                            break;

                        case 27:
                            if ((info.src.charCodeAt(pos) >= 48 && info.src.charCodeAt(pos) <= 57) || (info.src.charCodeAt(pos) >= 65 && info.src.charCodeAt(pos) <= 90) || (info.src.charCodeAt(pos) >= 97 && info.src.charCodeAt(pos) <= 122)) {
                                state = 27;
                            } else if (info.src.charCodeAt(pos) === 95) {
                                state = 35;
                            } else {
                                state = -1;
                            }
                            match = 7;
                            match_pos = pos;
                            break;

                        case 28:
                            if (info.src.charCodeAt(pos) === 38) {
                                state = 17;
                            } else if ((info.src.charCodeAt(pos) >= 65 && info.src.charCodeAt(pos) <= 90) || (info.src.charCodeAt(pos) >= 97 && info.src.charCodeAt(pos) <= 122)) {
                                state = 33;
                            } else {
                                state = -1;
                            }
                            break;

                        case 29:
                            if ((info.src.charCodeAt(pos) >= 48 && info.src.charCodeAt(pos) <= 57)) {
                                state = 18;
                            } else {
                                state = -1;
                            }
                            break;

                        case 30:
                            if (info.src.charCodeAt(pos) === 61) {
                                state = 20;
                            } else {
                                state = -1;
                            }
                            break;

                        case 31:
                            if (info.src.charCodeAt(pos) === 95) {
                                state = 36;
                            } else {
                                state = -1;
                            }
                            break;

                        case 32:
                            if (info.src.charCodeAt(pos) === 124) {
                                state = 22;
                            } else {
                                state = -1;
                            }
                            break;

                        case 33:
                            if (info.src.charCodeAt(pos) === 59) {
                                state = 23;
                            } else if ((info.src.charCodeAt(pos) >= 65 && info.src.charCodeAt(pos) <= 90) || (info.src.charCodeAt(pos) >= 97 && info.src.charCodeAt(pos) <= 122)) {
                                state = 33;
                            } else {
                                state = -1;
                            }
                            break;

                        case 34:
                            if ((info.src.charCodeAt(pos) >= 65 && info.src.charCodeAt(pos) <= 90) || (info.src.charCodeAt(pos) >= 97 && info.src.charCodeAt(pos) <= 122)) {
                                state = 37;
                            } else {
                                state = -1;
                            }
                            break;

                        case 35:
                            if ((info.src.charCodeAt(pos) >= 48 && info.src.charCodeAt(pos) <= 57) || (info.src.charCodeAt(pos) >= 65 && info.src.charCodeAt(pos) <= 90) || (info.src.charCodeAt(pos) >= 97 && info.src.charCodeAt(pos) <= 122)) {
                                state = 27;
                            } else if (info.src.charCodeAt(pos) === 95) {
                                state = 35;
                            } else {
                                state = -1;
                            }
                            break;

                        case 36:
                            if ((info.src.charCodeAt(pos) >= 48 && info.src.charCodeAt(pos) <= 57) || (info.src.charCodeAt(pos) >= 65 && info.src.charCodeAt(pos) <= 90) || (info.src.charCodeAt(pos) >= 97 && info.src.charCodeAt(pos) <= 122)) {
                                state = 24;
                            } else {
                                state = -1;
                            }
                            break;

                        case 37:
                            if (info.src.charCodeAt(pos) === 93) {
                                state = 25;
                            } else if ((info.src.charCodeAt(pos) >= 65 && info.src.charCodeAt(pos) <= 90) || (info.src.charCodeAt(pos) >= 97 && info.src.charCodeAt(pos) <= 122)) {
                                state = 37;
                            } else {
                                state = -1;
                            }
                            break;
                        }
                        pos += 1;

                    } while (state > -1);
                } while (1 > -1 && match === 1);

                if (match > -1) {
                    info.att = info.src.substr(start, match_pos - start);
                    info.offset = match_pos;


                } else {
                    info.att = '';
                    match = -1;
                }

                return match;
            }


            function parse(src, err_off, err_la) {
                var i, act, go, la, rval, rvstack, rsstack, undef,
                    act_tab, pop_tab, goto_tab, labels,
                    sstack = [],
                    vstack = [],
                    err_cnt = 0,
                    info = {};

                // Pop-Table
                pop_tab = [
                    [/* p' */0, 1],
                    [/* p */27, 1],
                    [/* e */26, 5],
                    [/* e */26, 3],
                    [/* e */26, 3],
                    [/* e */26, 3],
                    [/* e */26, 3],
                    [/* e */26, 3],
                    [/* e */26, 3],
                    [/* e */26, 3],
                    [/* e */26, 3],
                    [/* e */26, 2],
                    [/* e */26, 3],
                    [/* e */26, 3],
                    [/* e */26, 3],
                    [/* e */26, 3],
                    [/* e */26, 3],
                    [/* e */26, 2],
                    [/* e */26, 3],
                    [/* e */26, 3],
                    [/* e */26, 1],
                    [/* e */26, 1],
                    [/* e */26, 1],
                    [/* e */26, 1],
                    [/* e */26, 1],
                    [/* e */26, 1],
                    [/* e */26, 4],
                    [/* e */26, 1]
                ];

                // Action-Table
                act_tab = [
                    /* State 0 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 1 */
                    [/* "$$" */28, 0],
                    /* State 2 */
                    [/* "/" */14, 13, /* "*" */13, 14, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, 17, /* "-" */12, 18, /* "+" */11, 19, /* ">" */22, 20, /* "<" */21, 21, /* "!=" */20, 22, /* "==" */19, 23, /* ">=" */18, 24, /* "<=" */17, 25, /* "$$" */28, -1],
                    /* State 3 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 4 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 5 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 6 */
                    [/* "+" */11, 29, /* "$$" */28, -24, /* "<=" */17, -24, /* ">=" */18, -24, /* "==" */19, -24, /* "!=" */20, -24, /* "<" */21, -24, /* ">" */22, -24, /* "-" */12, -24, /* "^" */15, -24, /* "||" */24, -24, /* "&&" */25, -24, /* "*" */13, -24, /* "/" */14, -24, /* "," */16, -24, /* ")" */3, -24],
                    /* State 7 */
                    [/* "$$" */28, -20, /* "<=" */17, -20, /* ">=" */18, -20, /* "==" */19, -20, /* "!=" */20, -20, /* "<" */21, -20, /* ">" */22, -20, /* "+" */11, -20, /* "-" */12, -20, /* "^" */15, -20, /* "||" */24, -20, /* "&&" */25, -20, /* "*" */13, -20, /* "/" */14, -20, /* "," */16, -20, /* ")" */3, -20],
                    /* State 8 */
                    [/* "$$" */28, -21, /* "<=" */17, -21, /* ">=" */18, -21, /* "==" */19, -21, /* "!=" */20, -21, /* "<" */21, -21, /* ">" */22, -21, /* "+" */11, -21, /* "-" */12, -21, /* "^" */15, -21, /* "||" */24, -21, /* "&&" */25, -21, /* "*" */13, -21, /* "/" */14, -21, /* "," */16, -21, /* ")" */3, -21],
                    /* State 9 */
                    [/* "$$" */28, -22, /* "<=" */17, -22, /* ">=" */18, -22, /* "==" */19, -22, /* "!=" */20, -22, /* "<" */21, -22, /* ">" */22, -22, /* "+" */11, -22, /* "-" */12, -22, /* "^" */15, -22, /* "||" */24, -22, /* "&&" */25, -22, /* "*" */13, -22, /* "/" */14, -22, /* "," */16, -22, /* ")" */3, -22],
                    /* State 10 */
                    [/* "$$" */28, -23, /* "<=" */17, -23, /* ">=" */18, -23, /* "==" */19, -23, /* "!=" */20, -23, /* "<" */21, -23, /* ">" */22, -23, /* "+" */11, -23, /* "-" */12, -23, /* "^" */15, -23, /* "||" */24, -23, /* "&&" */25, -23, /* "*" */13, -23, /* "/" */14, -23, /* "," */16, -23, /* ")" */3, -23],
                    /* State 11 */
                    [/* "$$" */28, -25, /* "<=" */17, -25, /* ">=" */18, -25, /* "==" */19, -25, /* "!=" */20, -25, /* "<" */21, -25, /* ">" */22, -25, /* "+" */11, -25, /* "-" */12, -25, /* "^" */15, -25, /* "||" */24, -25, /* "&&" */25, -25, /* "*" */13, -25, /* "/" */14, -25, /* "," */16, -25, /* ")" */3, -25],
                    /* State 12 */
                    [/* "(" */2, 30, /* "$$" */28, -27, /* "<=" */17, -27, /* ">=" */18, -27, /* "==" */19, -27, /* "!=" */20, -27, /* "<" */21, -27, /* ">" */22, -27, /* "+" */11, -27, /* "-" */12, -27, /* "^" */15, -27, /* "||" */24, -27, /* "&&" */25, -27, /* "*" */13, -27, /* "/" */14, -27, /* "," */16, -27, /* ")" */3, -27],
                    /* State 13 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 14 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 15 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 16 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 17 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 18 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 19 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 20 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 21 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 22 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 23 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 24 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 25 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 26 */
                    [/* "/" */14, 13, /* "*" */13, 14, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, 17, /* "-" */12, 18, /* "+" */11, 19, /* ">" */22, 20, /* "<" */21, 21, /* "!=" */20, 22, /* "==" */19, 23, /* ">=" */18, 24, /* "<=" */17, 25, /* "," */16, 44, /* ")" */3, 45],
                    /* State 27 */
                    [/* "/" */14, -11, /* "*" */13, -11, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, -11, /* "-" */12, -11, /* "+" */11, -11, /* ">" */22, -11, /* "<" */21, -11, /* "!=" */20, -11, /* "==" */19, -11, /* ">=" */18, -11, /* "<=" */17, -11, /* "$$" */28, -11, /* "," */16, -11, /* ")" */3, -11],
                    /* State 28 */
                    [/* "/" */14, -17, /* "*" */13, -17, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, 17, /* "-" */12, -17, /* "+" */11, -17, /* ">" */22, 20, /* "<" */21, 21, /* "!=" */20, 22, /* "==" */19, 23, /* ">=" */18, 24, /* "<=" */17, 25, /* "$$" */28, -17, /* "," */16, -17, /* ")" */3, -17],
                    /* State 29 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 30 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 31 */
                    [/* "/" */14, -16, /* "*" */13, -16, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, 17, /* "-" */12, -16, /* "+" */11, -16, /* ">" */22, 20, /* "<" */21, 21, /* "!=" */20, 22, /* "==" */19, 23, /* ">=" */18, 24, /* "<=" */17, 25, /* "$$" */28, -16, /* "," */16, -16, /* ")" */3, -16],
                    /* State 32 */
                    [/* "/" */14, -15, /* "*" */13, -15, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, 17, /* "-" */12, -15, /* "+" */11, -15, /* ">" */22, 20, /* "<" */21, 21, /* "!=" */20, 22, /* "==" */19, 23, /* ">=" */18, 24, /* "<=" */17, 25, /* "$$" */28, -15, /* "," */16, -15, /* ")" */3, -15],
                    /* State 33 */
                    [/* "/" */14, -14, /* "*" */13, -14, /* "&&" */25, -14, /* "||" */24, -14, /* "^" */15, -14, /* "-" */12, -14, /* "+" */11, -14, /* ">" */22, -14, /* "<" */21, -14, /* "!=" */20, -14, /* "==" */19, -14, /* ">=" */18, -14, /* "<=" */17, -14, /* "$$" */28, -14, /* "," */16, -14, /* ")" */3, -14],
                    /* State 34 */
                    [/* "/" */14, -13, /* "*" */13, -13, /* "&&" */25, -13, /* "||" */24, -13, /* "^" */15, -13, /* "-" */12, -13, /* "+" */11, -13, /* ">" */22, -13, /* "<" */21, -13, /* "!=" */20, -13, /* "==" */19, -13, /* ">=" */18, -13, /* "<=" */17, -13, /* "$$" */28, -13, /* "," */16, -13, /* ")" */3, -13],
                    /* State 35 */
                    [/* "/" */14, -12, /* "*" */13, -12, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, -12, /* "-" */12, -12, /* "+" */11, -12, /* ">" */22, 20, /* "<" */21, 21, /* "!=" */20, 22, /* "==" */19, 23, /* ">=" */18, 24, /* "<=" */17, 25, /* "$$" */28, -12, /* "," */16, -12, /* ")" */3, -12],
                    /* State 36 */
                    [/* "/" */14, 13, /* "*" */13, 14, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, 17, /* "-" */12, -10, /* "+" */11, -10, /* ">" */22, 20, /* "<" */21, 21, /* "!=" */20, 22, /* "==" */19, 23, /* ">=" */18, 24, /* "<=" */17, 25, /* "$$" */28, -10, /* "," */16, -10, /* ")" */3, -10],
                    /* State 37 */
                    [/* "/" */14, 13, /* "*" */13, 14, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, 17, /* "-" */12, -9, /* "+" */11, -9, /* ">" */22, 20, /* "<" */21, 21, /* "!=" */20, 22, /* "==" */19, 23, /* ">=" */18, 24, /* "<=" */17, 25, /* "$$" */28, -9, /* "," */16, -9, /* ")" */3, -9],
                    /* State 38 */
                    [/* "/" */14, -8, /* "*" */13, -8, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, -8, /* "-" */12, -8, /* "+" */11, -8, /* ">" */22, -8, /* "<" */21, -8, /* "!=" */20, -8, /* "==" */19, -8, /* ">=" */18, -8, /* "<=" */17, -8, /* "$$" */28, -8, /* "," */16, -8, /* ")" */3, -8],
                    /* State 39 */
                    [/* "/" */14, -7, /* "*" */13, -7, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, -7, /* "-" */12, -7, /* "+" */11, -7, /* ">" */22, -7, /* "<" */21, -7, /* "!=" */20, -7, /* "==" */19, -7, /* ">=" */18, -7, /* "<=" */17, -7, /* "$$" */28, -7, /* "," */16, -7, /* ")" */3, -7],
                    /* State 40 */
                    [/* "/" */14, -6, /* "*" */13, -6, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, -6, /* "-" */12, -6, /* "+" */11, -6, /* ">" */22, -6, /* "<" */21, -6, /* "!=" */20, -6, /* "==" */19, -6, /* ">=" */18, -6, /* "<=" */17, -6, /* "$$" */28, -6, /* "," */16, -6, /* ")" */3, -6],
                    /* State 41 */
                    [/* "/" */14, -5, /* "*" */13, -5, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, -5, /* "-" */12, -5, /* "+" */11, -5, /* ">" */22, -5, /* "<" */21, -5, /* "!=" */20, -5, /* "==" */19, -5, /* ">=" */18, -5, /* "<=" */17, -5, /* "$$" */28, -5, /* "," */16, -5, /* ")" */3, -5],
                    /* State 42 */
                    [/* "/" */14, -4, /* "*" */13, -4, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, -4, /* "-" */12, -4, /* "+" */11, -4, /* ">" */22, -4, /* "<" */21, -4, /* "!=" */20, -4, /* "==" */19, -4, /* ">=" */18, -4, /* "<=" */17, -4, /* "$$" */28, -4, /* "," */16, -4, /* ")" */3, -4],
                    /* State 43 */
                    [/* "/" */14, -3, /* "*" */13, -3, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, -3, /* "-" */12, -3, /* "+" */11, -3, /* ">" */22, -3, /* "<" */21, -3, /* "!=" */20, -3, /* "==" */19, -3, /* ">=" */18, -3, /* "<=" */17, -3, /* "$$" */28, -3, /* "," */16, -3, /* ")" */3, -3],
                    /* State 44 */
                    [/* "(" */2, 3, /* "!" */23, 4, /* "-" */12, 5, /* "STRING" */9, 6, /* "INT" */4, 7, /* "FLOAT" */5, 8, /* "PARAM" */6, 9, /* "HTML" */8, 10, /* "COMMAND" */10, 11, /* "VAR" */7, 12],
                    /* State 45 */
                    [/* "$$" */28, -18, /* "<=" */17, -18, /* ">=" */18, -18, /* "==" */19, -18, /* "!=" */20, -18, /* "<" */21, -18, /* ">" */22, -18, /* "+" */11, -18, /* "-" */12, -18, /* "^" */15, -18, /* "||" */24, -18, /* "&&" */25, -18, /* "*" */13, -18, /* "/" */14, -18, /* "," */16, -18, /* ")" */3, -18],
                    /* State 46 */
                    [/* "/" */14, 13, /* "*" */13, 14, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, 17, /* "-" */12, -19, /* "+" */11, -19, /* ">" */22, 20, /* "<" */21, 21, /* "!=" */20, 22, /* "==" */19, 23, /* ">=" */18, 24, /* "<=" */17, 25, /* "$$" */28, -19, /* "," */16, -19, /* ")" */3, -19],
                    /* State 47 */
                    [/* "/" */14, 13, /* "*" */13, 14, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, 17, /* "-" */12, 18, /* "+" */11, 19, /* ">" */22, 20, /* "<" */21, 21, /* "!=" */20, 22, /* "==" */19, 23, /* ">=" */18, 24, /* "<=" */17, 25, /* ")" */3, 49],
                    /* State 48 */
                    [/* "/" */14, 13, /* "*" */13, 14, /* "&&" */25, 15, /* "||" */24, 16, /* "^" */15, 17, /* "-" */12, 18, /* "+" */11, 19, /* ">" */22, 20, /* "<" */21, 21, /* "!=" */20, 22, /* "==" */19, 23, /* ">=" */18, 24, /* "<=" */17, 25, /* ")" */3, 50],
                    /* State 49 */
                    [/* "$$" */28, -26, /* "<=" */17, -26, /* ">=" */18, -26, /* "==" */19, -26, /* "!=" */20, -26, /* "<" */21, -26, /* ">" */22, -26, /* "+" */11, -26, /* "-" */12, -26, /* "^" */15, -26, /* "||" */24, -26, /* "&&" */25, -26, /* "*" */13, -26, /* "/" */14, -26, /* "," */16, -26, /* ")" */3, -26],
                    /* State 50 */
                    [/* "$$" */28, -2, /* "<=" */17, -2, /* ">=" */18, -2, /* "==" */19, -2, /* "!=" */20, -2, /* "<" */21, -2, /* ">" */22, -2, /* "+" */11, -2, /* "-" */12, -2, /* "^" */15, -2, /* "||" */24, -2, /* "&&" */25, -2, /* "*" */13, -2, /* "/" */14, -2, /* "," */16, -2, /* ")" */3, -2]
                ];

                // Goto-Table
                goto_tab = [
                    /* State 0 */
                    [/* p */27, 1, /* e */26, 2],
                    /* State 1 */
                    [],
                    /* State 2 */
                    [],
                    /* State 3 */
                    [/* e */26, 26],
                    /* State 4 */
                    [/* e */26, 27],
                    /* State 5 */
                    [/* e */26, 28],
                    /* State 6 */
                    [],
                    /* State 7 */
                    [],
                    /* State 8 */
                    [],
                    /* State 9 */
                    [],
                    /* State 10 */
                    [],
                    /* State 11 */
                    [],
                    /* State 12 */
                    [],
                    /* State 13 */
                    [/* e */26, 31],
                    /* State 14 */
                    [/* e */26, 32],
                    /* State 15 */
                    [/* e */26, 33],
                    /* State 16 */
                    [/* e */26, 34],
                    /* State 17 */
                    [/* e */26, 35],
                    /* State 18 */
                    [/* e */26, 36],
                    /* State 19 */
                    [/* e */26, 37],
                    /* State 20 */
                    [/* e */26, 38],
                    /* State 21 */
                    [/* e */26, 39],
                    /* State 22 */
                    [/* e */26, 40],
                    /* State 23 */
                    [/* e */26, 41],
                    /* State 24 */
                    [/* e */26, 42],
                    /* State 25 */
                    [/* e */26, 43],
                    /* State 26 */
                    [],
                    /* State 27 */
                    [],
                    /* State 28 */
                    [],
                    /* State 29 */
                    [/* e */26, 46],
                    /* State 30 */
                    [/* e */26, 47],
                    /* State 31 */
                    [],
                    /* State 32 */
                    [],
                    /* State 33 */
                    [],
                    /* State 34 */
                    [],
                    /* State 35 */
                    [],
                    /* State 36 */
                    [],
                    /* State 37 */
                    [],
                    /* State 38 */
                    [],
                    /* State 39 */
                    [],
                    /* State 40 */
                    [],
                    /* State 41 */
                    [],
                    /* State 42 */
                    [],
                    /* State 43 */
                    [],
                    /* State 44 */
                    [/* e */26, 48],
                    /* State 45 */
                    [],
                    /* State 46 */
                    [],
                    /* State 47 */
                    [],
                    /* State 48 */
                    [],
                    /* State 49 */
                    [],
                    /* State 50 */
                    []
                ];



                // Symbol labels
                labels = [
                    /* Non-terminal symbol */
                    "p'",
                    /* Terminal symbol */
                    "WHITESPACE",
                    /* Terminal symbol */
                    "(",
                    /* Terminal symbol */
                    ")",
                    /* Terminal symbol */
                    "INT",
                    /* Terminal symbol */
                    "FLOAT",
                    /* Terminal symbol */
                    "PARAM",
                    /* Terminal symbol */
                    "VAR",
                    /* Terminal symbol */
                    "HTML",
                    /* Terminal symbol */
                    "STRING",
                    /* Terminal symbol */
                    "COMMAND",
                    /* Terminal symbol */
                    "+",
                    /* Terminal symbol */
                    "-",
                    /* Terminal symbol */
                    "*",
                    /* Terminal symbol */
                    "/",
                    /* Terminal symbol */
                    "^",
                    /* Terminal symbol */
                    ",",
                    /* Terminal symbol */
                    "<=",
                    /* Terminal symbol */
                    ">=",
                    /* Terminal symbol */
                    "==",
                    /* Terminal symbol */
                    "!=",
                    /* Terminal symbol */
                    "<",
                    /* Terminal symbol */
                    ">",
                    /* Terminal symbol */
                    "!",
                    /* Terminal symbol */
                    "||",
                    /* Terminal symbol */
                    "&&",
                    /* Non-terminal symbol */
                    "e",
                    /* Non-terminal symbol */
                    "p",
                    /* Terminal symbol */
                    "$$"
                ];



                info.offset = 0;
                info.src = src;
                info.att = '';

                if (!err_off) {
                    err_off = [];
                }

                if (!err_la) {
                    err_la = [];
                }

                sstack.push(0);
                vstack.push(0);

                la = lex(info);

                while (true) {
                    act = 52;

                    for (i = 0; i < act_tab[sstack[sstack.length - 1]].length; i += 2) {
                        if (act_tab[sstack[sstack.length - 1]][i] === la) {
                            act = act_tab[sstack[sstack.length - 1]][i + 1];
                            break;
                        }
                    }

                    if (dbg_withtrace && sstack.length > 0) {
                        dbg_print('\nState ' + sstack[sstack.length - 1] + '\n' +
                            '\tLookahead: ' + labels[la] + ' (\'' + info.att + '\')\n' +
                            '\tAction: ' + act + '\n' +
                            '\tSource: \'' + info.src.substr(info.offset, 30) +
                            ((info.offset + 30 < info.src.length) ? '...' : '') +
                            '\'\n' + '\tStack: ' + sstack.join() + '\n' +
                            '\tValue stack: ' + vstack.join() + '\n');
                    }

                    //Panic-mode: Try recovery when parse-error occurs!
                    if (act === 52) {
                        if (dbg_withtrace) {
                            dbg_print('Error detected: There is no reduce or shift on the symbol ' + labels[la]);
                        }

                        err_cnt += 1;
                        err_off.push(info.offset - info.att.length);
                        err_la.push([]);
                        for (i = 0; i < act_tab[sstack[sstack.length - 1]].length; i += 2) {
                            err_la[err_la.length - 1].push(labels[act_tab[sstack[sstack.length - 1]][i]]);
                        }

                        //Remember the original stack!
                        rsstack = [];
                        rvstack = [];
                        for (i = 0; i < sstack.length; i++) {
                            rsstack[i] = sstack[i];
                            rvstack[i] = vstack[i];
                        }

                        while (act === 52 && la !== 28) {
                            if (dbg_withtrace) {
                                dbg_print('\tError recovery\n' +
                                    'Current lookahead: ' + labels[la] + ' (' + info.att + ')\n' +
                                    'Action: ' + act + '\n\n');
                            }

                            if (la === -1) {
                                info.offset += 1;
                            }

                            while (act === 52 && sstack.length > 0) {
                                sstack.pop();
                                vstack.pop();

                                if (sstack.length === 0) {
                                    break;
                                }

                                act = 52;

                                for (i = 0; i < act_tab[sstack[sstack.length - 1]].length; i += 2) {
                                    if (act_tab[sstack[sstack.length - 1]][i] === la) {
                                        act = act_tab[sstack[sstack.length - 1]][i + 1];
                                        break;
                                    }
                                }
                            }

                            if (act !== 52) {
                                break;
                            }

                            for (i = 0; i < rsstack.length; i++) {
                                sstack.push(rsstack[i]);
                                vstack.push(rvstack[i]);
                            }

                            la = lex(info);
                        }

                        if (act === 52) {
                            if (dbg_withtrace) {
                                dbg_print('\tError recovery failed, terminating parse process...');
                            }
                            break;
                        }


                        if (dbg_withtrace) {
                            dbg_print('\tError recovery succeeded, continuing');
                        }
                    }

                    //Shift
                    if (act > 0) {
                        if (dbg_withtrace) {
                            dbg_print('Shifting symbol: ' + labels[la] + ' (' + info.att + ')');
                        }

                        sstack.push(act);
                        vstack.push(info.att);

                        la = lex(info);

                        if (dbg_withtrace) {
                            dbg_print('\tNew lookahead symbol: ' + labels[la] + ' (' + info.att + ')');
                        }
                        //Reduce
                    } else {
                        act *= -1;

                        if (dbg_withtrace) {
                            dbg_print('Reducing by producution: ' + act);
                        }

                        rval = undef;

                        if (dbg_withtrace) {
                            dbg_print('\tPerforming semantic action...');
                        }

                        switch (act) {
                        case 0:
                            rval = vstack[vstack.length - 1];
                            break;
                        case 1:
                            rval = ggbr.ggbAct('end', vstack[vstack.length - 1]);
                            break;
                        case 2:
                            rval = ggbr.ggbAct('coord', vstack[vstack.length - 4], vstack[vstack.length - 2], element);
                            break;
                        case 3:
                            rval = ggbr.ggbAct('le', vstack[vstack.length - 3], vstack[vstack.length - 1]);
                            break;
                        case 4:
                            rval = ggbr.ggbAct('ge', vstack[vstack.length - 3], vstack[vstack.length - 1]);
                            break;
                        case 5:
                            rval = ggbr.ggbAct('eq', vstack[vstack.length - 3], vstack[vstack.length - 1]);
                            break;
                        case 6:
                            rval = ggbr.ggbAct('neq', vstack[vstack.length - 3], vstack[vstack.length - 1]);
                            break;
                        case 7:
                            rval = ggbr.ggbAct('lt', vstack[vstack.length - 3], vstack[vstack.length - 1]);
                            break;
                        case 8:
                            rval = ggbr.ggbAct('gt', vstack[vstack.length - 3], vstack[vstack.length - 1]);
                            break;
                        case 9:
                            rval = ggbr.ggbAct('add', vstack[vstack.length - 3], vstack[vstack.length - 1]);
                            break;
                        case 10:
                            rval = ggbr.ggbAct('sub', vstack[vstack.length - 3], vstack[vstack.length - 1]);
                            break;
                        case 11:
                            rval = ggbr.ggbAct('neg', vstack[vstack.length - 1]);
                            break;
                        case 12:
                            rval = ggbr.ggbAct('pow', vstack[vstack.length - 3], vstack[vstack.length - 1]);
                            break;
                        case 13:
                            rval = ggbr.ggbAct('or', vstack[vstack.length - 3], vstack[vstack.length - 1]);
                            break;
                        case 14:
                            rval = ggbr.ggbAct('and', vstack[vstack.length - 3], vstack[vstack.length - 1]);
                            break;
                        case 15:
                            rval = ggbr.ggbAct('mul', vstack[vstack.length - 3], vstack[vstack.length - 1]);
                            break;
                        case 16:
                            rval = ggbr.ggbAct('div', vstack[vstack.length - 3], vstack[vstack.length - 1]);
                            break;
                        case 17:
                            rval = ggbr.ggbAct('negmult', vstack[vstack.length - 1]);
                            break;
                        case 18:
                            rval = ggbr.ggbAct('bra', vstack[vstack.length - 2]);
                            break;
                        case 19:
                            rval = ggbr.ggbAct('string', vstack[vstack.length - 3], vstack[vstack.length - 1]);
                            break;
                        case 20:
                            rval = ggbr.ggbAct('int', vstack[vstack.length - 1]);
                            break;
                        case 21:
                            rval = ggbr.ggbAct('float', vstack[vstack.length - 1]);
                            break;
                        case 22:
                            rval = ggbr.ggbAct('param', vstack[vstack.length - 1]);
                            break;
                        case 23:
                            rval = ggbr.ggbAct('html', vstack[vstack.length - 1]);
                            break;
                        case 24:
                            rval = ggbr.ggbAct('string', vstack[vstack.length - 1]);
                            break;
                        case 25:
                            rval = ggbr.ggbAct('command', vstack[vstack.length - 1]);
                            break;
                        case 26:
                            rval = ggbr.ggbAct('var', vstack[vstack.length - 4], vstack[vstack.length - 2]);
                            break;
                        case 27:
                            rval = ggbr.ggbAct('var', vstack[vstack.length - 1]);
                            break;
                        }

                        if (dbg_withtrace) {
                            dbg_print('\tPopping ' + pop_tab[act][1] + ' off the stack...');
                        }

                        for (i = 0; i < pop_tab[act][1]; i++) {
                            sstack.pop();
                            str = vstack.pop();
                        }

                        go = -1;
                        for (i = 0; i < goto_tab[sstack[sstack.length - 1]].length; i += 2) {
                            if (goto_tab[sstack[sstack.length - 1]][i] === pop_tab[act][0]) {
                                go = goto_tab[sstack[sstack.length - 1]][i + 1];
                                break;
                            }
                        }

                        if (act === 0) {
                            break;
                        }

                        if (dbg_withtrace) {
                            dbg_print('\tPushing non-terminal ' + labels[pop_tab[act][0]]);
                        }

                        sstack.push(go);
                        vstack.push(rval);
                    }

                    if (dbg_withtrace) {
                        JXG.debug(dbg_string);
                        dbg_string = '';
                    }
                }

                if (dbg_withtrace) {
                    dbg_print('\nParse complete.');
                    JXG.debug(dbg_string);
                }

                return err_cnt;
            }
            /***** end replace *****/

            if ((error_count = parse(str, error_offsets, error_lookaheads)) > 0) {
                for (i = 0; i < error_count; i++) {
                    errstr += 'Parse error in line ' +
                        (str.substr(0, error_offsets[i]).match(/\n/g) ? str.substr(0, error_offsets[i]).match(/\n/g).length : 1) +
                        ' near \'' + str.substr(error_offsets[i]) + '\', expecting \'' + error_lookaheads[i].join() + '\'\n';
                }
                JXG.debug(errstr);
            }

            return str;
        },

        /**
         * Override JSxGraph defaults with Geogebra settings
         */
        setDefaultOptions: function () {
            this.board.options.elements.strokeWidth = 1;
            this.board.options.elements.withLabel = true;

            this.board.options.point.face = 'circle';
            this.board.options.point.size = 3;
            this.board.options.point.fillColor = 'blue';
            this.board.options.point.fillOpacity = 1;
            this.board.options.point.highlightFillOpacity = 1;
            this.board.options.point.strokeColor = 'black';
            this.board.options.point.highlightStrokeColor = 'black';
            this.board.options.point.strokeWidth = 2;

            this.board.options.line.strokeWidth = 1;
            this.board.options.line.highlightStrokeColor = '#000000';
            this.board.options.line.strokeColor = '#000000';

            this.board.options.polygon.fillColor = JXG.rgb2hex(153, 51, 0);
            this.board.options.polygon.fillOpacity = 0.1;
            this.board.options.polygon.highlightFillColor = this.board.options.polygon.fillColor;
            this.board.options.polygon.highlightFillOpacity = 0.1;

            this.board.options.sector.fillColor = JXG.rgb2hex(153, 51, 0);
            this.board.options.sector.fillOpacity = 0.1;
            this.board.options.sector.highlightFillColor = this.board.options.sector.fillColor;
            this.board.options.sector.highlightFillOpacity = 0.1;

            this.board.options.angle.fillColor = JXG.rgb2hex(0, 100, 0);
            this.board.options.angle.fillOpacity = 0.1;
            this.board.options.angle.highlightFillOpacity = 0.1;
        },

        /**
         * Set color properties of a geogebra element.
         * Set stroke, fill, lighting, label and draft color attributes.
         * @param {Object} Data gxtEl element of which attributes are to set
         * @param {Object} attr object carrying all necessary attribute values
         * @returns {Object} returning the updated attr-attributes object
         */
        colorProperties: function (Data, attr) {
            var a, r, g, b,
                objColor = Data.getElementsByTagName("objColor")[0],
                len = Data.getElementsByTagName("objColor").length > 0;

            a = (len && objColor.getAttribute("alpha")) ? parseFloat(objColor.getAttribute("alpha")) : 0;
            r = (len && objColor.getAttribute("r")) ? parseInt(objColor.getAttribute("r"), 10).toString(16) : 0;
            g = (len && objColor.getAttribute("g")) ? parseInt(objColor.getAttribute("g"), 10).toString(16) : 0;
            b = (len && objColor.getAttribute("b")) ? parseInt(objColor.getAttribute("b"), 10).toString(16) : 0;

            if (r.length === 1) {
                r = '0' + r;
            }

            if (g.length === 1) {
                g = '0' + g;
            }

            if (b.length === 1) {
                b = '0' + b;
            }

            attr.fillColor = '#' + r + g + b;
            attr.strokeColor = attr.fillColor;
            attr.highlightFillColor = attr.fillColor;
            attr.highlightStrokeColor = attr.strokeColor;
            attr.fillOpacity = a;
            attr.highlightFillOpacity = a;
            attr.labelColor = attr.fillColor;

            return attr;
        },

        /**
         * Set the board properties.
         * Set active, area, dash, draft and showinfo attributes.
         * @param {Object} gxtEl element of which attributes are to set
         * @param {Object} Data element of which attributes are to set
         * @param {Object} attr object containing the necessary attribute values
         * @returns {Object} The attr parameter
         */
        boardProperties: function (gxtEl, Data, attr) {
            return attr;
        },

        /**
         * @param {Object} gxtEl element of which attributes are to set
         * @param {Object} Data element of which attributes are to set
         * @returns {Object} updated element
         */
        coordinates: function (gxtEl, Data) {
            var a, tmp,
                labelOffset = {
                    x: 0,
                    y: 0,
                    z: 0
                };

            if (Data.getElementsByTagName('labelOffset')[0]) {
                labelOffset.x = parseFloat(Data.getElementsByTagName("labelOffset")[0].getAttribute("x")) / this.board.unitX;
                labelOffset.y = parseFloat(Data.getElementsByTagName("labelOffset")[0].getAttribute("y")) / this.board.unitY;
            }

            if (Data.getElementsByTagName("coords")[0]) {
                gxtEl.x = parseFloat(Data.getElementsByTagName("coords")[0].getAttribute("x"));
                gxtEl.y = parseFloat(Data.getElementsByTagName("coords")[0].getAttribute("y"));
                gxtEl.z = parseFloat(Data.getElementsByTagName("coords")[0].getAttribute("z"));
            } else if (Data.getElementsByTagName("startPoint")[0]) {
                if (Data.getElementsByTagName("startPoint")[0].getAttribute('exp')) {
                    a = this.board.select(Data.getElementsByTagName("startPoint")[0].getAttribute('exp'));
                    gxtEl.x = function () {
                        return a.X() + labelOffset.x;
                    };
                    gxtEl.y = function () {
                        // minus because geogebra starts on the other side
                        return a.Y() - labelOffset.y;
                    };
                    gxtEl.z = false;
                } else {
                    gxtEl.x = parseFloat(Data.getElementsByTagName("startPoint")[0].getAttribute("x"));
                    gxtEl.y = parseFloat(Data.getElementsByTagName("startPoint")[0].getAttribute("y"));
                    gxtEl.z = parseFloat(Data.getElementsByTagName("startPoint")[0].getAttribute("z"));
                }
            } else if (Data.getElementsByTagName("absoluteScreenLocation")[0]) {
                tmp = new JXG.Coords(JXG.COORDS_BY_SCREEN, [parseFloat(Data.getElementsByTagName("absoluteScreenLocation")[0].getAttribute("x")),
                    parseFloat(Data.getElementsByTagName("absoluteScreenLocation")[0].getAttribute("y"))], this.board);
                gxtEl.x = tmp.usrCoords[1] + labelOffset.x;
                gxtEl.y = tmp.usrCoords[2] + labelOffset.y;
                gxtEl.z = false;
            } else {
                return false;
            }

            return gxtEl;
        },

        /**
         * Writing element attributes to the given object
         * @param {Object} Data expects the content of the current element
         * @param {Object} attr
         * @returns {Object} object with according attributes
         */
        visualProperties: function (Data, attr) {
            var show = Data.getElementsByTagName("show"),
                pointSize = Data.getElementsByTagName('pointSize'),
                pointStyle = Data.getElementsByTagName('pointStyle'),
                slopeTriangleSize = Data.getElementsByTagName('slopeTriangleSize'),
                lineStyle = Data.getElementsByTagName('lineStyle'),
                labelOffset = Data.getElementsByTagName('labelOffset'),
                trace = Data.getElementsByTagName('trace'),
                fix = Data.getElementsByTagName('fix');

            if (show.length > 0 && show[0].getAttribute('object')) {
                attr.visible = JXG.str2Bool(show[0].getAttribute('object'));
            }

            if (show.length > 0 && show[0].getAttribute('label')) {
                attr.withLabel = JXG.str2Bool(show[0].getAttribute('label'));
            }

            if (pointSize.length > 0 && pointSize[0].getAttribute('val')) {
                attr.size = parseInt(pointSize[0].getAttribute('val'), 10);
            }

            if (pointStyle.length > 0 && pointStyle[0].getAttribute('val')) {
                attr.styleGGB = parseInt(pointStyle[0].getAttribute('val'), 10);
            }

            if (attr.styleGGB === 0 || attr.styleGGB === 2) {
                attr.face = 'circle';

                if (attr.styleGGB === 0) {
                    attr.fillColor = attr.strokeColor;
                    attr.fillOpacity = 1;
                    attr.highlightFillColor = attr.strokeColor;
                    attr.highlightFillOpacity = 1;
                    attr.strokeColor = 'black';
                    attr.strokeWidth = 1;
                } else if (attr.styleGGB === 2) {
                    attr.fillColor = 'none';
                }
            } else if (attr.styleGGB === 1) {
                attr.face = 'x';
            } else if (attr.styleGGB === 3) {
                attr.face = '+';
                attr.strokeOpacity = 1;
            } else if (attr.styleGGB === 4 || attr.styleGGB === 5) {
                attr.face = 'diamond';

                if (attr.styleGGB === 4) {
                    attr.fillColor = attr.strokeColor;
                    attr.fillOpacity = 1;
                } else if (attr.styleGGB === 5) {
                    attr.fillColor = 'none';
                }
            } else if (attr.styleGGB === 6) {
                attr.face = 'triangleUp';
                attr.fillColor = attr.strokeColor;
                attr.fillOpacity = 1;
            } else if (attr.styleGGB === 7) {
                attr.face = 'triangleDown';
                attr.fillColor = attr.strokeColor;
                attr.fillOpacity = 1;
            } else if (attr.styleGGB === 8) {
                attr.face = 'triangleRight';
                attr.fillColor = attr.strokeColor;
                attr.fillOpacity = 1;
            } else if (attr.styleGGB === 9) {
                attr.face = 'triangleLeft';
                attr.fillColor = attr.strokeColor;
                attr.fillOpacity = 1;
            }

            if (slopeTriangleSize.length > 0) {
                attr.slopeWidth = slopeTriangleSize[0].getAttribute('val');
            }

            if (lineStyle.length > 0) {
                attr.strokeWidth = Math.round(parseFloat(lineStyle[0].getAttribute('thickness')) / 2);
                attr.dashGGB = lineStyle[0].getAttribute("type");
            }

            if (attr.strokeWidth) {
                attr.highlightStrokeWidth = attr.strokeWidth + 1;
            }

            if (attr.dashGGB === '0') {
                attr.dash = 0;
            } else if (attr.dashGGB === '10') {
                attr.dash = 2;
            } else if (attr.dashGGB === '15') {
                attr.dash = 3;
            } else if (attr.dashGGB === '20') {
                attr.dash = 1;
            } else if (attr.dashGGB === '30') {
                attr.dash = 6;
            }

            if (labelOffset.length > 0) {
                attr.labelX = parseFloat(labelOffset[0].getAttribute('x'));
                attr.labelY = parseFloat(labelOffset[0].getAttribute('y'));
            }

            if (trace.length > 0) {
                attr.trace = trace[0].getAttribute('val');
            }

            if (fix.length > 0) {
                attr.fixed = fix[0].getAttribute('val');
            }

            return attr;
        },

        /**
         * Searching for an element in the geogebra tree
         * @param {String} name the name of the element to search for
         * @param {Boolean} [expr=false] whether it is search for an expression or not
         * @returns {Object} object with according label
         */
        getElement: function (name, expr) {
            var Data, i, j;

            expr = expr || false;
            for (i = 0; i < this.tree.getElementsByTagName("construction").length; i++) {
                if (expr === false) {
                    for (j = 0; j < this.tree.getElementsByTagName("construction")[i].getElementsByTagName("element").length; j++) {
                        Data = this.tree.getElementsByTagName("construction")[i].getElementsByTagName("element")[j];
                        if (name === Data.getAttribute("label")) {
                            return Data;
                        }
                    }
                } else {
                    for (j = 0; j < this.tree.getElementsByTagName("construction")[i].getElementsByTagName("expression").length; j++) {
                        Data = this.tree.getElementsByTagName("construction")[i].getElementsByTagName("expression")[j];
                        if (name === Data.getAttribute("label")) {
                            return Data;
                        }
                        if (name === Data.getAttribute("exp")) {
                            return this.getElement(Data.getAttribute("label"));
                        }
                    }
                }
            }

            return false;
        },

        /**
         * Check if an element is already registered in the temporary ggbElements register. If not, create and register the element.
         * @param {String} name the name of the element to check
         * @returns {Object} newly created element
         */
        checkElement: function (name) {
            var input;

            // Segment[A, B] nur bis Version 2.4 ? In 2.5 schon (x(A), x(B)) und durch Parser loesbar
            // if(name.match(/[a-zA-Z]+\[[a-zA-Z0-9]+[a-zA-Z0-9,\ ]*\]/)) {
            //   var tmp, type, input, output, i;
            //   tmp = name.split('[');
            //   type = tmp[0];
            //   input = tmp[1].split(']');
            //   input = input[0].split(', ');
            //   for(i=0; i<input.length; i++) {
            //     input[i] = this.checkElement(input[i]);
            //   }
            //   output = {
            //     'attributes' : []
            //   };
            //   output.attributes['type'] = {value: type };
            //   output.attributes['label'] = {value: name};
            //
            //   this.ggbElements[name] = this.writeElement(name, input, type);
            // } else

            if (!JXG.exists(this.ggbElements[name]) || this.ggbElements[name] === '') {
                input = this.getElement(name) || this.getElement(name, true);
                if(!input) {
                    var i, j, Data;
                    var exp1 = this.ggbParse(name);
                    for (i = 0; i < this.tree.getElementsByTagName("construction").length; i++) {
                        for (j = 0; j < this.tree.getElementsByTagName("construction")[i].getElementsByTagName("expression").length; j++) {
                            Data = this.tree.getElementsByTagName("construction")[i].getElementsByTagName("expression")[j];
                            var exp2 = this.ggbParse(Data.getAttribute("exp"));
                            if(JXG.isArray(exp1) && JXG.isArray(exp2)) {
                                if(exp1[0] == exp2[0] && exp1[1] == exp2[1]) {
                                    input = this.getElement(Data.getAttribute("label"));
                                }
                            }
                        }
                    }
                    if(!input) {
                        return new Function('return ' + exp1 + ';');
                    }
                }
                this.ggbElements[name] = this.writeElement(input);
            }

            return this.ggbElements[name];
        },

        /**
         * Prepare expression for this.ggbParse with solving multiplications and replacing mathematical functions.
         * @param {String} type c, s, or something else
         * @param {String} exp Expression to parse and correct
         * @returns {String} correct expression with fixed function and multiplication
         */
        functionParse: function (type, exp) {
            var input, vars, expr, output, i, s, o;

            switch (type) {
            case 'c':
                // search for function params
                if (exp.match(/[a-zA-Z0-9\']+\([a-zA-Z0-9]+[a-zA-Z0-9,\ ]*\)[\ ]*[=][\ ]*[a-zA-Z0-9\+\-\*\/ \( \) \u005E]+/)) {
                    input = exp.split('(')[1].split(')')[0];
                    vars = input.split(', ');

                    output = [];
                    for (i = 0; i < vars.length; i++) {
                        output.push("__" + vars[i]);
                    }

                    expr = exp.split('=')[1];

                    // separate and replace function parameters
                    for (i = 0; i < vars.length; i++) {
                        if (vars[i] === 'x') {
                            expr = expr.replace(/(?![e])x(?!\()(?![p])/g, '__' + vars[i]);
                        } else if (vars[i] === 'y') {
                            expr = expr.replace(/(?![e])y(?!\()(?![p])/g, '__' + vars[i]);
                        } else {
                            expr = expr.replace(new RegExp(vars[i], 'g'), '__' + vars[i]);
                        }
                    }

                    // replace -__x to -1*__x
                    expr = expr.replace(/-__/g, '-1*__');

                    if (this.format <= 3.01) {
                        // prepare string: "solve" multiplications 'a b' to 'a*b'
                        s = expr.split(' ');
                        o = '';

                        for (i = 0; i < s.length; i++) {
                            if (s.length !== i + 1) {
                                if (s[i].search(/\)$/) > -1 || s[i].search(/[0-9]+$/) > -1 || s[i].search(/[a-zA-Z]+(_*[a-zA-Z0-9]+)*$/) > -1) {
                                    if (s[i + 1].search(/^\(/) > -1 ||
                                            s[i + 1].search(/^[0-9]+/) > -1 ||
                                            s[i + 1].search(/^[a-zA-Z]+(_*[a-zA-Z0-9]+)*/) > -1 ||
                                            s[i + 1].search(/__[a-zA-Z0-9]+/) > -1) {
                                        s[i] = s[i] + "*";
                                    }
                                }
                            }
                            o += s[i];
                        }
                        expr = o;
                    }

                    output.push(expr);
                    return output;
                }

                return exp;
            case 's':
                exp = exp.replace(/(?![e])x(?!\()(?![p])/g, '__x');
                return ['__x', exp];
            default:
                if (this.format <= 3.01) {
                    // prepare string: "solve" multiplications 'a b' to 'a*b'
                    s = exp.split(' ');
                    o = '';

                    for (i = 0; i < s.length; i++) {
                        if (s.length !== i + 1) {
                            if (s[i].search(/\)$/) > -1 || s[i].search(/[0-9]+$/) > -1 || s[i].search(/[a-zA-Z]+(_*[a-zA-Z0-9]+)*$/) > -1) {
                                if (s[i + 1].search(/^\(/) > -1 ||
                                        s[i + 1].search(/^[0-9]+/) > -1 ||
                                        s[i + 1].search(/^[a-zA-Z]+(\_*[a-zA-Z0-9]+)*/) > -1 ||
                                        s[i + 1].search(/\_\_[a-zA-Z0-9]+/) > -1) {
                                    s[i] = s[i] + "*";
                                }
                            }
                        }
                        o += s[i];
                    }
                    exp = o;
                }
                return exp;
            }
        },

        /**
         * Searching for an element in the geogebra tree
         */
        writeBoard: function () {
            var grid, // currently unused: snapToPoint,
                boardData = this.tree.getElementsByTagName("euclidianView")[0],
                coordSystem = boardData.getElementsByTagName('coordSystem')[0],
                gui = this.tree.getElementsByTagName('gui')[0],
                evSettings = boardData.getElementsByTagName('evSettings')[0];

            this.board.origin = {};
            this.board.origin.usrCoords = [1, 0, 0];
            this.board.origin.scrCoords = [1, parseInt(coordSystem.getAttribute('xZero'), 10), parseInt(coordSystem.getAttribute('yZero'), 10)];
            this.board.unitX = (coordSystem.getAttribute('scale')) ? parseInt(coordSystem.getAttribute('scale'), 10) : 1;
            this.board.unitY = (coordSystem.getAttribute('yscale')) ? parseInt(coordSystem.getAttribute('yscale'), 10) : this.board.unitX;

            this.board.fontSize = (gui && gui.getElementsByTagName('font')[0]) ?
                    parseInt(gui.getElementsByTagName("font")[0].getAttribute("size"), 10) :
                    12;

            // the new board storage
            JXG.boards[this.board.id] = this.board;

            // Update of properties during update() is not necessary in GEONExT files
            this.board.renderer.enhancedRendering = true;

            // snap to point; value is never used?
            //snapToPoint = (evSettings.getAttribute("pointCapturing") === "true");

            grid = (evSettings.getAttribute("grid") === "true") ? this.board.create('grid') : null;

            if (evSettings.getAttribute("axes")) {
                if(evSettings.getAttribute("axes") === "true") {
                    this.ggbElements.xAxis = this.board.create('axis', [[0, 0], [1, 0]], {strokeColor: 'transparent', minorTicks: 0});
                    this.ggbElements.yAxis = this.board.create('axis', [[0, 0], [0, 1]], {strokeColor: 'black', minorTicks: 0});
                } else {
                    this.ggbElements.xAxis = this.board.create('axis', [[0, 0], [1, 0]], {strokeColor: 'transparent', ticks: {drawLabels: false}});
                    this.ggbElements.yAxis = this.board.create('axis', [[0, 0], [0, 1]], {strokeColor: 'transparent', ticks: {drawLabels: false}});
                }
            }
        },

        /**
         * Searching for an element in the geogebra tree
         * @param {Object} output ggb element whose attributes are to parse
         * @param {Array} input list of all input elements
         * @param {String} cmd output construction method
         * @returns {Object} return newly created element or false
         */
        writeElement: function (output, input, cmd) {
            var p, res, re2, poly, t2, t, m, i, l2, p2, l1, p1, slopeWidth,
                tmp, attr2, t1, i2, i1, pol, type, d2, d1, d, startpoint,
                inp, borderatts, borders, element, gxtEl, attr, exp, coord, points,
                length, match, matchDep, rx, q, c, s, e, sx, sy, ex, ey, func, range,

                // for use with closures
                that = this,

                makeConstFun = function (a) {
                    return function () {
                        return a;
                    };
                },
                makeRootFun = function (x) {
                    return function () {
                        return JXG.Math.Numerics.root(inp.Y, x, inp);
                    };
                };

            element = (JXG.isArray(output) ? output[0] : output);
            // geometric element
            gxtEl = {};
            // Attributes of geometric elements
            attr = {};

            JXG.debug(element);

            gxtEl.type = (element && element.attributes && !JXG.exists(cmd)) ? element.getAttribute('type').toLowerCase() : cmd;
            gxtEl.label = element.getAttribute('label');
            attr.name  = gxtEl.label;

            JXG.debug("Constructing " + attr.name + "(" + gxtEl.type + "):");

            switch (gxtEl.type) {
            case 'point':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                attr = this.visualProperties(element, attr);

                if (this.getElement(attr.name, true)) {
                    exp = this.getElement(attr.name, true).getAttribute('exp');
                    coord = this.ggbParse(exp);

                    // this is parsed and verified by the parser unit above
                    /*jslint evil:true*/
                    gxtEl.x = new Function('return ' + coord[0] + ';');
                    gxtEl.y = new Function('return ' + coord[1] + ';');
                    /*jslint evil:false*/
                } else {
                    gxtEl = this.coordinates(gxtEl, element);
                }

                if (!JXG.exists(attr.styleGGB)) {
                    attr.face = 'circle';
                    attr.fillColor = attr.strokeColor;
                    attr.fillOpacity = 1;
                    attr.highlightFillColor = attr.strokeColor;
                    attr.highlightFillOpacity = 1;
                    attr.strokeColor = 'black';
                    attr.strokeWidth = 1;
                }

                JXG.debug(gxtEl);
                JXG.debug(input);

                try {
                    match = /Circle\[\s*(\w+)\s*,\s*([\d\.]+)\s*\]/.exec(input);
                    matchDep = /Circle\[\s*(\w+)\s*,\s*(\w+)\s*\]/.exec(input);

                    if (JXG.exists(input)) {
                        if (JXG.exists(match) && match.length === 3) {
                            // from Circle[A, 5] take "A" and "5", stored in ma[1] and ma[2]
                            q = this.checkElement(match[1]);
                            c = this.board.create('circle', [q, parseFloat(match[2])], {fillColor: 'none', visible: false, name: ''});
                            p = this.board.create('glider', [gxtEl.x, gxtEl.y, c], attr);
                        } else if (JXG.exists(matchDep) && matchDep.length === 3) {
                            // Circle around point ma[1] with radius defined by another elements Value-function ma[2]
                            q = this.checkElement(matchDep[1]);
                            m = this.checkElement(matchDep[2]);
                            c = this.board.create('circle', [q, function () { return m.Value(); }], {fillColor: 'none', visible: false, name: ''});
                            p = this.board.create('glider', [gxtEl.x, gxtEl.y, c], attr);
                        } else if (JXG.isArray(input)) {
                            p = this.board.create('glider', [gxtEl.x, gxtEl.y, input[0]], attr);
                        } else {
                            p = this.board.create('glider', [gxtEl.x, gxtEl.y, input], attr);
                        }
                    } else {
                        p = this.board.create('point', [gxtEl.x, gxtEl.y], attr);
                    }
                    return p;
                } catch (exc1) {
                    JXG.debug("* Err: Point " + attr.name);
                    return false;
                }
                break;
            case 'segment':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                if (typeof input === 'undefined') {
                    input = [
                        parseFloat(element.getElementsByTagName('coords')[0].getAttribute('z')),
                        parseFloat(element.getElementsByTagName('coords')[0].getAttribute('x')),
                        parseFloat(element.getElementsByTagName('coords')[0].getAttribute('y'))
                    ];
                } else if (this.board.select(input[1].id).elementClass === JXG.OBJECT_CLASS_LINE) {
                    type = 'parallel';
                }

                try {
                    JXG.debug("* Segment: (" + attr.name + ") First: " + input[0].name + ", Last: " + input[1].name);
                    attr.straightFirst = false;
                    attr.straightLast =  false;
                    p = this.board.create('line', input, attr);
                    return p;
                } catch (exc2) {
                    JXG.debug("* Err: Segment " + attr.name + " First: " + input[0].name + ", Last: " + input[1].name);
                    return false;
                }
                break;
            case 'line':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                type = 'line';
                if (!input) {
                    input = [
                        parseFloat(element.getElementsByTagName('coords')[0].getAttribute('z')),
                        parseFloat(element.getElementsByTagName('coords')[0].getAttribute('x')),
                        parseFloat(element.getElementsByTagName('coords')[0].getAttribute('y'))
                    ];
                } else if (this.board.select(input[1].id).elementClass === JXG.OBJECT_CLASS_LINE) {
                    // Parallel line through point
                    type = 'parallel';
                }

                try {
                    p = this.board.create(type, input, attr);
                    return p;
                } catch (exc3) {
                    JXG.debug("* Err: Line " + attr.label);
                    return false;
                }
                break;
            case "orthogonalline":
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* Orthogonalline: First: " + input[0].id + ", Last: " + input[1].id);
                    p = this.board.create('normal', input, attr);
                    return p;
                } catch (exc4) {
                    JXG.debug("* Err: Orthogonalline " + attr.label);
                    return false;
                }
                break;
            case "polygon":
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                // test if polygon is regular
                if (input.length === 3 && output.length !== 4) {
                    input[2] = parseInt(input[2], 10);
                    type = 'regular';
                }

                try {
                    JXG.debug("* Polygon: First: " + input[0].name + ", Second: " + input[1].name + ", Third: " + input[2]);

                    borders = [];
                    borderatts = [];
                    length = (type === 'regular' ? output.length - input[2] + 2 : output.length);

                    for (i = 1; i < length; i++) {
                        borders[i - 1] = {};
                        borderatts[i - 1] = {};
                        borders[i - 1].id = '';
                        borders[i - 1].name = output[i].getAttribute('label');
                        borderatts[i - 1] = this.colorProperties(output[i], borderatts[i - 1]);
                        borderatts[i - 1] = this.visualProperties(output[i], borderatts[i - 1]);
                    }
                    attr.borders = borders;

                    points = [];
                    if (type === 'regular') {
                        points.push(input[0]);
                        points.push(input[1]);

                        for (i = input[2] + 1; i < output.length; i++) {
                            if (output[i].attributes) {
                                points.push(this.checkElement(output[i].getAttribute('label')));
                            } else {
                                points.push(output[i]);
                            }
                        }
                    } else {
                        for (i = 0; i < input.length; i++) {
                            if (typeof input[i] === 'object') {
                                points.push(input[i]);
                            }
                        }
                    }

                    if (type === 'regular') {
                        p = this.board.create('regularpolygon', points, attr);
                    } else {
                        p = this.board.create('polygon', points, attr);
                    }

                    for (i = 0; i < p.borders.length; i++) {
                        if (borderatts[i].withLabel) {
                            p.borders[i].createLabel();
                        }
                        p.borders[i].setAttribute(borderatts[i]);
                    }
                    return p;
                } catch (exc5) {
                    JXG.debug("* Err: Polygon " + attr.name);
                    return false;
                }
                break;
            case 'intersect':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* Intersection: First: " + input[0].name + ", Second: " + input[1].name);
                    if (!JXG.exists(attr.styleGGB)) {
                        attr.face = 'circle';
                        attr.fillColor = attr.strokeColor;
                        attr.fillOpacity = 1;
                        attr.highlightFillColor = attr.strokeColor;
                        attr.highlightFillOpacity = 1;
                        attr.strokeColor = 'black';
                        attr.strokeWidth = 1;
                    }

                    if (output.length === 1) {
                        p = this.board.create('intersection', [input[0], input[1], 0], attr);
                    } else {
                        p = this.board.create('intersection', [input[0], input[1], 1], attr);
                        attr2 = {};
                        attr2 = this.colorProperties(output[1], attr2);
                        attr2 = this.visualProperties(output[1], attr2);
                        attr2.name = output[1].getAttribute('label');
                        p2 = this.board.create('otherintersection', [input[0], input[1], p], attr2);
                        this.ggbElements[attr2.name] = p2;
                    }

                    return p;
                } catch (exc6) {
                    JXG.debug("* Err: Intersection " + attr.name);
                    return false;
                }
                break;
            case 'distance':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);


                try {
                    JXG.debug("* Distance: First: " + input[0].name + ", Second: " + input[1].name);

                    /*if (false && output[0].getAtribute('type') && output[0].getAttribute('type') == 'numeric') {
                        input[1].Value = function(){ return this.X(); };
                        p = input[1];
                        board.elementsByName[attr.name] = p;
                    } else {*/
                    m = this.board.create('midpoint', input, {visible: 'false'});
                    attr.visible = 'true';
                    p = this.board.create('text', [
                        function () {
                            return m.X();
                        },
                        function () {
                            return m.Y();
                        },
                        function () {
                            return "<span style='text-decoration: overline'>" + input[0].name + input[1].name + "</span> = " +
                                JXG.trimNumber(
                                    JXG.toFixed(
                                        that.board.select(input[0].id).Dist(that.board.select(input[1].id)),
                                        that.decimals
                                    )
                                );
                        }
                    ], attr);

                    p.Value = function () {
                        return (that.board.select(input[0].id).Dist(that.board.select(input[1].id)));
                    };

                    return p;
                } catch (exc7) {
                    JXG.debug("* Err: Distance " + attr.name);
                    return false;
                }
                break;
            case 'vector':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                if (element.getElementsByTagName("startPoint")[0]) {
                    if (input && input.length === 2) {
                        e = this.checkElement(input[1].name);
                    } else {
                        e = [parseFloat(element.getElementsByTagName("coords")[0].getAttribute("x")), parseFloat(element.getElementsByTagName("coords")[0].getAttribute("y"))];
                    }

                    if (element.getElementsByTagName("startPoint")[0].getAttribute("x") && element.getElementsByTagName("startPoint")[0].getAttribute("y")) {
                        s = [parseFloat(element.getElementsByTagName("startPoint")[0].getAttribute("x")), parseFloat(element.getElementsByTagName("startPoint")[0].getAttribute("y"))];
                    } else if (element.getElementsByTagName("startPoint")[0].getAttribute("exp")) {
                        startpoint = element.getElementsByTagName("startPoint")[0].getAttribute("exp");
                        s = this.checkElement(startpoint);
                    }
                } else if (input && input.length !== 0) {
                    s = input[0];
                    e = input[1];
                } else {
                    exp = this.getElement(element.getAttribute('label'), true);
                    if (exp) {// experimental
                        exp = exp.getAttribute('exp');
                        exp = this.ggbParse(exp);

                        // the input to these evals were verified by the parser unit above
                        /*jslint evil:true*/
                        if (JXG.isArray(exp)) {
                            exp = [new Function('return ' + exp[1] + ';'), new Function('return ' + exp[2] + ';')];
                        } else {
                            exp = new Function('return ' + exp + ';');
                        }
                        /*jslint evil:false*/

                        JXG.debug('exp: ' + exp);
                        p = this.board.create('arrow', [[0, 0], [exp[0], exp[1]]], attr);

                        return p;
                        // priorization of expression like 't*a' --> a := startPoint
                    }
                }

                try {
                    JXG.debug("* Vector: First: " + attr.name);
                    p = this.board.create('arrow', [s, e], attr);
                    return p;
                } catch (exc8) {
                    JXG.debug("* Err: Vector " + attr.name + e);
                    return false;
                }
                break;
            case 'rotate':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* Rotate: First: " + input[0].name + ", Second: " + input[1]);
                    attr.type = 'rotate';

                    if (!JXG.exists(attr.styleGGB)) {
                        attr.face = 'circle';
                        attr.fillColor = attr.strokeColor;
                        attr.fillOpacity = 1;
                        attr.highlightFillColor = attr.strokeColor;
                        attr.highlightFillOpacity = 1;
                        attr.strokeColor = 'black';
                        attr.strokeWidth = 1;
                    }

                    t = this.board.create('transform', [parseInt(input[1], 10) * Math.PI / 180, input[2]], {type: 'rotate'});
                    p = this.board.create('point', [input[0], t], attr);
                    return p;
                } catch (exc9) {
                    JXG.debug("* Err: Rotate " + attr.name);
                    return false;
                }
                break;
            case 'dilate':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* Dilate: First: " + input[0].name + ", Second: " + input[1]);
                    attr.type = 'rotate';
                    d = parseInt(input[1], 10);
                    d1 = this.board.create('transform', [d, d], {type: 'scale'});
                    d2 = this.board.create('transform', [
                        function () {
                            return (1 - d) * input[2].X();
                        },
                        function () {
                            return (1 - d) * input[2].Y();
                        }
                    ], {type: 'translate'});

                    if (!JXG.exists(attr.styleGGB)) {
                        attr.face = 'circle';
                        attr.fillColor = attr.strokeColor;
                        attr.fillOpacity = 1;
                        attr.highlightFillColor = attr.strokeColor;
                        attr.highlightFillOpacity = 1;
                        attr.strokeColor = 'black';
                        attr.strokeWidth = 1;
                    }
                    p = this.board.create('point', [input[0], [d1, d2]], attr);

                    return p;
                } catch (exc10) {
                    JXG.debug("* Err: Dilate " + attr.name);
                    return false;
                }
                break;
            case 'translate':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    t = this.board.create('transform', [
                        function () {
                            return input[1].point2.X() - input[1].point1.X();
                        },
                        function () {
                            return input[1].point2.Y() - input[1].point1.Y();
                        }
                    ], {type: 'translate'});

                    if (!JXG.exists(attr.styleGGB)) {
                        attr.face = 'circle';
                        attr.fillColor = attr.strokeColor;
                        attr.fillOpacity = 1;
                        attr.highlightFillColor = attr.strokeColor;
                        attr.highlightFillOpacity = 1;
                        attr.strokeColor = 'black';
                        attr.strokeWidth = 1;
                    }
                    p = this.board.create('point', [input[0], t], attr);
                    return p;
                } catch (exc11) {
                    JXG.debug("* Err: Translate " + attr.name);
                    return false;
                }
                break;
            case 'mirror':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                // Punktspiegelung
                if (JXG.isPoint(this.board.select(input[1].id))) {
                    type = 'mirrorpoint';
                // Achsenspiegelung
                } else if (this.board.select(input[1].id).elementClass === JXG.OBJECT_CLASS_LINE) {
                    type = 'reflection';
                }

                try {
                    JXG.debug("* Mirror: First: " + input[0].name + ", Second: " + input[1].name);
                    p = this.board.create(type, [input[1], input[0]], attr);
                    return p;
                } catch (exc12) {
                    JXG.debug("* Err: Mirror " + attr.name);
                    return false;
                }
                break;
            case 'circle':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* Circle: First: " + input[0].name + ", Second: " + input[1]);
                    p = this.board.create('circle', input, attr);
                    return p;
                } catch (exc13) {
                    JXG.debug("* Err: Circle " + attr.name);
                    return false;
                }
                break;
            case 'circlearc':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* CircleArc: First: " + input[0].name + ", Second: " + input[1].name + ", Third: " + input[2].name);
                    p = this.board.create('arc', input, attr);
                    return p;
                } catch (exc14) {
                    JXG.debug("* Err: CircleArc " + attr.name);
                    return false;
                }
                break;
            case 'ellipse':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* Ellipse: First: " + input[0].name + ", Second: " + input[1].name + ", Third: " + input[2]);

                    // if third parameters is the major axis, else the third parameter is a point
                    if (parseInt(input[2], 10) === input[2]) {
                        // Geogebra delivers the half major axis
                        input[2] = parseInt(input[2], 10) * 2;
                    }

                    p = this.board.create('ellipse', input, attr);
                    return p;
                } catch (exc15) {
                    JXG.debug("* Err: Ellipse " + attr.name);
                    return false;
                }
                break;
            case 'conic':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    if (input && input.length === 5) {
                        p = this.board.create('conic', input, attr);
                    } else if (element.getElementsByTagName('matrix')) {
                        m = [];
                        for (i = 0; i < element.getElementsByTagName('matrix')[0].attributes.length; i++) {
                            m[i] = parseFloat(element.getElementsByTagName('matrix')[0].attributes[i].value);
                        }
                        p = this.board.create('conic', m, attr);
                    }
                    return p;
                } catch (exc16) {
                    JXG.debug("* Err: Conic " + attr.name);
                    return false;
                }
                break;
            case 'circlesector':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);
                try {
                    JXG.debug("* CircleSector: First: " + input[0].name + ", Second: " + input[1].name + ", Third: " + input[2].name);
                    p = this.board.create('sector', [input[0], input[1], input[2]], attr);
                    return p;
                } catch (exc17) {
                    JXG.debug("* Err: CircleSector " + attr.name);
                    return false;
                }
                break;
            case 'linebisector':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* LineBiSector (Mittelsenkrechte): First: " + input[0].name);
                    m = this.board.create('midpoint', input, {visible: false});
                    if (JXG.isPoint(this.board.select(input[0].id)) &&
                            JXG.isPoint(this.board.select(input[1].id))) {
                        t = this.board.create('line', input, {visible: 'false'});
                        p = this.board.create('perpendicular', [m, t], attr);
                    } else {
                        p = this.board.create('perpendicular', [m, input[0]], attr);
                    }
                    return p;
                } catch (exc18) {
                    JXG.debug("* Err: LineBiSector (Mittelsenkrechte) " + attr.name);
                    return false;
                }
                break;
            case 'ray':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* Ray: First: " + input[0].name);
                    attr.straightFirst = true;
                    attr.straightLast =  false;
                    p = this.board.create('line', [input[1], input[0]], attr);
                    return p;
                } catch (exc19) {
                    JXG.debug("* Err: Ray " + attr.name);
                    return false;
                }
                break;
            case 'tangent':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* Tangent: First: " + input[0].name + ", Sec.: " + input[1].name + "(" + input[1].type + ")");
                    switch (input[1].type) {
                    // graph
                    case 1330923344:
                        input[0].makeGlider(input[1]);
                        p = this.board.create('tangent', [input[0]], attr);
                        return p;
                    // circle 0x4F54434C
                    case 1330922316:
                    // conic 0x4F54434F
                    case 1330922319:
                        pol = this.board.create('polar', [input[1], input[0]], {visible: false});
                        i1 = this.board.create('intersection', [input[1], pol, 0], {visible: false});
                        i2 = this.board.create('intersection', [input[1], pol, 1], {visible: false});
                        t1 = this.board.create('line', [input[0], i1], attr);
                        attr2 = {};
                        attr2 = this.colorProperties(output[1], attr2);
                        attr2 = this.visualProperties(output[1], attr2);
                        attr2.name = output[1].getAttribute('label');
                        t2 = this.board.create('line', [input[0], i2], attr2);
                        this.ggbElements[attr2.name] = t2;
                        return [t1, t2];
                    }
                } catch (exc20) {
                    JXG.debug("* Err: Tangent " + attr.name + " " + attr2.name);
                    return false;
                }
                break;
            case 'circumcirclearc':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* CircumcircleArc: First: " + input[0].name);
                    p = this.board.create('circumcirclearc', input, attr);
                    return p;
                } catch (exc21) {
                    JXG.debug("* Err: CircumcircleArc " + attr.name);
                    return false;
                }
                break;
            case 'circumcirclesector':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* CircumcircleSector: First: " + input[0].name);
                    p = this.board.create('circumcirclesector', [input[0], input[1], input[2]], attr);
                    return p;
                } catch (exc22) {
                    JXG.debug("* Err: CircumcircleSector " + attr.name);
                    return false;
                }
                break;
            case 'semicircle':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* Semicircle: First: " + input[0].name);
                    p = this.board.create('semicircle', [input[0], input[1]], attr);
                    return p;
                } catch (exc23) {
                    JXG.debug("* Err: Semicircle " + attr.name);
                    return false;
                }
                break;
            case 'angle':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* Angle: First: " + input[0].name);
                    p = this.board.create('angle', input, attr);
                    return p;
                } catch (exc24) {
                    JXG.debug("* Err: Angle " + attr.name);
                    return false;
                }
                break;
            case 'angularbisector':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);
                attr.straightFirst = true;
                attr.straightLast = true;

                try {
                    JXG.debug("* Angularbisector: First: " + input[0].name);
                    p = this.board.create('bisector', input, attr);
                    return p;
                } catch (exc25) {
                    JXG.debug("* Err: Angularbisector " + attr.name);
                    return false;
                }
                break;
            case 'numeric':
                if (element.getElementsByTagName('slider').length === 0) {
                    // auxiliary doesn't exist in every numeric
                    //element.getElementsByTagName('auxiliary').length != 0 && element.getElementsByTagName('auxiliary')[0].attributes['val'].value == 'true') {
                    exp = this.getElement(element.getAttribute('label'), true);

                    if (exp) {
                        exp = exp.getAttribute('exp');
                        exp = this.functionParse('', exp);
                        exp = this.ggbParse(exp);
                    }

                    // exp was validated by ggbParse
                    /*jslint evil:true*/
                    this.board.ggb[attr.name] = new Function('return ' + exp + ';');
                    /*jslint evil:false*/

                    JXG.debug('value: ' + this.board.ggb[attr.name]());
                    return this.board.ggb[attr.name];
                }
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                attr = this.visualProperties(element, attr);

                // it's a slider
                if (element.getElementsByTagName('slider').length === 1) {
                    sx = parseFloat(element.getElementsByTagName('slider')[0].getAttribute('x'));
                    sy = parseFloat(element.getElementsByTagName('slider')[0].getAttribute('y'));
                    length = parseFloat(element.getElementsByTagName('slider')[0].getAttribute('width'));
                    // are coordinates absolut?
                    if (element.getElementsByTagName('slider')[0].getAttribute('absoluteScreenLocation') && element.getElementsByTagName('slider')[0].getAttribute('absoluteScreenLocation') === 'true') {
                        tmp = new JXG.Coords(JXG.COORDS_BY_SCREEN, [sx, sy], this.board);
                        sx = tmp.usrCoords[1];
                        sy = tmp.usrCoords[2];
                    }

                    if (element.getElementsByTagName('slider')[0].getAttribute('horizontal') === 'true') {
                        if (element.getElementsByTagName('slider')[0].getAttribute('absoluteScreenLocation') && element.getElementsByTagName('slider')[0].getAttribute('absoluteScreenLocation') === 'true') {
                            length /= (this.board.unitX);
                        }
                        ex = sx + length;
                        ey = sy;
                    } else {
                        if (element.getElementsByTagName('slider')[0].getAttribute('absoluteScreenLocation') && element.getElementsByTagName('slider')[0].getAttribute('absoluteScreenLocation') === 'true') {
                            length /= (this.board.unitY);
                        }
                        ex = sx;
                        ey = sy + length;
                    }

                    if (element.getElementsByTagName('animation')[0]) {
                        attr.snapWidth = parseFloat(element.getElementsByTagName('animation')[0].getAttribute('step'));
                    }

                    try {
                        JXG.debug("* Numeric: First: " + attr.name);
                        attr.withTicks = false;
                        p = this.board.create('slider', [[sx, sy], [ex, ey], [
                            parseFloat(element.getElementsByTagName('slider')[0].getAttribute('min')),
                            parseFloat(element.getElementsByTagName('value')[0].getAttribute('val')),
                            parseFloat(element.getElementsByTagName('slider')[0].getAttribute('max'))
                        ]], attr);
                        return p;
                    } catch (exc26) {
                        JXG.debug("* Err: Numeric " + attr.name);
                        return false;
                    }
                }
                break;
            case 'midpoint':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    if (!JXG.exists(attr.styleGGB)) {
                        attr.face = 'circle';
                        attr.fillColor = attr.strokeColor;
                        attr.fillOpacity = 1;
                        attr.highlightFillColor = attr.strokeColor;
                        attr.highlightFillOpacity = 1;
                        attr.strokeColor = 'black';
                        attr.strokeWidth = 1;
                    }
                    p = this.board.create('midpoint', input, attr);
                    JXG.debug("* Midpoint (" + p.id + "): " + attr.name + "(" + gxtEl.x + ", " + gxtEl.y + ")");
                    return p;
                } catch (exc27) {
                    JXG.debug("* Err: Midpoint " + attr.name);
                    return false;
                }
                break;
            case 'center':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);
                try {
                    if (!JXG.exists(attr.styleGGB)) {
                        attr.face = 'circle';
                        attr.fillColor = attr.strokeColor;
                        attr.fillOpacity = 1;
                        attr.highlightFillColor = attr.strokeColor;
                        attr.highlightFillOpacity = 1;
                        attr.strokeColor = 'black';
                        attr.strokeWidth = 1;
                    }
                    p = this.board.create('point', [
                        function () {
                            return that.board.select(input[0].id).center.X();
                        },
                        function () {
                            return that.board.select(input[0].id).center.Y();
                        }
                    ], attr);
                    JXG.debug("* Center (" + p.id + "): " + attr.name + "(" + gxtEl.x + ", " + gxtEl.y + ")");
                    return p;
                } catch (exc28) {
                    JXG.debug("* Err: Center " + attr.name);
                    return false;
                }
                break;
            case 'function':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                if (this.getElement(attr.name, true)) {
                    func = this.getElement(attr.name, true).getAttribute('exp');
                    func = this.functionParse('c', func);
                } else {
                    func = input[0];
                    func = this.functionParse('s', func);
                }

                JXG.debug(func);

                length = func.length;
                func[func.length - 1] = 'return ' + this.ggbParse(func[func.length - 1]) + ';';

                JXG.debug(func);

                range = [(input && input[1]) ? input[1] : null, (input && input[2]) ? input[2] : null];

                // fix the range input. This might by x(<point>) or y(point) but JSXGraph only allows X(<point>)
                // and Y(point) so we need to convert this.
                rx = /([x|y])\((\w+)\)/;
                for (i = 0; i < 2; i++) {
                    match = rx.exec(range[i]);
                    if (match) {
                        range[i] = match[1].toUpperCase() + '(' + match[2] + ')';
                    }
                }

                // all validated by ggbParse and functionParse
                try {
                    /*jslint evil:true*/
                    if (length === 1) {
                        p = this.board.create('functiongraph', [new Function(func[0]), range[0], range[1]], attr);
                    } else if (length === 2) {
                        p = this.board.create('functiongraph', [new Function(func[0], func[1]), range[0], range[1]], attr);
                    } else if (length === 3) {
                        p = this.board.create('functiongraph', [new Function(func[0], func[1], func[2]), range[0], range[1]], attr);
                    } else if (length === 4) {
                        p = this.board.create('functiongraph', [new Function(func[0], func[1], func[2], func[3]), range[0], range[1]], attr);
                    } else if (length === 5) {
                        p = this.board.create('functiongraph', [new Function(func[0], func[1], func[2], func[3], func[4]), range[0], range[1]], attr);
                    }
                    /*jslint evil:false*/

                    return p;
                } catch (exc29) {
                    JXG.debug("* Err: Functiongraph " + attr.name);
                    return false;
                }

                break;
            case 'polar':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* Polar: First: " + input[0].name + ", Sec.: " + input[1].name);
                    p = this.board.create('polar', input, attr);
                    return p;
                } catch (exc30) {
                    JXG.debug("* Err: Polar " + attr.name);
                    return false;
                }
                break;
            case 'slope':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* Slope (" + attr.name + "): First: " + input[0].name);

                    slopeWidth = parseInt(attr.slopeWidth, 10) || 1;
                    p1 = input[0].glider || input[0].point1;

                    p2 = this.board.create('point', [
                        function () {
                            return (slopeWidth + p1.X());
                        },
                        function () {
                            return p1.Y();
                        }
                    ], {visible: false});

                    l1 = this.board.create('segment', [p1, p2], {visible: false});
                    l2 = this.board.create('normal', [l1, l1.point2], {visible: false});
                    i = this.board.create('intersection', [input[0], l2, 0], {visible: false});
                    m = this.board.create('midpoint', [l1.point2, i], {visible: false});

                    t = this.board.create('text', [
                        function () {
                            return m.X();
                        },
                        function () {
                            return m.Y();
                        },
                        function () {
                            return "&nbsp;&nbsp;" + (slopeWidth > 1 ? slopeWidth.toString() : '') + ' ' + this.name + ' = ' + JXG.trimNumber(
                                JXG.toFixed(slopeWidth * input[0].getSlope(), that.decimals)
                            );
                        }
                    ], attr);
                    attr.name = '';
                    t2 = this.board.create('text', [
                        function () {
                            return (p1.X() + p2.X()) / 2;
                        },
                        function () {
                            return p1.Y();
                        },
                        function () {
                            return '<br/>' + slopeWidth;
                        }
                    ], attr);
                    t.Value = (function () {
                        return function () {
                            return input[0].getSlope();
                        };
                    }());
                    poly = this.board.create('polygon', [p1, p2, i], attr);

                    poly.borders[2].setAttribute({visible: false});
                    poly.borders[0].setAttribute({strokeColor: attr.fillColor, strokeWidth: attr.strokeWidth, highlightStrokeColor: attr.fillColor, dash: attr.dash});
                    poly.borders[1].setAttribute({strokeColor: attr.fillColor, strokeWidth: attr.strokeWidth, highlightStrokeColor: attr.fillColor, dash: attr.dash});
                    return t;
                } catch (exc31) {
                    JXG.debug("* Err: Slope " + attr.name);
                    return false;
                }
                break;
            case 'text':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);
                res = '';

                try {
                    /*jslint regexp:true*/
                    if (element.getElementsByTagName('isLaTeX')[0] && element.getElementsByTagName('isLaTeX')[0].getAttribute('val') === 'true') {
                        this.board.options.text.useASCIIMathML = true;
                        t = this.getElement(attr.name, true).getAttribute('exp');

                        // here we're searching for patterns like
                        //    " + ... + "
                        // ... will be sent to the ggbParser and a calculated text element is built from this.
                        rx = t.match(/(.*?)" \+ (.+) \+ "(.*)/);
                        while (rx) {
                            re2 = this.ggbParse(RegExp.$2);
                            if (typeof re2 === 'string') {
                                res = res + RegExp.$1 + re2;
                            } else {
                                res = res + RegExp.$1 + '" + JXG.trimNumber(JXG.toFixed(' + re2 + ', ' + this.decimals + ')) + "';
                            }
                            t = RegExp.$3;

                            rx = t.match(/(.*?)" \+ (.+) \+ "(.*)/);
                        }

                        // we have to look, if the string's ending with a string-part or a formula part:
                        rx = t.match(/(.*?)" \+ (.+)/);
                        if (rx) {
                            res = res + RegExp.$1 + '" + JXG.trimNumber(JXG.toFixed(' + this.ggbParse(RegExp.$2) + ', ' + this.decimals + '))';
                        } else {
                            res = res + t;
                        }

                        JXG.debug("Text: " + res);

                        // res is verified by ggbParse
                        /*jslint evil:true*/
                        p = this.board.create('text', [gxtEl.x, gxtEl.y, new Function('return ' + res + ';')], attr);
                        /*jslint evil:false, regexp:false*/
                    } else {
                        JXG.debug(this.getElement(attr.name, true).getAttribute('exp'));
                        t = this.functionParse(false, this.getElement(attr.name, true).getAttribute('exp'));
                        t = this.ggbParse(t);
                        JXG.debug(t[1]);

                        if (JXG.isArray(t)) {
                            // input string is verified by ggbParse
                            /*jslint evil:true*/
                            p = this.board.create('text', [gxtEl.x, gxtEl.y, new Function('return ' + t[0] + ' + " " + JXG.trimNumber(JXG.toFixed(parseFloat(' + t[1] + ', ' + this.decimals + '));') ], attr);
                            /*jslint evil:false*/
                        } else {
                            p = this.board.create('text', [gxtEl.x, gxtEl.y, t], attr);
                        }
                    }
                    JXG.debug("* Text: " + t);
                    return p;
                } catch (exc32) {
                    JXG.debug("* Err: Text: " + t, exc32, exc32.stack);
                    return false;
                }
                break;
            case 'root':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                for (i = 0; i < output.length; i++) {
                    output[i] = this.checkElement(output[i].getAttribute('label'));
                }

                if (JXG.isArray(input)) {
                    inp = input[0];
                } else {
                    inp = input;
                }

                // At this point, the output points already exist.
                // Bind the root function to all output elements.
                // The start values for all output elements are the x-coordinates as given
                // in the ggb file.
                for (i = 0; i < output.length; i++) {
                    output[i].addConstraint([
                        makeRootFun(output[i].X()),
                        makeConstFun(0)
                    ]);
                }
                // What to return here????
                return output;
            case 'integral':
                attr = this.boardProperties(gxtEl, element, attr);
                attr = this.colorProperties(element, attr);
                gxtEl = this.coordinates(gxtEl, element);
                attr = this.visualProperties(element, attr);

                try {
                    JXG.debug("* Integral: First: " + input[0].name + ", Sec.: " + input[1].name + ", Thir.: " + input[2].name);
                    JXG.debug([input[1](), input[2]()]);
                    p = this.board.create('integral', [this.board.select(input[0]), [input[1], input[2]]], attr);
                    return p;
                } catch (exc33) {
                    JXG.debug("* Err: Integral " + attr.name + e);
                    return false;
                }
                break;

//    case 'transform':
//    break;
//    case 'radius':
//    break;
//    case 'derivative':
//    break;
//    case 'root':
//    break;
//    case 'corner':
//    break;
//    case 'unitvector':
//    break;
//    case 'extremum':
//    break;
//    case 'turningpoint':
//    break;
//    case 'arc':
//    break;
//    case 'circlepart':
//    break;
//    case 'uppersum':
//    break;
//    case 'lowersum':
//    break;
//    case 'image':
//    break;
            default:
                return false;
            }
        },

        /**
         * Reading the elements of a geogebra file
         */
        read: function () {
            var type, constructions, el, Data, i, t, s, expr, cmds, input, output, elname, elements;

            this.writeBoard();

            // board won't be overwritten, setDefaultOptions returns the board reference given to it.
            this.setDefaultOptions();

            // speeding up the drawing process
            //this.board.suspendUpdate();

            constructions = this.tree.getElementsByTagName("construction");
            for (t = 0; t < constructions.length; t++) {

                cmds = constructions[t].getElementsByTagName("command");
                for (s = 0; s < cmds.length; s++) {
                    Data = cmds[s];

                    JXG.debug('now i\'ll parse the command:');
                    JXG.debug(Data);

                    input = [];
                    for (i = 0; i < Data.getElementsByTagName("input")[0].attributes.length; i++) {
                        el = Data.getElementsByTagName("input")[0].attributes[i].value;
                        if (el.match(/\u00B0/) || !el.match(/\D/) || el.match(/Circle/) || Data.getAttribute('name') === 'Function' || el === parseFloat(el)) {
                            input[i] = el;
                        } else if (el === 'xAxis' || el === 'yAxis') {
                            input[i] = this.ggbElements[el];
                        } else {
                            input[i] = this.checkElement(el);
                        }
                    }

                    output = [];
                    elname = Data.getElementsByTagName("output")[0].attributes[0].value;

                    for (i = 0; i < Data.getElementsByTagName("output")[0].attributes.length; i++) {
                        el = Data.getElementsByTagName("output")[0].attributes[i].value;
                        output[i] = this.getElement(el);
                    }

                    if (!JXG.exists(this.ggbElements[elname]) || this.ggbElements[elname] === '') {
                        this.ggbElements[elname] = this.writeElement(output, input, Data.getAttribute('name').toLowerCase());

                        /* register borders to according "parent" */
                        if (this.ggbElements[elname].borders) {
                            for (i = 0; i < this.ggbElements[elname].borders.length; i++) {
                                this.ggbElements[this.ggbElements[elname].borders[i].name] = this.ggbElements[elname].borders[i];
                            }
                        }
                    }
                }

                JXG.debug('Restesammler: ');
                // create "single" elements which do not depend on any other
                elements = constructions[t].getElementsByTagName("element");
                for (s = 0; s < elements.length; s++) {
                    Data = elements[s];
                    el = Data.getAttribute('label');

                    if (!JXG.exists(this.ggbElements[el]) || this.ggbElements === '') {
                        this.ggbElements[el] = this.writeElement(Data);

                        expr = this.getElement(el, true);
                        if (expr) {
                            type = Data.getAttribute('type');

                            switch (type) {
                            case 'text':
                            case 'function':
                                // this.ggbElements[el] = this.writeElement(this.ggbElements, this.board, expr, false, type);
                                break;
                            default:
                                this.ggbParse(expr.getAttribute('exp'), el);
                                break;
                            }
                        }

                    }
                }

            } // end: for construction

            // speeding up the drawing process
            this.board.unsuspendUpdate();
            this.board.fullUpdate();
        },

        /**
         * Clean the utf8-symbols in a Geogebra expression in JavaScript syntax
         * @param {String} exp string to clean
         * @returns {String} replaced string
         */
        utf8replace: function (exp) {
            exp = exp.replace(/\u03C0/g, 'PI')
                .replace(/\u00B2/g, '^2')
                .replace(/\u00B3/g, '^3')
                .replace(/\u225F/g, '==')
                .replace(/\u2260/g, '!=')
                .replace(/\u2264/g, '<=')
                .replace(/\u2265/g, '>=')
                .replace(/\u2227/g, '&&')
                .replace(/\u2228/g, '//');

            return exp;
        },

        /**
         * Extracting the packed geogebra file in order to return the "blank" xml-tree for further parsing.
         * @param {String} fileStr archive containing geogebra.xml-file or raw input string (eg. xml-tree)
         * @returns {String} content of geogebra.xml-file if an archive was passed in
         */
        prepareString: function (fileStr) {
            var i, bA, len, fstr,
                isString = fileStr.slice(0, 2) !== "PK";

            // here we have to deal with two different base64 encoded streams
            // first one: base64 encoded xml (geogebra's web export)
            // second one: base64 encoded ggb file, this is our recommendation for an IE & Opera
            // workaround, which can't deal with binary data transferred via AJAX.

            if (isString && fileStr.indexOf('<') !== 0) {
                // first try to decode assuming we got a base64 encoded ggb file
                fstr = JXG.Util.Base64.decode(fileStr);

                if (fstr.slice(0, 2) !== "PK") {
                    // ooops, that was no ggb file. try again with utf8 parameter set.
                    fstr = JXG.Util.Base64.decode(fileStr, true);
                }
                fileStr = fstr;
            }

            if (fileStr.indexOf('<') !== 0) {
                bA = [];
                len = fileStr.length;
                for (i = 0; i < len; i++) {
                    bA[i] = JXG.Util.UTF8.asciiCharCodeAt(fileStr, i);
                }

                // Unzip
                fileStr = (new JXG.Util.Unzip(bA)).unzipFile("geogebra.xml");
            }
            fileStr = JXG.Util.UTF8.decode(fileStr);
            fileStr = this.utf8replace(fileStr);

            return fileStr;
        },

        /**
         * Checking if a parameter is a Geogebra vector (array with length 3)
         * @param {Object} v possible Geogebra vector
         * @returns {Boolean}
         */
        isGGBVector: function (v) {
            return JXG.isArray(v) && v.length === 3 && v[0] === 1;
        }
    });

    JXG.registerReader(JXG.GeogebraReader, ['ggb', 'geogebra']);
}());
