----------------- Trace -----------------
356168
function Trace(input, pos1, pos2, expr, succeeded, bindings, optChildren) {
  this.input = input;
  this.pos = this.pos1 = pos1;
  this.pos2 = pos2;
  this.source = new Interval(input, pos1, pos2);
  this.expr = expr;
  this.bindings = bindings;
  this.children = optChildren || [];
  this.terminatingLREntry = null;

  this._flags = succeeded ? Flags.succeeded : 0;
}
242905
public void trace(Object message, Throwable exception) {
        log(Level.FINEST, String.valueOf(message), exception);
    }
915415
private String filterStackTrace(String trace) {
    for (StackTraceFilter filter : stackFilters) {
      trace = filter.apply(trace);
    }
    return trace;
  }
1075151
public function trace()
    {
        $s = 0;
        $n = min($this->m, $this->n);
        for ($i = 0; $i < $n; ++$i) {
            $s += $this->A[$i][$i];
        }
        return $s;
    }
359439
function trace(message) {
    var logger = State.logger || console;
    if (!this.root().trace || !logger) { return; }
    logger.info(message);
  }
1135930
function trace(a, b) {
    return trim((new Error()).stack.split('\n').slice(a || 3, b || 4).join('\n'));
}
542807
public void trace(Throwable throwable, String msg, Object[] argArray) {
		logIfEnabled(Level.TRACE, throwable, msg, UNKNOWN_ARG, UNKNOWN_ARG, UNKNOWN_ARG, argArray);
	}
1156207
public void setTraces(java.util.Collection<Trace> traces) {
        if (traces == null) {
            this.traces = null;
            return;
        }

        this.traces = new java.util.ArrayList<Trace>(traces);
    }
942697
public void trace( String msg, Throwable t )
    {
        if( m_delegate.isTraceEnabled() )
        {
            m_delegate.trace( msg, t );
        }
    }
994200
public RayTraceResult trace()
	{
		RayTraceResult mop = null, firstHit = null;
		double tX, tY, tZ, min;
		int count = 0;
		boolean ret = false;

		int currentX = blockSrc.getX();
		int currentY = blockSrc.getY();
		int currentZ = blockSrc.getZ();

		while (!ret && count++ <= MAX_BLOCKS)
		{
			tX = ray.intersectX(currentX + (ray.direction.x > 0 ? 1 : 0));
			tY = ray.intersectY(currentY + (ray.direction.y > 0 ? 1 : 0));
			tZ = ray.intersectZ(currentZ + (ray.direction.z > 0 ? 1 : 0));

			min = getMin(tX, tY, tZ);

			// do not trace first block
			if (count != 1 || !hasOption(Options.IGNORE_FIRST_BLOCK))
				mop = rayTraceBlock(new BlockPos(currentX, currentY, currentZ), ray.getPointAt(min));
			if (firstHit == null)
				firstHit = mop;
			if (hasOption(Options.LOG_BLOCK_PASSED))
				blockPassed.put(new BlockPos(currentX, currentY, currentZ), mop);

			if (dest != null && currentX == blockDest.getX() && currentY == blockDest.getY() && currentZ == blockDest.getZ())
				ret = true;

			if (!ret)
			{
				if (min == tX)
					currentX += step.x;
				if (min == tY)
					currentY += step.y;
				if (min == tZ)
					currentZ += step.z;
			}

			if (dest != null && dest.equals(ray.getPointAt(min)))
				ret = true;

		}

		if (firstHit == null && dest != null)
			firstHit = new RayTraceResult(RayTraceResult.Type.MISS, dest.toVec3d(), null, new BlockPos(currentX, currentY, currentZ));

		firstHit = ChunkCollision.get().getRayTraceResult(	world,
															Pair.of(src, dest),
															firstHit,
															hasOption(Options.HIT_LIQUIDS),
															hasOption(Options.CHECK_COLLISION),
															true);

		if (!ret)
			MalisisCore.message("Trace fail : " + MAX_BLOCKS + " blocks passed (" + currentX + "," + currentY + "," + currentZ + ")");
		return firstHit;
	}
1012263
private void cleanStackTrace() {
    StackTraceElement[] realTrace = getStackTrace();
    StackTraceElement[] trace = new StackTraceElement[realTrace.length - 1];
    StackTraceElement top = realTrace[0];
    trace[0] = new StackTraceElement(top.getClassName(),
        getMethodName(realTrace[2].getMethodName()),
        top.getFileName(), top.getLineNumber());
    System.arraycopy(realTrace, 2, trace, 1, realTrace.length - 2);
    setStackTrace(trace);
  }
400243
function TraceSubset(fullTrace, fullTraceBegin, fullTraceEnd) {
  this._fullTrace = fullTrace;
  this._fullTraceBegin = fullTraceBegin;
  this._fullTraceEnd = fullTraceEnd;
  this._isNTerminal = this._fullTraceBegin === 0;
  this._isCTerminal = this._fullTrace.length() === this._fullTraceEnd;
  var length = this._fullTraceEnd - this._fullTraceBegin;
  if (!this._isCTerminal) {
    ++length;
  }
  if (!this._isNTerminal) {
    ++length;
    this._fullTraceBegin -= 1;
  }
  this._length = length;
}
419121
@Override
    public void printStack(final StringBuilder sb, final StackTraceElement[] trace) {
        for (final StackTraceElement element : trace) {
            sb.append("\tat ").append(element).append('\n');
        }
    }
1242242
public void trace(Marker marker, String format, Object arg1, Object arg2) {
        if (!logger.isTraceEnabled(marker))
            return;
        if (instanceofLAL) {
            String formattedMessage = MessageFormatter.format(format, arg1, arg2).getMessage();
            ((LocationAwareLogger) logger).log(marker, fqcn, LocationAwareLogger.TRACE_INT, formattedMessage, new Object[] { arg1, arg2 }, null);
        } else {
            logger.trace(marker, format, arg1, arg2);
        }
    }
176889
public void trace(String message, Object ... args) {
    if (log.isTraceEnabled()) {
      log.trace(String.format(message, args));
    }
  }
186506
public Router trace(@NotNull final Pattern regex, @NotNull final IMiddleware... handlers) {
        addRegEx("TRACE", regex, handlers, traceBindings);
        return this;
    }
313021
private void setTraces() {
		int pointers[] = new int[4]; //alphabetical, 0=A, 1=C, 2=G, 3=T
		int datas[] = new int[4];
		char order[] = new char[4];

		datas[0] = DATA9;
		datas[1] = DATA10;
		datas[2] = DATA11;
		datas[3] = DATA12;

		for (int i = 0; i <= 3; i++) {
			order[i] = (char) traceData[FWO + i];
		}

		for (int i = 0; i <= 3; i++) {
			switch (order[i]) {
				case 'A':
				case 'a':
					pointers[0] = datas[i];
					break;
				case 'C':
				case 'c':
					pointers[1] = datas[i];
					break;
				case 'G':
				case 'g':
					pointers[2] = datas[i];
					break;
				case 'T':
				case 't':
					pointers[3] = datas[i];
					break;
				default:
					throw new IllegalArgumentException("Trace contains illegal values.");
			}
		}

		A = new int[traceLength];
		C = new int[traceLength];
		G = new int[traceLength];
		T = new int[traceLength];

		for (int i = 0; i <= 3; i++) {
			byte[] qq = new byte[traceLength * 2];
			getSubArray(qq, pointers[i]);
			DataInputStream dis = new DataInputStream(new ByteArrayInputStream(qq));
			for (int x = 0; x <= traceLength - 1; x++) {
				try {
					if (i == 0) A[x] = (int) dis.readShort();
					if (i == 1) C[x] = (int) dis.readShort();
					if (i == 2) G[x] = (int) dis.readShort();
					if (i == 3) T[x] = (int) dis.readShort();
				} catch (IOException e)//This shouldn't happen. If it does something must be seriously wrong.
				{
					throw new IllegalStateException("Unexpected IOException encountered while manipulating internal streams.");
				}
			}
		}
		return;
	}