JXG.GeogebraReader = new function() {
/**
 * @param {String} type the type of expression
 * @param {String} m first input value
 * @param {String} n second input value
 * @return {String} return the object, string or calculated value
 */
this.ggbAct = function(type, m, n) {
  var v1 = m, v2 = n, s1, s2, a;
  switch(type.toLowerCase()) {
    case 'end':
      // JXG.debug("<b>end: </b>"+ v1);
      return v1;
    break;
    case 'coord':
      s1 = (JXG.GeogebraReader.board.ggbElements[v1]) ? 'JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'")' : v1;
      s2 = (JXG.GeogebraReader.board.ggbElements[v2]) ? 'JXG.getReference(JXG.GeogebraReader.board, "'+ v2 +'")' : v2;
      return [s1, s2];
    break;
    case 'le': // smaller then
      return '( ('+ v1 +') <= ('+ v2 +') )';
    break;
    case 'ge': // greater then
      return '( ('+ v1 +') >= ('+ v2 +') )';
    break;
    case 'eq': // equal
      return '( ('+ v1 +') == ('+ v2 +') )';
    break;
    case 'neq': // not equal
      return '( ('+ v1 +') != ('+ v2 +') )';
    break;
    case 'lt': // smaller
      return '( ('+ v1 +') < ('+ v2 +') )';
    break;
    case 'gt': // greater
      return '( ('+ v1 +') > ('+ v2 +') )';
    break;
    case 'add':
    	if (JXG.GeogebraReader.isGGBVector(v1) && JXG.GeogebraReader.isGGBVector(v2)){ //Add: Vector + Vector
    		return [1, v1[1] + '+' + v2[1], v1[2] + '+' + v2[2]];
    	}
      if( JXG.isString(v1) && !v1.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v1.match(/JXG\.getReference/) ) {
        s1 = [v1+'.X()', v1+'.Y()'];
      } else {
        s1 = v1;
      }

      if( JXG.isString(v2) && !v2.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v2.match(/JXG\.getReference/) ) {
        s2 = [v2+'.X()', v2+'.Y()'];
      } else {
        s2 = v2;
      }

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

      if (JXG.GeogebraReader.isGGBVector(s2) && JXG.isArray(s1)){ //Add: Vector + Point
    	  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] ];
      }
      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
        return s1 +' + '+ s2;
      }
      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && JXG.isArray(s2) ) {
        return [ s1 +' + '+ s2[0], s1 +' + '+ s2[1] ];
      }
      else if( JXG.isArray(s1) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
        return [ s1[0] +' + '+ s2, s1[1] +' + '+ s2 ];
      }
      else {
        return s1 +' + '+ s2;
      }
    break;
    case 'sub':
    	if (JXG.GeogebraReader.isGGBVector(v1) && JXG.GeogebraReader.isGGBVector(v2)){ //Sub: Vector - Vector
    		return [1, v1[1] + '-' + v2[1], v1[2] + '-' + v2[2]];
    	}

      if( JXG.isString(v1) && !v1.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v1.match(/JXG\.getReference/) ) {
        s1 = [v1+'.X()', v1+'.Y()'];
      } else {
        s1 = v1;
      }

      if( JXG.isString(v2) && !v2.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v2.match(/JXG\.getReference/) ) {
        s2 = [v2+'.X()', v2+'.Y()'];
      } else {
        s2 = v2;
      }

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

      if (JXG.isArray(s1) && JXG.GeogebraReader.isGGBVector(s2)){ //Add: Punkt - Vector
    	  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] ];
      }
      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
        return s1 +' - '+ s2;
      }
      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && JXG.isArray(s2) ) {
        return [ s1 +' - '+ s2[0], s1 +' - '+ s2[1] ];
      }
      else if( JXG.isArray(s1) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
        return [ s1[0] +' - '+ s2, s1[1] +' - '+ s2 ];
      }
      else {
        return s1 +' - '+ s2;
      }
    break;
    case 'neg':
      return '!('+ v1 +')';
    break;
    case 'pow':
      return 'Math.pow('+ v1 +', '+ v2 +')';
    break;
    case 'or':
      return '('+ v1 +'||'+ v2 +')';
    break;
    case 'and':
      return '('+ v1 +'&&'+ v2 +')';
    break;
    case 'mul':
    	if (JXG.GeogebraReader.isGGBVector(v1) && !JXG.isArray(v2)){ // Mult: Vector * Skalar
    		return [1,'(' + v1[1] + ')*'+v2,'(' + v1[2] + ')*'+v2];
    	} else if (!JXG.isArray(v1) && JXG.GeogebraReader.isGGBVector(v2)){ // Mult: Skalar * Vector
    		return new Array(1,'(' + v2[1] + ')*'+v1,'(' + v2[2] + ')*'+v1);
    	} else if (JXG.GeogebraReader.isGGBVector(v1) && JXG.GeogebraReader.isGGBVector(v2)){ //Mult: Vector * Vector
    		return '((' + v1[1] + ')*('+v2[1]+')+('+ v1[2] + ')*('+v2[2]+'))';
    	} else { // Rest
      if( JXG.isString(v1) && !v1.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v1.match(/JXG\.getReference/) ) {
		        s1 = [v1+'.X()', v1+'.Y()'];
		      } else {
		    	s1 = v1;
		      }

      		if( JXG.isString(v2) && !v2.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v2.match(/JXG\.getReference/) ) {
		        s2 = [v2+'.X()', v2+'.Y()'];
		      } else {
		        s2 = v2;
		      }

		      if( JXG.isArray(s1) && JXG.isArray(s2) ) {
		        return [ s1[0] +' * '+ s2[0], s1[1] +' * '+ s2[1] ];
		      }
		      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
		        return s1 +' * '+ s2;
		      }
		      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && JXG.isArray(s2) ) {
		        return [ s1 +' * '+ s2[0], s1 +' * '+ s2[1] ];
		      }
		      else if( JXG.isArray(s1) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
		        return [ s1[0] +' * '+ s2, s1[1] +' * '+ s2 ];
		      }
		      else {
		        return s1 +' * '+ s2;
		      }
    	}
    break;
    case 'div':
      if( JXG.isString(v1) && !v1.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v1.match(/JXG\.getReference/) ) {
        s1 = [v1+'.X()', v1+'.Y()'];
      } else {
        s1 = v1;
      }

      if( JXG.isString(v2) && !v2.match(/JXG\.getReference\(JXG\.GeogebraReader\.board, "(.+?)"\)\./) && v2.match(/JXG\.getReference/) ) {
        s2 = [v2+'.X()', v2+'.Y()'];
      } else {
        s2 = v2;
      }

      if( JXG.isArray(s1) && JXG.isArray(s2) ) {
        return [ s1[0] +' / '+ s2[0], s1[1] +' / '+ s2[1] ];
      }
      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
        return s1 +' / '+ s2;
      }
      else if( (JXG.isNumber(s1) || JXG.isString(s1)) && JXG.isArray(s2) ) {
        return [ s1 +' / '+ s2[0], s1 +' / '+ s2[1] ];
      }
      else if( JXG.isArray(s1) && (JXG.isNumber(s2) || JXG.isString(s2)) ) {
        return [ s1[0] +' / '+ s2, s1[1] +' / '+ s2 ];
      }
      else {
        return s1 +' / '+ s2;
      }
    break;
    case 'negmult':
    	if (JXG.GeogebraReader.isGGBVector(v1))
    		return new Array(1, -1 + '*' + v1[1],-1 + '*' + v1[2]);
      return -1 +'*'+ v1;
    break;
    case 'bra':
    	if (JXG.GeogebraReader.isGGBVector(v1))
    		return new Array(1,'(' + v1[1] + ')','(' + v1[2] + ')');
      return '('+ v1 +')';
    break;
    case 'int':
      return parseInt(v1);
    break;
    case 'float':
      return parseFloat(v1);
    break;
    case 'param':
      return v1;
    break;
    case 'html':
      return v1;
    break;
    case 'string':
      if(v2) return [v1, v2];
      else   return v1;
    break;
    case 'command':
      v2 = v1.split('[');
      s1 = v2[0];
      s2 = (v2[1].split(']'))[0];
      switch(s1.toLowerCase()) {
        case 'name':
          return 'JXG.getReference(JXG.GeogebraReader.board, "'+ s2 +'").getName()'; //TODO korrigiere getName()
        break;
      }
    break;
    case 'var':
      if(v2) {
        switch(v1.toLowerCase()) {
            case 'x':
                return v2 +'.X()';
            break;
            case 'y':
                return v2 +'.Y()';
            break;
            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 +')';
            break;
            default:
                return v1.toLowerCase()+'*('+ v2 +')';
            break;
        }
      } else {

        if(v1 == 'PI') {
          return 'Math.PI';
        } else {
          a = JXG.GeogebraReader.checkElement(v1);
          if(typeof JXG.GeogebraReader.board.ggb[v1] != 'undefined') {
            return 'JXG.GeogebraReader.board.ggb["'+ v1 +'"]()';
          } else if(typeof a.Value != 'undefined') {
            return 'JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").Value()';
          } else if(typeof a.Area != 'undefined') {
            return 'JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").Area()';
          } else if(typeof a.plaintextStr != 'undefined') {
            return '1.0*JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").plaintextStr';
          } else if (a.type == JXG.OBJECT_TYPE_VECTOR){
            return new Array(1, 'JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").point2.X()-JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").point1.X()','JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").point2.Y()-JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").point1.Y()');
          }else if(a.elementClass == JXG.OBJECT_CLASS_LINE) {
            return 'JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").point1.Dist(JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'").point2)';
          } else {
            return 'JXG.getReference(JXG.GeogebraReader.board, "'+ v1 +'")';
          }
        }
      }
    break;
  }
};

/**
 * JS/CC parser to convert the input expression to a working javascript function.
 * @param {Object} board object
 * @param {Object} element Element that needs to be updated
 * @param {String} exp String which contains the function, expression or information
 */
this.ggbParse = function(exp, element) {
  var element = (element) ? JXG.getReference(JXG.GeogebraReader.board, JXG.GeogebraReader.board.ggbElements[element].id) : false;
  if(element) JXG.debug("Zu aktualisierendes 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 *****/
	var _dbg_withtrace		= false;
	var _dbg_string			= new String();

	function __dbg_print( text ) {
		_dbg_string += text + "\n";
	}

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

		do
		{
			pos--;
			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++;

			}
			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 = new String();
			match = -1;
		}

		return match;
	}


	function __parse( src, err_off, err_la ) {
		var		sstack			= new Array();
		var		vstack			= new Array();
		var 	err_cnt			= 0;
		var		act;
		var		go;
		var		la;
		var		rval;
		var 	parseinfo		= new Function( "", "var offset; var src; var att;" );
		var		info			= new parseinfo();

	/* Pop-Table */
	var pop_tab = new Array(
		new Array( 0/* p' */, 1 ),
		new Array( 27/* p */, 1 ),
		new Array( 26/* e */, 5 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 2 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 2 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 3 ),
		new Array( 26/* e */, 1 ),
		new Array( 26/* e */, 1 ),
		new Array( 26/* e */, 1 ),
		new Array( 26/* e */, 1 ),
		new Array( 26/* e */, 1 ),
		new Array( 26/* e */, 1 ),
		new Array( 26/* e */, 4 ),
		new Array( 26/* e */, 1 )
	);

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



	/* Symbol labels */
	var labels = new Array(
		"p'" /* Non-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 */,
		"&&" /* Terminal symbol */,
		"e" /* Non-terminal symbol */,
		"p" /* Non-terminal symbol */,
		"$" /* Terminal symbol */
	);



		info.offset = 0;
		info.src = src;
		info.att = new String();

		if( !err_off )
			err_off	= new Array();
		if( !err_la )
		err_la = new Array();

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

		la = __lex( info );

		while( true )
		{
			act = 52;
			for( var 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++;
				err_off.push( info.offset - info.att.length );			
				err_la.push( new Array() );
				for( var 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!
				var rsstack = new Array();
				var rvstack = new Array();
				for( var 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++;

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

						if( sstack.length == 0 )
							break;

						act = 52;
						for( var 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( var 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" );
			}

			/*
			if( act == 52 )
				break;
			*/


			//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 = void(0);

				if( _dbg_withtrace )
					__dbg_print( "\tPerforming semantic action..." );

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



				if( _dbg_withtrace )
					__dbg_print( "\tPopping " + pop_tab[act][1] + " off the stack..." );

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

				go = -1;
				for( var 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 = new String();
			}
		}

		if( _dbg_withtrace )
		{
			__dbg_print( "\nParse complete." );
			JXG.debug( _dbg_string );
		}

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

  var error_offsets = new Array();
  var error_lookaheads = new Array();
  var error_count = 0;
  var str = exp;
  if( ( error_count = __parse( str, error_offsets, error_lookaheads ) ) > 0 ) {
    var errstr = new String();
    for( var 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;
}; //end: ggbParse()


/**
 * Override JSxGraph defaults with Geogebra settings
 * @param {Object} board object
 * @return {Object} board oject
 */
this.setDefaultOptions = function(board){
  board.options.elements.strokeWidth = '1px'; // TODO: board.options.line.strokeWidth
  board.options.elements.withLabel = true;

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

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

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

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

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

  return board;
};

/**
 * Set color properties of a geogebra element.
 * Set stroke, fill, lighting, label and draft color attributes.
 * @param {Object} gxtEl element of which attributes are to set
 * @param {Object} attr object carrying all necessary attribute values
 * @return {Object} returning the updated attr-attributes object
 */
this.colorProperties = function(Data, attr) {
  var a,r,g,b;
  a = (Data.getElementsByTagName("objColor").length > 0 && Data.getElementsByTagName("objColor")[0].getAttribute("alpha")) ? parseFloat(Data.getElementsByTagName("objColor")[0].getAttribute("alpha")) : 0;
  r = (Data.getElementsByTagName("objColor").length > 0 && Data.getElementsByTagName("objColor")[0].getAttribute("r")) ? parseInt(Data.getElementsByTagName("objColor")[0].getAttribute("r")).toString(16) : 0;
  g = (Data.getElementsByTagName("objColor").length > 0 && Data.getElementsByTagName("objColor")[0].getAttribute("g")) ? parseInt(Data.getElementsByTagName("objColor")[0].getAttribute("g")).toString(16) : 0;
  b = (Data.getElementsByTagName("objColor").length > 0 && Data.getElementsByTagName("objColor")[0].getAttribute("b")) ? parseInt(Data.getElementsByTagName("objColor")[0].getAttribute("b")).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
 */
this.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
 * @return {Object} updated element
 */
this.coordinates = function(gxtEl, Data) {
  var labelOffset = {}, tmp;
  labelOffset.x = 0; labelOffset.y = 0; labelOffset.z = 0;

  if(Data.getElementsByTagName('labelOffset')[0]) {
    // tmp = new JXG.Coords(JXG.COORDS_BY_SCREEN, [,
    //                                             parseFloat(Data.getElementsByTagName("labelOffset")[0].attributes["y"].value)], JXG.GeogebraReader.board);
    labelOffset.x = parseFloat(Data.getElementsByTagName("labelOffset")[0].getAttribute("x"))/JXG.GeogebraReader.board.stretchX;
    labelOffset.y = parseFloat(Data.getElementsByTagName("labelOffset")[0].getAttribute("y"))/JXG.GeogebraReader.board.stretchY;
  }

  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')) {
      var a = JXG.getReference(JXG.GeogebraReader.board, Data.getElementsByTagName("startPoint")[0].getAttribute('exp'));
      gxtEl.x = function() {return a.X()+labelOffset.x;};
      gxtEl.y = function() {return a.Y()-labelOffset.y;}; // minus because geogebra starts on the other side
      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]) {
    var tmp = new JXG.Coords(JXG.COORDS_BY_SCREEN, [parseFloat(Data.getElementsByTagName("absoluteScreenLocation")[0].getAttribute("x")),
                                                    parseFloat(Data.getElementsByTagName("absoluteScreenLocation")[0].getAttribute("y"))], JXG.GeogebraReader.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 {XMLNode} Data expects the content of the current element
 * @return {Object} object with according attributes
 */
this.visualProperties = function(Data, attr) {
  (Data.getElementsByTagName("show").length != 0 && Data.getElementsByTagName("show")[0].getAttribute("object")) ? attr.visible = Data.getElementsByTagName("show")[0].getAttribute("object") : false;
  (Data.getElementsByTagName("show").length != 0 && Data.getElementsByTagName("show")[0].getAttribute("label")) ? attr.withLabel = Data.getElementsByTagName("show")[0].getAttribute("label") : true;
  if(attr.withLabel == 'true') {
     attr.withLabel = true;
  }
  else if(attr.withLabel == 'false') {
     attr.withLabel = false;
  }
  (Data.getElementsByTagName('pointSize')[0]) ? attr.size = Data.getElementsByTagName('pointSize')[0].getAttribute("val") : false;
  (Data.getElementsByTagName('pointStyle')[0]) ? attr.styleGGB = Data.getElementsByTagName('pointStyle')[0].getAttribute("val") : false;
   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 = '1px';
      }
      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;
   }
  (Data.getElementsByTagName('slopeTriangleSize')[0]) ? attr.slopeWidth = Data.getElementsByTagName('slopeTriangleSize')[0].getAttribute("val") : false;
  (Data.getElementsByTagName('lineStyle')[0]) ? attr.strokeWidth = (Data.getElementsByTagName('lineStyle')[0].getAttribute("thickness")/2.0)+'px' : false;
  if(attr.strokeWidth) {
    attr.highlightStrokeWidth = (1*attr.strokeWidth.substr(0,attr.strokeWidth.length-2)+1)+'px';
  }
  (Data.getElementsByTagName('lineStyle')[0]) ? attr.dashGGB = Data.getElementsByTagName('lineStyle')[0].getAttribute("type") : false;

   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;
   }
  (Data.getElementsByTagName("labelOffset")[0]) ? attr.labelX = 1*Data.getElementsByTagName("labelOffset")[0].getAttribute("x") : false;
  (Data.getElementsByTagName("labelOffset")[0]) ? attr.labelY = 1*Data.getElementsByTagName("labelOffset")[0].getAttribute("y") : false;
  (Data.getElementsByTagName("trace")[0]) ? attr.trace = Data.getElementsByTagName("trace")[0].getAttribute("val") : false;
  (Data.getElementsByTagName('fix')[0]) ? attr.fixed = Data.getElementsByTagName('fix')[0].getAttribute("val") : false;
  return attr;
};

/**
 * Searching for an element in the geogebra tree
 * @param {String} the name of the element to search for
 * @param {Boolean} whether it is search for an expression or not
 * @return {Object} object with according label
 */
this.getElement = function(name, expr) {
  var Data, i, j;
  expr = expr || false;
  for(i=0; i<JXG.GeogebraReader.tree.getElementsByTagName("construction").length; i++)
    if(expr == false) {
      for(j=0; j<JXG.GeogebraReader.tree.getElementsByTagName("construction")[i].getElementsByTagName("element").length; j++) {
        Data = JXG.GeogebraReader.tree.getElementsByTagName("construction")[i].getElementsByTagName("element")[j];
        if(name == Data.getAttribute("label")) {
          return Data;
        }
      };
    } else {
      for(j=0; j<JXG.GeogebraReader.tree.getElementsByTagName("construction")[i].getElementsByTagName("expression").length; j++) {
        Data = JXG.GeogebraReader.tree.getElementsByTagName("construction")[i].getElementsByTagName("expression")[j];
        if(name == Data.getAttribute("label")) {
          return Data;
        }
      };
    }
  return false;
};

/**
 * Check if an element is already registered in the temporary ggbElements register. If not, create and register the element.
 * @param {String} the name of the element to check
 * @return {Object} newly created element
 */
this.checkElement = function(name) {
// 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] = JXG.GeogebraReader.checkElement(input[i]);
  //   }
  //   output = {
  //     'attributes' : []
  //   };
  //   output.attributes['type'] = {value: type };
  //   output.attributes['label'] = {value: name};
  //
  //   JXG.GeogebraReader.board.ggbElements[name] = JXG.GeogebraReader.writeElement(JXG.GeogebraReader.board, name, input, type);
  // } else
  if(typeof JXG.GeogebraReader.board.ggbElements[name] == 'undefined' || JXG.GeogebraReader.board.ggbElements[name] == '') {
    var input = JXG.GeogebraReader.getElement(name);
    JXG.GeogebraReader.board.ggbElements[name] = JXG.GeogebraReader.writeElement(JXG.GeogebraReader.board, input);
  }
  return JXG.GeogebraReader.board.ggbElements[name];
};

/**
 * Prepare expression for this.ggbParse with solving multiplications and replacing mathematical functions.
 * @param {String} exp Expression to parse and correct
 * @return {String} correct expression with fixed function and multiplication
 */
this.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( eval('/'+vars[i]+'/g'), '__'+vars[i] );
        }
      }

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

	  if(JXG.GeogebraReader.format <= 3.01) {
	    // prepare string: "solve" multiplications 'a b' to 'a*b'
	    s = expr.split(' ');
	    o = '';
	    for(var 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;
    } else {
      return exp;
    }
  break;
  case 's':
    exp = exp.replace(/(?![e])x(?!\()(?![p])/g, '__x');
    return ['__x', exp];
  break;
  default:
    if(JXG.GeogebraReader.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;
  break;
 }
};

/**
 * Searching for an element in the geogebra tree
 * @param {Object} board object
 */
this.writeBoard = function(board) {
  var boardData = JXG.GeogebraReader.tree.getElementsByTagName("euclidianView")[0];

  board.origin = {};
  board.origin.usrCoords = [1, 0, 0];
  board.origin.scrCoords = [1, 1*boardData.getElementsByTagName("coordSystem")[0].getAttribute("xZero"), 1*boardData.getElementsByTagName("coordSystem")[0].getAttribute("yZero")];
  board.unitX = (boardData.getElementsByTagName("coordSystem")[0].getAttribute("scale")) ? 1*boardData.getElementsByTagName("coordSystem")[0].getAttribute("scale") : 1;
  board.unitY = (boardData.getElementsByTagName("coordSystem")[0].getAttribute("yscale")) ? 1*boardData.getElementsByTagName("coordSystem")[0].getAttribute("yscale") : board.unitX;
  board.stretchX = board.zoomX*board.unitX;
  board.stretchY = board.zoomY*board.unitY;

  board.fontSize = (JXG.GeogebraReader.tree.getElementsByTagName("gui")[0] && JXG.GeogebraReader.tree.getElementsByTagName("gui")[0].getElementsByTagName("font")[0]) ? 1*JXG.GeogebraReader.tree.getElementsByTagName("gui")[0].getElementsByTagName("font")[0].getAttribute("size") : '12px';

  JXG.JSXGraph.boards[board.id] = board;

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

  // snap to point
  var snapToPoint = (boardData.getElementsByTagName('evSettings')[0].getAttribute("pointCapturing") == "true");

  var grid = (boardData.getElementsByTagName('evSettings')[0].getAttribute("grid") == "true") ? board.renderer.drawGrid(board) : null;

  if(boardData.getElementsByTagName('evSettings')[0].getAttribute("axes") && boardData.getElementsByTagName('evSettings')[0].getAttribute("axes") == "true") {
      board.ggbElements["xAxis"] = board.create('axis', [[0, 0], [1, 0]], {strokeColor:'black', minorTicks: 0});
      board.ggbElements["yAxis"] = board.create('axis', [[0, 0], [0, 1]], {strokeColor:'black', minorTicks: 0});
  }
};

/**
 * Searching for an element in the geogebra tree
 * @param {Object} board object
 * @param {Object} ggb element whose attributes are to parse
 * @param {Array} input list of all input elements
 * @param {String} typeName output construction method
 * @return {Object} return newly created element or false
 */
this.writeElement = function(board, output, input, cmd) {
  var element, gxtEl, attr, p, exp, coord, type, points, border, length, m, s, e, sx, sy, ex, ey, func, range;
  element = (JXG.isArray(output)) ? output[0] : output;

  gxtEl = {}; // geometric element
  attr = {}; // Attributes of geometric elements

  JXG.debug(element);

  gxtEl.type = (element && element.attributes && typeof cmd === 'undefined') ? element.getAttribute('type').toLowerCase() : cmd;
  gxtEl.label = element.getAttribute('label');
  attr.name  = gxtEl.label;

  JXG.debug("<br><b>Konstruiere</b> "+ attr.name +"("+ gxtEl.type +"):");

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

      if(JXG.GeogebraReader.getElement(attr.name, true)) {
        exp = JXG.GeogebraReader.getElement(attr.name, true).getAttribute('exp');
        coord = JXG.GeogebraReader.ggbParse(exp);
        gxtEl.x = new Function('return '+ coord[0] +';');
        gxtEl.y = new Function('return '+ coord[1] +';');
      } else {
        gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      }
      if(attr.styleGGB == undefined) {
         attr.face = 'circle';
         attr.fillColor = attr.strokeColor;
         attr.fillOpacity = 1;
         attr.highlightFillColor = attr.strokeColor;
         attr.highlightFillOpacity = 1;
         attr.strokeColor = 'black';
         attr.strokeWidth = '1px';
      }

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

      try {
        var ma = /Circle\[\s*(\w+)\s*,\s*([\d\.]+)\s*\]/.exec(input);
        if(typeof input != 'undefined') {
          if (ma!=null && ma.length==3) {
            // from Circle[A, 5] take "A" and "5", stored in ma[1] and ma[2]
            var q = JXG.GeogebraReader.checkElement(ma[1])
            var c = board.create('circle', [q, parseFloat(ma[2])], {fillColor:'none',visible:false,name:''});
            p = board.create('glider', [gxtEl.x, gxtEl.y, c], attr);
          } else if(JXG.isArray(input)) {
            p = board.create('glider', [gxtEl.x, gxtEl.y, input[0]], attr);
          } else {
            p = board.create('glider', [gxtEl.x, gxtEl.y, input], attr);
          }
        } else {
          p = board.create('point', [gxtEl.x, gxtEl.y], attr);
        }
        return p;
      } catch(e) {
          JXG.debug("* <b>Err:</b> Point " + attr.name +"<br>\n");
          return false;
      }
    break;
    case 'segment':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

      try {
        JXG.debug("* <b>Segment:</b> ("+ attr.name +") First: " + input[0].name + ", Last: " + input[1].name + "<br>\n");
        attr.straightFirst = false;
        attr.straightLast =  false;
        p = board.create('line', input, attr);
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Segment " + attr.name +" First: " + input[0].name + ", Last: " + input[1].name + "<br>\n");
        return false;
      }
    break;
    case 'line':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.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(JXG.getReference(board, input[1].id).type == 1330924622) {
         type = 'parallel'; // Parallele durch Punkt
      }

      try {
        p = board.create(type, input, attr);
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Line " + attr.label +"<br>\n");
        return false;
      }
    break;
    case "orthogonalline":
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

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

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

      try {
        JXG.debug("* <b>Polygon:</b> First: " + input[0].name + ", Second: " + input[1].name + ", Third: " + input[2] + "<br>\n");

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

        for(var 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] = JXG.GeogebraReader.colorProperties(output[i], borderatts[i-1]);
          borderatts[i-1] = JXG.GeogebraReader.visualProperties(output[i], borderatts[i-1]);
          // JXG.debug("border["+ typeof borders[i-1] +"]: "+ borders[i-1].name);
        }
        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(JXG.GeogebraReader.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]);
              // JXG.debug("input-queue: added "+ input[i].name);
            }
          }
        }

        if(type == 'regular') {
          p = board.create('regularpolygon', points, attr);
        }
        else {
          p = board.create('polygon', points, attr);
        }
        for(i=0; i<p.borders.length; i++) {
            if(borderatts[i].withLabel) {
                p.borders[i].addLabelToElement();
            }
            p.borders[i].setProperty(borderatts[i]);
        }
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Polygon " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'intersect':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

      try {
        JXG.debug("* <b>Intersection:</b> First: " + input[0].name + ", Second: " + input[1].name + "<br>\n");
        if(attr.styleGGB == undefined) {
           attr.face = 'circle';
           attr.fillColor = attr.strokeColor;
           attr.fillOpacity = 1;
           attr.highlightFillColor = attr.strokeColor;
           attr.highlightFillOpacity = 1;
           attr.strokeColor = 'black';
           attr.strokeWidth = '1px';
        }
        if(output.length == 1) {
           p = board.create('intersection', [input[0], input[1], 0], attr);
        }
        else {
           p = board.create('intersection', [input[0], input[1], 1], attr);
           var attr2 = {}
           attr2 = JXG.GeogebraReader.colorProperties(output[1], attr2);
           attr2 = JXG.GeogebraReader.visualProperties(output[1], attr2);
           attr2.name = output[1].getAttribute('label');
           var p2 = board.create('otherintersection', [input[0], input[1], p], attr2);
           board.ggbElements[attr2.name] = p2;
        }

        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Intersection " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'distance':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);


      try {
        JXG.debug("* <b>Distance:</b> First: " + input[0].name + ", Second: " + input[1].name + "<br>\n");

        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 = board.create('midpoint', input, {visible: 'false'});
          attr.visible = 'true';
          p = 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.getReference(board, input[0].id).Dist(JXG.getReference(board, input[1].id)).toFixed(JXG.GeogebraReader.decimals));
                }], attr);
          p.Value = function () {
            return (JXG.getReference(board, input[0].id).Dist(JXG.getReference(board, input[1].id)));
          }
        }
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Distance " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'vector':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

      if(element.getElementsByTagName("startPoint")[0]) {

        if(input && input.length == 2) {
            e = JXG.GeogebraReader.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")) {
            var startpoint = element.getElementsByTagName("startPoint")[0].getAttribute("exp");
            s = JXG.GeogebraReader.checkElement(startpoint);
        }
      } else if(input && input.length != 0) {
        s = input[0];
        e = input[1];
      } else {
        exp = JXG.GeogebraReader.getElement(element.getAttribute('label'), true);
        if(exp) {// experimental
            exp = exp.getAttribute('exp');
            // exp = JXG.GeogebraReader.functionParse('', exp);
            exp = JXG.GeogebraReader.ggbParse(exp);
            if (JXG.isArray(exp))
            	exp = new Array(new Function('return '+ exp[1] +';'), new Function('return '+ exp[2] +';'));
            else
            	exp = new Function('return '+ exp +';');
            JXG.debug('exp: '+ exp);
            p = board.create('arrow', [[0,0], [exp[0], exp[1]]], attr);
            return p;
            //t = JXG.getReference(board, 'a');
            //s = t.point1;
            // var e = [-1*vector.point2.X(), -1*vector.point2.Y()];
            // attr.type = 'rotate';
            // var angle;
            // if(exp < 0) {
            //   angle = Math.PI;
            // } else if(exp == 0) {
            //   angle = 0;
            // } else {
            //   angle = Math.PI/exp;
            // }
            // needed: a clean rotating based on factor 'exp'

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

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

      try {
        JXG.debug("* <b>Rotate:</b> First: " + input[0].name + ", Second: " + input[1] + "<br>\n");
        attr.type = 'rotate';

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

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

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

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

        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Dilate " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'translate':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

      try {
          t = 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(attr.styleGGB == undefined) {
             attr.face = 'circle';
             attr.fillColor = attr.strokeColor;
             attr.fillOpacity = 1;
             attr.highlightFillColor = attr.strokeColor;
             attr.highlightFillOpacity = 1;
             attr.strokeColor = 'black';
             attr.strokeWidth = '1px';
          }
          p = board.create('point', [input[0], t], attr);
          return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Translate " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'mirror':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

      if(JXG.getReference(board, input[1].id).type == 1330925652) var type = 'mirrorpoint'; // Punktspiegelung
      else if(JXG.getReference(board, input[1].id).type == 1330924622) var type = 'reflection'; // Geradenspiegelung

      try {
        JXG.debug("* <b>Mirror:</b> First: " + input[0].name + ", Second: " + input[1].name + "<br>\n");
        p = board.create(type, [input[1], input[0]], attr);
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Mirror " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'circle':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

      try {
        JXG.debug("* <b>Circle:</b> First: " + input[0].name + ", Second: " + input[1] + "<br>\n");
        p = board.create('circle', input, attr);
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Circle " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'circlearc':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

      try {
        JXG.debug("* <b>CircleArc:</b> First: " + input[0].name + ", Second: " + input[1].name + "<br>\n");
        p = board.create('arc', input, attr);
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> CircleArc " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'ellipse':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

      try {
        JXG.debug("* <b>Ellipse:</b> First: " + input[0].name + ", Second: " + input[1].name + ", Third: "+ input[2] +"<br>\n");
        // if third parameters is the major axis, else the third parameter is a point
        if(parseInt(input[2]) == input[2])
          input[2] = parseInt(input[2]*2); // Geogebra delivers the half major axis

        p = board.create('ellipse', input, attr);
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Ellipse " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'conic':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

//      try {
	/*
        // is there an expression named like the conic?
        var exp = JXG.GeogebraReader.getElement(attr.name, true);

        // then get the function parameteres
        if(exp.attributes['exp']){
          // exp = JXG.GeogebraReader.functionParse(exp.attributes['exp'].value);
          // exp = JXG.GeogebraReader.ggbParse(exp.attributes['exp'].value);



          // (exp.getElementsByTagName('value')) ? exp = parseFloat(exp.getElementsByTagName('value')[0].attributes['val'].value) : false;

        } else */ if(input && input.length == 5) {
          p = board.create('conic', input, attr);
        } else if(element.getElementsByTagName('matrix')) {
          m = [];
          for(var i=0; i<element.getElementsByTagName('matrix')[0].attributes.length; i++) {
            m[i] = parseFloat(element.getElementsByTagName('matrix')[0].attributes[i].value);
          }
          p = board.create('conic', m, attr);
        }

        return p;
//      } catch(e) {
//        JXG.debug("* <b>Err:</b> Conic " + attr.name +"<br>\n");
//        return false;
//      }
    break;
    case 'circlesector':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);
      //attr.names = [attr.name,'','',''];
      //attr2 = {};
      //attr2.names = attr.names;
      try {
        JXG.debug("* <b>CircleSector:</b> First: " + input[0].name + ", Second: " + input[1].name + ", Third: " + input[2].name + "<br>\n");
        p = board.create('sector', [input[0],input[1],input[2]], attr);
        /*
        p.point4.hideElement();
        p.arc.setProperty(attr);
        p.arc.visProp['highlightStrokeWidth'] = (1*p.arc.visProp['strokeWidth'].substr(0,p.arc.visProp['strokeWidth'].length-2)+1)+'px';
        p.lines[0].setProperty(attr);
        p.lines[1].setProperty(attr);
        p.lines[0].visProp['highlightStrokeWidth'] = (1*p.lines[0].visProp['strokeWidth'].substr(0,p.lines[0].visProp['strokeWidth'].length-2)+1)+'px';
        p.lines[1].visProp['highlightStrokeWidth'] = (1*p.lines[1].visProp['strokeWidth'].substr(0,p.lines[1].visProp['strokeWidth'].length-2)+1)+'px';
        p.arc.hasPoint = p.arc.hasPointSector;
        p.arc.highlight = (function(el){ return function() {
            this.board.renderer.highlight(this);
            this.board.renderer.highlight(el.lines[0]);
            this.board.renderer.highlight(el.lines[1]);
        };})(p);
        p.arc.noHighlight = (function(el){ return function() {
            this.board.renderer.noHighlight(this);
            this.board.renderer.noHighlight(el.lines[0]);
            this.board.renderer.noHighlight(el.lines[1]);
        };})(p);
        p.lines[0].highlight = (function(el){ return function() {
            this.board.renderer.highlight(this);
            this.board.renderer.highlight(el.arc);
            this.board.renderer.highlight(el.lines[1]);
        };})(p);
        p.lines[1].highlight = (function(el){ return function() {
            this.board.renderer.highlight(this);
            this.board.renderer.highlight(el.arc);
            this.board.renderer.highlight(el.lines[0]);
        };})(p);
        p.lines[0].noHighlight = (function(el){ return function() {
            this.board.renderer.noHighlight(this);
            this.board.renderer.noHighlight(el.arc);
            this.board.renderer.noHighlight(el.lines[1]);
        };})(p);
        p.lines[1].noHighlight = (function(el){ return function() {
            this.board.renderer.noHighlight(this);
            this.board.renderer.noHighlight(el.arc);
            this.board.renderer.noHighlight(el.lines[0]);
        };})(p);
        */
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> CircleSector " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'linebisector':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

      try {
        JXG.debug("* <b>LineBiSector (Mittelsenkrechte):</b> First: " + input[0].name + "<br>\n");
        attr.straightFirst = true;
        attr.straightLast =  true;

        m = board.create('midpoint', input, {visible: false});
        if(JXG.getReference(board, input[0].id).type == 1330925652 && JXG.getReference(board, input[1].id).type == 1330925652) {
          t = board.create('line', input, {visible: 'false'});
          p = board.create('perpendicular', [m, t], attr);
          p.point.setProperty('visible:false');
        } else {
          p = board.create('perpendicular', [m, input[0]], attr);
          p.point.setProperty('visible:false');
        }
        return p[0];
      } catch(e) {
        JXG.debug("* <b>Err:</b> LineBiSector (Mittelsenkrechte) " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'ray':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

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

      try {
        JXG.debug("* <b>Tangent:</b> First: " + input[0].name + ", Sec.: "+ input[1].name +"("+ input[1].type +")<br>\n");
        switch(input[1].type) {
          case 1330923344: // graph
            input[0].makeGlider(input[1]);
            p = board.create('tangent', [input[0]], attr);
            return p;
          break;
          case 1330922316: // circle 0x4F54434C
          case 1330922319: // conic 0x4F54434F
            /*
            m = function(circ) {
	        return [[circ.midpoint.X()*circ.midpoint.X()+circ.midpoint.Y()*circ.midpoint.Y()-circ.Radius()*circ.Radius(),
	                     -circ.midpoint.X(),-circ.midpoint.Y()],
	                    [-circ.midpoint.X(),1,0],
	                    [-circ.midpoint.Y(),0,1]
	                   ];
	            };

	        t = board.create('line', [
	                    function(){ return JXG.Math.matVecMult(m(input[1]), input[0].coords.usrCoords)[0]; },
	                    function(){ return JXG.Math.matVecMult(m(input[1]), input[0].coords.usrCoords)[1]; },
	                    function(){ return JXG.Math.matVecMult(m(input[1]), input[0].coords.usrCoords)[2]; }
	                ], {visible: false});
                     */
            // input[0]: point
            // input[1]: circle or conic
            var pol = board.create('polar',[input[1],input[0]],{visible:false});
	        var i1 = board.create('intersection', [input[1], pol, 0], {visible: false});
	        var i2 = board.create('intersection', [input[1], pol, 1], {visible: false});
	        var t1 = board.create('line', [input[0], i1], attr);
            var attr2 = {}
            attr2 = JXG.GeogebraReader.colorProperties(output[1], attr2);
            attr2 = JXG.GeogebraReader.visualProperties(output[1], attr2);
            attr2.name = output[1].getAttribute('label');
            var t2 = board.create('line', [input[0], i2], attr2);
            board.ggbElements[attr2.name] = t2;
            return [t1, t2];
          break;
        }
      } catch(e) {
        JXG.debug("* <b>Err:</b> Tangent " + attr.name +" "+ attr2.name + "<br>\n");
        return false;
      }
    break;
    case 'circumcirclearc':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

      try {
        JXG.debug("* <b>CircumcircleArc:</b> First: " + input[0].name + "<br>\n");
        p = board.create('circumcirclearc', input, attr);
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> CircumcircleArc " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'circumcirclesector':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

      try {
        JXG.debug("* <b>CircumcircleSector:</b> First: " + input[0].name + "<br>\n");
        p = board.create('circumcirclesector', [input[0], input[1], input[2]], attr); //{name:attr['name']});
        /*
        p.arc.setProperty(attr);
        p.lines[0].setProperty(attr);
        p.lines[1].setProperty(attr);
        p.arc.visProp['highlightStrokeWidth'] = (1*p.arc.visProp['strokeWidth'].substr(0,p.arc.visProp['strokeWidth'].length-2)+1)+'px';
        p.lines[0].visProp['highlightStrokeWidth'] = (1*p.lines[0].visProp['strokeWidth'].substr(0,p.lines[0].visProp['strokeWidth'].length-2)+1)+'px';
        p.lines[1].visProp['highlightStrokeWidth'] = (1*p.lines[1].visProp['strokeWidth'].substr(0,p.lines[1].visProp['strokeWidth'].length-2)+1)+'px';
        p.arc.hasPoint = p.arc.hasPointSector;
        p.arc.highlight = (function(el){ return function() {
            this.board.renderer.highlight(this);
            this.board.renderer.highlight(el.lines[0]);
            this.board.renderer.highlight(el.lines[1]);
        };})(p);
        p.arc.noHighlight = (function(el){ return function() {
            this.board.renderer.noHighlight(this);
            this.board.renderer.noHighlight(el.lines[0]);
            this.board.renderer.noHighlight(el.lines[1]);
        };})(p);
        p.lines[0].highlight = (function(el){ return function() {
            this.board.renderer.highlight(this);
            this.board.renderer.highlight(el.arc);
            this.board.renderer.highlight(el.lines[1]);
        };})(p);
        p.lines[1].highlight = (function(el){ return function() {
            this.board.renderer.highlight(this);
            this.board.renderer.highlight(el.arc);
            this.board.renderer.highlight(el.lines[0]);
        };})(p);
        p.lines[0].noHighlight = (function(el){ return function() {
            this.board.renderer.noHighlight(this);
            this.board.renderer.noHighlight(el.arc);
            this.board.renderer.noHighlight(el.lines[1]);
        };})(p);
        p.lines[1].noHighlight = (function(el){ return function() {
            this.board.renderer.noHighlight(this);
            this.board.renderer.noHighlight(el.arc);
            this.board.renderer.noHighlight(el.lines[0]);
        };})(p);
        */
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> CircumcircleSector " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'semicircle':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

      try {
        JXG.debug("* <b>Semicircle:</b> First: " + input[0].name + "<br>\n");
        p = board.create('semicircle', [input[0], input[1]], attr);
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Semicircle " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'angle':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

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

      try {
        JXG.debug("* <b>Angularbisector:</b> First: " + input[0].name + "<br>\n");
        p = board.create('bisector', input, attr);
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Angularbisector " + attr.name +"<br>\n");
        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 = JXG.GeogebraReader.getElement(element.getAttribute('label'), true);
      if(exp) {
    	  exp = exp.getAttribute('exp');
    	  exp = JXG.GeogebraReader.functionParse('', exp);
    	  exp = JXG.GeogebraReader.ggbParse(exp);
      }
      board.ggb[attr.name] = new Function('return '+ exp +';');
      JXG.debug('value: '+ board.ggb[attr.name]());
      return board.ggb[attr.name];
	} else {
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      // gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);
      if(element.getElementsByTagName('slider').length == 1) { // it's a slider
        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') {
          var tmp = new JXG.Coords(JXG.COORDS_BY_SCREEN, [sx, sy], 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 /= (board.unitX*board.zoomX);
          ex = sx + length;
          ey = sy;
        } else {
          if(element.getElementsByTagName('slider')[0].getAttribute('absoluteScreenLocation') && element.getElementsByTagName('slider')[0].getAttribute('absoluteScreenLocation') == 'true')
          length /= (board.unitY*board.zoomY);
          ex = sx;
          ey = sy + length;
        }

        (element.getElementsByTagName('animation')[0]) ? attr.snapWidth = parseFloat(element.getElementsByTagName('animation')[0].getAttribute('step')) : false;

        try {
          JXG.debug("* <b>Numeric:</b> First: " + attr.name + "<br>\n");
          attr['withTicks'] = false;
          p = 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);
          p.setProperty({withLabel:false});
          return p;
        } catch(e) {
          JXG.debug("* <b>Err:</b> Numeric " + attr.name +"<br>\n");
          return false;
        }
      }
    }
    break;
    case 'midpoint':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

      try {
          if(attr.styleGGB == undefined) {
             attr.face = 'circle';
             attr.fillColor = attr.strokeColor;
             attr.fillOpacity = 1;
             attr.highlightFillColor = attr.strokeColor;
             attr.highlightFillOpacity = 1;
             attr.strokeColor = 'black';
             attr.strokeWidth = '1px';
          }
          p = board.create('midpoint', input, attr);
          JXG.debug("* <b>Midpoint ("+ p.id +"):</b> "+ attr.name + "("+ gxtEl.x +", "+ gxtEl.y +")<br>\n");
          return p;
      } catch(e) {
          JXG.debug("* <b>Err:</b> Midpoint " + attr.name +"<br>\n");
          return false;
      }
    break;
    case 'center':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);
      try {
          if(attr.styleGGB == undefined) {
             attr.face = 'circle';
             attr.fillColor = attr.strokeColor;
             attr.fillOpacity = 1;
             attr.highlightFillColor = attr.strokeColor;
             attr.highlightFillOpacity = 1;
             attr.strokeColor = 'black';
             attr.strokeWidth = '1px';
          }
          p = board.create('point', [function() { return JXG.getReference(board, input[0].id).midpoint.X(); },
                                     function() { return JXG.getReference(board, input[0].id).midpoint.Y(); }], attr);
          JXG.debug("* <b>Center ("+ p.id +"):</b> "+ attr.name + "("+ gxtEl.x +", "+ gxtEl.y +")<br>\n");
          return p;
      } catch(e) {
          JXG.debug("* <b>Err:</b> Center " + attr.name +"<br>\n");
          return false;
      }
    break;
    case 'function':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

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

      JXG.debug(func);

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

      JXG.debug(func);

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

      try {
        if(length == 1)
          p = board.create('functiongraph', [new Function(func[0]), range[0], range[1]], attr);
        else if(length==2)
          p = board.create('functiongraph', [new Function(func[0], func[1]), range[0], range[1]], attr);
        else if(length==3)
          p = board.create('functiongraph', [new Function(func[0], func[1], func[2]), range[0], range[1]], attr);
        else if(length==4)
          p = board.create('functiongraph', [new Function(func[0], func[1], func[2], func[3]), range[0], range[1]], attr);
        else if(length==5)
          p = board.create('functiongraph', [new Function(func[0], func[1], func[2], func[3], func[4]), range[0], range[1]], attr);
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Functiongraph " + attr.name +"<br>\n");
        return false;
      }

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

      try {
        JXG.debug("* <b>Polar:</b> First: " + input[0].name + ", Sec.: "+ input[1].name +"<br>\n");
        p = board.create('polar', input, attr);
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Polar " + attr.name +"<br>\n");
        return false;
      }
    break;
    case 'slope':
     attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
     attr = JXG.GeogebraReader.colorProperties(element, attr);
     gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
     attr = JXG.GeogebraReader.visualProperties(element, attr);

     try {
       JXG.debug("* <b>Slope ("+ attr.name +"):</b> First: " + input[0].name +"<br>\n");
       var slopeWidth = parseInt(attr.slopeWidth) || 1.0;
       var p1 = input[0].glider || input[0].point1;
       var p2 = board.create('point',[function(){return (slopeWidth+p1.X());}, function(){return p1.Y();}], {visible: false});
       var l1 = board.create('segment', [p1, p2], {visible: false}); // visible: attr.visible
       var l2 = board.create('normal', [l1, l1.point2], {visible: false}); // visible attr.visible
       var i  = board.create('intersection', [input[0], l2, 0], {visible: false});
       var m  = board.create('midpoint', [l1.point2, i], {visible: false});

       var t = board.create('text', [function(){return m.X();}, function(){return m.Y();},
                      function(){ return "&nbsp;&nbsp;" + (slopeWidth > 1 ? slopeWidth.toString() : "") + " " + this.name + " = " + JXG.trimNumber((slopeWidth * input[0].getSlope()).toFixed(JXG.GeogebraReader.decimals)); }], attr);
       attr.name = "";
       var t2 = 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(); }; })();
       var poly = board.create('polygon',[p1,p2,i], attr);

       poly.borders[2].setProperty({visible: false});
       return t;
     } catch(e) {
       JXG.debug("* <b>Err:</b> Slope " + attr.name +"<br>\n");
       return false;
     }
    break;
    case 'text':
     attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
     attr = JXG.GeogebraReader.colorProperties(element, attr);
     gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
     attr = JXG.GeogebraReader.visualProperties(element, attr);
     var rx, res = '';

     try {
       if(element.getElementsByTagName('isLaTeX')[0] && element.getElementsByTagName('isLaTeX')[0].getAttribute('val') == 'true') {
         JXG.GeogebraReader.board.options.text.useASCIIMathML = true;
         t = JXG.GeogebraReader.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.
         while(rx = t.match(/(.*?)" \+ (.+) \+ "(.*)/)) {
             var re2 = JXG.GeogebraReader.ggbParse(RegExp.$2);
             if (typeof re2 == 'string') {
               res = res + RegExp.$1 + re2;
             } else {
               res = res + RegExp.$1 + '" + JXG.trimNumber((' + re2 + ').toFixed(JXG.GeogebraReader.decimals)) + "';
             }
             t = RegExp.$3;
         }
         // we have to look, if the string's ending with a string-part or a formula part:
         if(rx = t.match(/(.*?)" \+ (.+)/)) {
             res = res + RegExp.$1 + '" + JXG.trimNumber((' + JXG.GeogebraReader.ggbParse(RegExp.$2) + ').toFixed(JXG.GeogebraReader.decimals))';
         } else
             res = res + t;

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

         p = board.create('text', [gxtEl.x, gxtEl.y, new Function('return ' + res + ';')], attr);
       } else {
         JXG.debug(JXG.GeogebraReader.getElement(attr.name, true).getAttribute('exp'));
         t = JXG.GeogebraReader.ggbParse(JXG.GeogebraReader.functionParse(false, JXG.GeogebraReader.getElement(attr.name, true).getAttribute('exp')));
         JXG.debug(t[1]);
         p = board.create('text', [gxtEl.x, gxtEl.y, new Function('return '+t[0]+' + " " + JXG.trimNumber(parseFloat(' + t[1] +').toFixed(JXG.GeogebraReader.decimals));') ], attr);
       }
       JXG.debug("* <b>Text:</b> " + t  +"<br>\n");
       return p;
     } catch(e) {
      JXG.debug("* <b>Err:</b> Text: " + t +"<br>\n");
      return false;
     }
    break;
    case 'root':
        JXG.debug(input);
        if(JXG.isArray(input))
            p = board.root(input[0]);
        else
            p = board.root(input);
        JXG.debug('r: '+ r.length);
        return p;
    break;
  case 'integral':
      attr = JXG.GeogebraReader.boardProperties(gxtEl, element, attr);
      attr = JXG.GeogebraReader.colorProperties(element, attr);
      gxtEl = JXG.GeogebraReader.coordinates(gxtEl, element);
      attr = JXG.GeogebraReader.visualProperties(element, attr);

      try {
        JXG.debug("* <b>Integral:</b> First: " + input[0].name + ", Sec.: "+ input[1].name +", Thir.: "+ input[2].name +"<br>\n");
        JXG.debug([input[1](), input[2]()]);
        var p = board.create('integral', [JXG.getRef(board, input[0]), [input[1], input[2]]], attr);
        return p;
      } catch(e) {
        JXG.debug("* <b>Err:</b> Integral " + attr.name + e + "<br>\n");
        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;
    break;
  }
};

/**
 * Reading the elements of a geogebra file
 * @param {Object} board board object
 */
this.readGeogebra = function(tree, board) {
  var el, Data, i, els = [], expr;

  board.ggbElements = [];
  board.ggb = {};
  JXG.GeogebraReader.tree = tree;
  JXG.GeogebraReader.board = board;
  JXG.GeogebraReader.format = parseFloat(JXG.GeogebraReader.tree.getElementsByTagName('geogebra')[0].getAttribute('format'));
  JXG.GeogebraReader.decimals = parseInt(JXG.GeogebraReader.tree.getElementsByTagName('geogebra')[0].getElementsByTagName('kernel')[0].getElementsByTagName('decimals')[0].getAttribute('val'));
  JXG.GeogebraReader.writeBoard(board);
  board = JXG.GeogebraReader.setDefaultOptions(board);

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

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

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

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

      var 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.match(/[a-zA-Z]+\[[a-zA-Z0-9]+[a-zA-Z0-9,\ ]*\]/)) {
        //   input[i] = JXG.GeogebraReader.writeElement(board, )
        } else if(el == 'xAxis' || el == 'yAxis') {
          input[i] = board.ggbElements[el];
        } else {
          input[i] = JXG.GeogebraReader.checkElement(el);
        }
      };

      var 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] = JXG.GeogebraReader.getElement(el);
      };
      if(typeof board.ggbElements[elname] == 'undefined' || board.ggbElements[elname] == '') {
        board.ggbElements[elname] = JXG.GeogebraReader.writeElement(board, output, input, Data.getAttribute('name').toLowerCase());
        // JXG.debug("regged: "+board.ggbElements[elname].id+"<br/>");

        /* register borders to according "parent" */
        if(board.ggbElements[elname].borders)
          for(var i=0; i<board.ggbElements[elname].borders.length; i++) {
            board.ggbElements[board.ggbElements[elname].borders[i].name] = board.ggbElements[elname].borders[i];
            // JXG.debug(i+") regged: "+board.ggbElements[elname].borders[i].name+"("+ board.ggbElements[board.ggbElements[elname].borders[i].name].id +")<br/>");
          };
      }
    };

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

      if(typeof board.ggbElements[el] == 'undefined' || board.ggbElements[el] == '') {
        board.ggbElements[el] = JXG.GeogebraReader.writeElement(board, Data);

        if(expr = JXG.GeogebraReader.getElement(el, true)) {
          var type = Data.getAttribute('type');
          switch(type) {
            case 'text':
            case 'function':
              // board.ggbElements[el] = JXG.GeogebraReader.writeElement(board.ggbElements, board, expr, false, type);
            break;
            default:
              JXG.GeogebraReader.ggbParse(expr.getAttribute('exp'), el);
            break;
          }
        }

      }
    };

  }; // end: for construction

  // speeding up the drawing process
  board.unsuspendUpdate();

  board.fullUpdate();
 // delete(board.ggbElements);
};

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

/**
 * Extracting the packed geogebra file in order to return the "blank" xml-tree for further parsing.
 * @param {String} archive containing geogebra.xml-file or raw input string (eg. xml-tree)
 * @return {String} content of geogebra.xml-file if archive was passed in
 */
this.prepareString = function(fileStr, isString) {
    var i, bA, len;
    // if isString is true, fileStr is a base64 encoded string, otherwise it's the zipped file
    if(isString)
        fileStr = JXG.Util.Base64.decode(fileStr, true);
    else if (fileStr.indexOf('<') != 0) {
        bA = [];
        len = fileStr.length;
        for (i=0;i<len;i++)
            bA[i]=JXG.Util.asciiCharCodeAt(fileStr,i);
        // Unzip
        fileStr = (new JXG.Util.Unzip(bA)).unzipFile("geogebra.xml");
    }
    fileStr = JXG.Util.utf8Decode(fileStr);
    fileStr = JXG.GeogebraReader.utf8replace(fileStr);
    return fileStr;
};

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