GE Lua Documentation

  M.dpi = dpi or 1
  camFwd:set(1,0,0)
  camFwd:setRotate(camRot)

  camFwd:setRotate(camRot)
  camRight:set(0,1,0)
  camRight:setRotate(camRot)

  camInverseFwd:set(1,0,0)
  camInverseFwd:setRotate(camRotInverse)

  camInverseFwd:setRotate(camRotInverse)
  camInverseRight:set(0,1,0)
  camInverseRight:setRotate(camRotInverse)

  cp:set(cp.x + width/2, height - cp.y -  height/2,0)
  return cp

local function worldToMapXYZ(target, source)
  --target:set(source)
  local x, y = source.x, source.y

  --target:setRotate(camRot)
  --target:set(target.x * camFwd + target.y * camRight)
  local tX = x

  target:set(x, y,0)
end

  inset = inset or 0
  centerLocal:set(width*0.5 + offsetX, height*0.5 + offsetY, 0)
  target:set(pos.x, pos.y, 0)

  centerLocal:set(width*0.5 + offsetX, height*0.5 + offsetY, 0)
  target:set(pos.x, pos.y, 0)

  -- Vector from center to target
  fromCenter:set(target.x - centerLocal.x, target.y - centerLocal.y, 0)
  local distance = fromCenter:length()

  if distance <= 1e-6 then
    pos:set(centerLocal.x, centerLocal.y, 0)
    return pos, false

    if distance > maxDistance then
      dir:set(fromCenter)
      dir:normalize()

      dir:normalize()
      pos:set(centerLocal.x + dir.x * maxDistance, centerLocal.y + dir.y * maxDistance, 0)
      return pos, true

    end
    pos:set(target)
    return pos, false

  if math.abs(target.x - centerLocal.x) <= halfWidth and math.abs(target.y - centerLocal.y) <= halfHeight then
    pos:set(target)
    return pos, false

  -- Ray/segment intersection against rectangle edges
  corners[1]:set(offsetX + inset,           offsetY + inset,            0)
  corners[2]:set(offsetX + width - inset,   offsetY + inset,            0)

  corners[1]:set(offsetX + inset,           offsetY + inset,            0)
  corners[2]:set(offsetX + width - inset,   offsetY + inset,            0)
  corners[3]:set(offsetX + width - inset,   offsetY + height - inset,   0)

  corners[2]:set(offsetX + width - inset,   offsetY + inset,            0)
  corners[3]:set(offsetX + width - inset,   offsetY + height - inset,   0)
  corners[4]:set(offsetX + inset,           offsetY + height - inset,   0)

  corners[3]:set(offsetX + width - inset,   offsetY + height - inset,   0)
  corners[4]:set(offsetX + inset,           offsetY + height - inset,   0)

  dir:set(fromCenter)
  dir:normalize()

    local p2 = corners[i % 4 + 1]
    edge:set(p2.x - p1.x, p2.y - p1.y, 0)
    toP1:set(p1.x - centerLocal.x, p1.y - centerLocal.y, 0)

    edge:set(p2.x - p1.x, p2.y - p1.y, 0)
    toP1:set(p1.x - centerLocal.x, p1.y - centerLocal.y, 0)

  if tMin < math.huge then
    pos:set(centerLocal.x + dir.x * tMin, centerLocal.y + dir.y * tMin, 0)
    return pos, true

  -- Fallback: return original target if no intersection found
  pos:set(target)
  return pos, false

local simpleCircle = function(pos, fill, strikeClr, radius)
  circlePos:set(pos)
  worldToMapXYZ(circlePos, circlePos)

local simpleLine = function(pos1, pos2, fill, strikeClr)
  linePos1:set(pos1)
  linePos2:set(pos2)

  linePos1:set(pos1)
  linePos2:set(pos2)
  worldToMapXYZ(linePos1, linePos1)

  -- Convert world position to minimap coordinates
  circlePos:set(pos)
  worldToMapXYZ(circlePos, circlePos)

  -- Work in minimap's local coordinate system (before rotation)
  centerLocal:set(width/2 + offsetX, height/2 + offsetY, 0)

  -- Convert marker to local coordinates
  markerLocal:set(0,0,0)
  worldToMapXYZ(markerLocal, pos)

  -- Calculate direction in local coordinates
  directionLocal:set(markerLocal.x - centerLocal.x, markerLocal.y - centerLocal.y, 0)
  directionLocal:normalize()

  -- Clamp target to bounds using shared helper (account for marker radius)
  intersectionLocal:set(markerLocal)
  local _, wasClamped = setClampToBounds(intersectionLocal, buffer + radius)

  -- Draw triangle pointing toward marker
  tip:set(intersectionLocal.x + directionLocal.x * triangleLength, intersectionLocal.y + directionLocal.y * triangleLength, 0)

  -- Triangle sides (perpendicular to direction)
  side:set(-directionLocal.y, directionLocal.x, 0)
  side1:set(intersectionLocal.x + side.x * triangleSize, intersectionLocal.y + side.y * triangleSize, 0)

  side:set(-directionLocal.y, directionLocal.x, 0)
  side1:set(intersectionLocal.x + side.x * triangleSize, intersectionLocal.y + side.y * triangleSize, 0)
  side2:set(intersectionLocal.x - side.x * triangleSize, intersectionLocal.y - side.y * triangleSize, 0)

  side1:set(intersectionLocal.x + side.x * triangleSize, intersectionLocal.y + side.y * triangleSize, 0)
  side2:set(intersectionLocal.x - side.x * triangleSize, intersectionLocal.y - side.y * triangleSize, 0)

local simpleLineWithEdgePointer = function(pos1, pos2, fill, strikeClr)
  center:set(pos1)
  center:setAdd(pos2)

    if self.pinIn.duration.value ~= nil then
      self.mgr.modules.timer:set(id, "duration", self.pinIn.duration.value)
    end

    if self.pinIn.ref.value ~= nil then
      self.mgr.modules.timer:set(id, "mode", self.pinIn.ref.value)
    end

  local xyOffset = obj:getObjectBox():getCenter():z0()
  xyOffset:set(xyOffset:componentMul(obj:getScale()))

    for i = 0, edgeCount - 2 do
      pos1:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i) or guide:getTopMiddleEdgePosition(i))
      pos2:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i + 1) or guide:getTopMiddleEdgePosition(i + 1))

      pos1:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i) or guide:getTopMiddleEdgePosition(i))
      pos2:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i + 1) or guide:getTopMiddleEdgePosition(i + 1))
      totalDist = totalDist + pos1:distance(pos2)

  if not params.useNormal then
    dirVecUp:set(vecUp)
  end

  for i = 0, edgeCount - 2 do
    pos1:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i) or guide:getTopMiddleEdgePosition(i))
    pos2:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i + 1) or guide:getTopMiddleEdgePosition(i + 1))

    pos1:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i) or guide:getTopMiddleEdgePosition(i))
    pos2:set(guide.className == "DecalRoad" and guide:getMiddleEdgePosition(i + 1) or guide:getTopMiddleEdgePosition(i + 1))
    local dist = math.max(1e-12, pos2:distance(pos1))

        local n = params.randomPosOffset
        posOffset:set(getRandom(n, params.useGauss), getRandom(n, params.useGauss), params.useRandomPosZ and getRandom(n, params.useGauss) or 0)
      end

        local useXY = params.useRandomRotXY
        rotOffset:set(quatFromEuler(useXY and getRandom(n, params.useGauss) or 0, useXY and getRandom(n, params.useGauss) or 0, getRandom(n, params.useGauss)))
      end

            pos.z = z
            dirVecUp:set(core_terrain.getTerrainSmoothNormal(pos))
          end

          pos.z = be:getSurfaceHeightBelow(pos + vecUp)
          dirVecUp:set(map.surfaceNormal(pos, 1))
        end

      pos.z = pos.z + posOffset.z -- adjust after snapping
      dirVec:set((pos2 - pos1):normalized() * dirForwards)

      if params.useCross then
        dirVec:set(dirVec:cross(dirVecUp) * dirSide)
      end

          tmpMat2:identity()
          tmpVec1:set(px, py, pz)
          tmpMat1:setPosition(tmpVec1)

          tmpVec1:set(rad(-op.x), rad(-op.y), rad(-op.z))
          tmpMat2:setFromEuler(tmpVec1)

          tmpMat2:identity()
          tmpVec1:set(-px, -py, -pz)
          tmpMat2:setPosition(tmpVec1)

        else
          tmpVec1:set(rad(-op.x), rad(-op.y), rad(-op.z))
          tmpMat1:setFromEuler(tmpVec1)

        tmpMat1:identity()
        tmpVec1:set(cachePosXSign * op.x, op.y, op.z)
        tmpMat1:setPosition(tmpVec1)

        tmpMat1:identity()
        tmpVec1:set(op.x, op.y, op.z)
        tmpMat1:setPosition(tmpVec1)

  if cacheUsingMatrixMath then
    tmpVec1:set(x, y, z)
    tmpVec1:set(cacheOpsMat:mulP3F(tmpVec1))

    tmpVec1:set(x, y, z)
    tmpVec1:set(cacheOpsMat:mulP3F(tmpVec1))
    return tmpVec1.x, tmpVec1.y, tmpVec1.z

  if cacheUsingMatrixMath then
    tmpVec1:set(rad(-rx), rad(-ry), rad(-rz))
    tmpMat1:setFromEuler(tmpVec1)

    tmpMat1:mul(cacheOpsMat)
    tmpVec1:set(x, y, z)
    tmpVec1:set(cacheOpsMat:mulP3F(tmpVec1))

    tmpVec1:set(x, y, z)
    tmpVec1:set(cacheOpsMat:mulP3F(tmpVec1))
    local eulerRot = tmpMat1:toEuler()

      tmpVec1:set(rad(-rx), rad(-ry), rad(-rz))
      tmpMat1:setFromEuler(tmpVec1)

      tmpMat1:mul(opsMat)
      tmpVec1:set(x, y, z)
      tmpVec1:set(opsMat:mulP3F(tmpVec1))

      tmpVec1:set(x, y, z)
      tmpVec1:set(opsMat:mulP3F(tmpVec1))
      local eulerRot = tmpMat1:toEuler()

        this._probes.push(probe);
        this._probesByIdentifier.set(probe.id, probe);

    local smJer = smootherJer:getUncapped(jer, dtSim)
    if smJer > 2 then smootherJer:set(2) smJer = 2 end
    local smoothness = max(abs(smAcc) + smJer)

    observations.set(target, new ResizeObservation(target));

    observers.set(this, observer);
};

        this._durationByTaskType.set(taskType, duration);
        return duration;

  selectionCentroidValid = true
  selectionCentroid:set(0, 0, 0)
  selectionBoxCentroid = selectionCentroid

  editor.objectSelectionBBox = Box3F()
  editor.objectSelectionBBox.minExtents:set(editor.FloatMax, editor.FloatMax, editor.FloatMax)
  editor.objectSelectionBBox.maxExtents:set(editor.FloatMin, editor.FloatMin, editor.FloatMin)

  editor.objectSelectionBBox.minExtents:set(editor.FloatMax, editor.FloatMax, editor.FloatMax)
  editor.objectSelectionBBox.maxExtents:set(editor.FloatMin, editor.FloatMin, editor.FloatMin)

  local bbox = Box3F()
  bbox.minExtents:set(editor.FloatMax, editor.FloatMax, editor.FloatMax)
  bbox.maxExtents:set(editor.FloatMin, editor.FloatMin, editor.FloatMin)

  bbox.minExtents:set(editor.FloatMax, editor.FloatMax, editor.FloatMax)
  bbox.maxExtents:set(editor.FloatMin, editor.FloatMin, editor.FloatMin)

    local obj = getObjectByID(vehId)
    camPos:set(core_camera.getPositionXYZ())
    vehPos:set(obj:getPositionXYZ())

    camPos:set(core_camera.getPositionXYZ())
    vehPos:set(obj:getPositionXYZ())

    if camPos:distance(vehPos) > deleteDistance then
      camDir:set(core_camera.getForwardXYZ())
      local camToVeh = vehPos - camPos

      $scope.$on("hide_ui", function (event, visible) {
        let cmd = visible === undefined ? `extensions.ui_visibility.toggleCef()` : `extensions.ui_visibility.set(${visible})`
        console.error("The hide_ui function is deprecated and will stop working in the future. Please use " + cmd)

  const registerStep = stepConfig => stepRegistry.value.set(stepConfig.id, stepConfig)
  const unregisterStep = stepId => stepRegistry.value.delete(stepId)

        abo:set(tonumber(ab.idRef), tonumber(ab.idX), tonumber(ab.idY))

            let node = new WI.LayerTreeDataGridNode(layer);
            this._dataGridNodesByLayerId.set(layer.layerId, node);
            this._dataGrid.appendChild(node);

  -- Rotational acceleration compensation at sensor location
  refNodeCoGTransformationOmega:set(sensorHub.rollAV, sensorHub.pitchAV, sensorHub.yawAV)
  refNodeCoGTransformationAlpha:set((refNodeCoGTransformationOmega.x - refNodeCoGTransformationLastOmega.x) / dt, (refNodeCoGTransformationOmega.y - refNodeCoGTransformationLastOmega.y) / dt, (refNodeCoGTransformationOmega.z - refNodeCoGTransformationLastOmega.z) / dt)

  refNodeCoGTransformationOmega:set(sensorHub.rollAV, sensorHub.pitchAV, sensorHub.yawAV)
  refNodeCoGTransformationAlpha:set((refNodeCoGTransformationOmega.x - refNodeCoGTransformationLastOmega.x) / dt, (refNodeCoGTransformationOmega.y - refNodeCoGTransformationLastOmega.y) / dt, (refNodeCoGTransformationOmega.z - refNodeCoGTransformationLastOmega.z) / dt)
  refNodeCoGTransformationLastOmega:set(refNodeCoGTransformationOmega.x, refNodeCoGTransformationOmega.y, refNodeCoGTransformationOmega.z)

  refNodeCoGTransformationAlpha:set((refNodeCoGTransformationOmega.x - refNodeCoGTransformationLastOmega.x) / dt, (refNodeCoGTransformationOmega.y - refNodeCoGTransformationLastOmega.y) / dt, (refNodeCoGTransformationOmega.z - refNodeCoGTransformationLastOmega.z) / dt)
  refNodeCoGTransformationLastOmega:set(refNodeCoGTransformationOmega.x, refNodeCoGTransformationOmega.y, refNodeCoGTransformationOmega.z)

  refNodeCoGTransformationAccRefNode:set(sensorHub.accelerationX, sensorHub.accelerationY, sensorHub.accelerationZ)
  refNodeCoGTransformationAccCoG:set(refNodeCoGTransformationAccRefNode.x - rotAcc.x, refNodeCoGTransformationAccRefNode.y - rotAcc.y, refNodeCoGTransformationAccRefNode.z - rotAcc.z)

  refNodeCoGTransformationAccRefNode:set(sensorHub.accelerationX, sensorHub.accelerationY, sensorHub.accelerationZ)
  refNodeCoGTransformationAccCoG:set(refNodeCoGTransformationAccRefNode.x - rotAcc.x, refNodeCoGTransformationAccRefNode.y - rotAcc.y, refNodeCoGTransformationAccRefNode.z - rotAcc.z)

  local pos = self:getPosition()
  posCache:set(pos)
  self.lastRecalculateVehiclePos = posCache

local function lerpColor(a,b,t)
  lerpedColor:set(lerp(a[1],b[1],t), lerp(a[2],b[2],t), lerp(a[3],b[3],t))
  return lerpedColor

  playerPosition:set(core_camera.getPosition())

    left:updateInstanceRenderData()
    scale:set(sideRadius, sideRadius, sideHeight)
    left:setScale(scale)

    right:updateInstanceRenderData()
    scale:set(sideRadius, sideRadius, sideHeight)
    right:setScale(scale)

    -- Backward slope.
    ab:set(p1.x - p0.x, p1.y - p0.y, 0)
    local horizLenBack = ab:length() + epsilon

    -- Forward slope.
    bc:set(p2.x - p1.x, p2.y - p1.y, 0)
    local horizLenFwd = bc:length() + epsilon

    -- Compute the corner radius.
    tmp1:set(divPoints[iBack].x, divPoints[iBack].y, 0) -- Do in 2D.
    tmp2:set(divPoints[i].x, divPoints[i].y, 0)

    tmp1:set(divPoints[iBack].x, divPoints[iBack].y, 0) -- Do in 2D.
    tmp2:set(divPoints[i].x, divPoints[i].y, 0)
    tmp3:set(divPoints[iFwd].x, divPoints[iFwd].y, 0)

    tmp2:set(divPoints[i].x, divPoints[i].y, 0)
    tmp3:set(divPoints[iFwd].x, divPoints[iFwd].y, 0)
    local radius = geom.computeTurningRadius(tmp1, tmp2, tmp3)

    if tangentHoriz:length() < epsilon then
      tangentHoriz:set(1, 0, 0) -- Fallback to X axis if vertical.
    else

    local p0, p1 = divPoints[i], divPoints[iPlus1]
    tmp1:set(p0.x, p0.y, 0)
    tmp2:set(p1.x, p1.y, 0)

    tmp1:set(p0.x, p0.y, 0)
    tmp2:set(p1.x, p1.y, 0)
    local d = tmp1:distance(tmp2) + epsilon

    local a, b = nodes[iMinus1], nodes[i]
    tmp1:set(b.x, b.y, 0)
    tmp2:set(a.x, a.y, 0)

    tmp1:set(b.x, b.y, 0)
    tmp2:set(a.x, a.y, 0)
    dists[i] = dists[iMinus1] + tmp1:distance(tmp2)

  local p0, p1, p2 = nodes[i - 1], nodes[i], nodes[i + 1]
  p0_2D:set(p0.x, p0.y, 0)
  p1_2D:set(p1.x, p1.y, 0)

  p0_2D:set(p0.x, p0.y, 0)
  p1_2D:set(p1.x, p1.y, 0)
  p2_2D:set(p2.x, p2.y, 0)

  p1_2D:set(p1.x, p1.y, 0)
  p2_2D:set(p2.x, p2.y, 0)
  local slope1 = abs(p1.z - p0.z) / (p0_2D:distance(p1_2D) + epsilon)

    local iMinus1 = i - 1
    tmp1:set(nodes[i])
    tmp1.z = 0.0

    tmp1.z = 0.0
    tmp2:set(nodes[iMinus1])
    tmp2.z = 0.0

  -- Should always be facing the camera
  playerPosition:set(core_camera.getPosition())

            let value = WI.Resource.Type[key];
            typeToLabelMap.set(value, WI.Resource.displayNameForType(value, true));
        }

            this._resourceDataGridNodeMap.set(resourceTimelineRecord.resource, dataGridNode);

  -- Convert the AABB from world space to grid space.
  tmp1:set(box.xMin, box.yMin, 0) te:worldToGridByPoint2I(tmp1, gMin, tb)
  tmp1:set(box.xMax, box.yMax, 0) te:worldToGridByPoint2I(tmp1, gMax, tb)

  tmp1:set(box.xMin, box.yMin, 0) te:worldToGridByPoint2I(tmp1, gMin, tb)
  tmp1:set(box.xMax, box.yMax, 0) te:worldToGridByPoint2I(tmp1, gMax, tb)
  local gMinX, gMinY, gMaxX, gMaxY = gMin.x, gMin.y, gMax.x, gMax.y

      tmpPoint2I.x, tmpPoint2I.y = x, y
      posWS:set(te:gridToWorldByPoint2I(tmpPoint2I, tb))
      local idx = (y - gMinY) * width + (x - gMinX) + 1 -- 2D -> 1D index used for the mask.

  -- Update the grid.
  tmp1:set(gMinX, gMinY, 0)
  tmp2:set(gMaxX, gMaxY, 0)

  tmp1:set(gMinX, gMinY, 0)
  tmp2:set(gMaxX, gMaxY, 0)
  tb:updateGrid(tmp1, tmp2)

  -- Update the grid.
  tmp1:set(spline.riverbedDataBoxXMin, spline.riverbedDataBoxYMin, 0)
  tmp2:set(spline.riverbedDataBoxXMax, spline.riverbedDataBoxYMax, 0)

  tmp1:set(spline.riverbedDataBoxXMin, spline.riverbedDataBoxYMin, 0)
  tmp2:set(spline.riverbedDataBoxXMax, spline.riverbedDataBoxYMax, 0)
  tb:updateGrid(tmp1, tmp2)

    local a, b, c, d = vec3(), vec3(), vec3(), vec3()
    a:set(v.pos) a.z = a.z+self.fenceDown
    b:set(v.pos) b.z = b.z+self.fenceHeight

    a:set(v.pos) a.z = a.z+self.fenceDown
    b:set(v.pos) b.z = b.z+self.fenceHeight
    c:set(self.vertices[v.next].pos) c.z = c.z+self.fenceHeight

    b:set(v.pos) b.z = b.z+self.fenceHeight
    c:set(self.vertices[v.next].pos) c.z = c.z+self.fenceHeight
    d:set(self.vertices[v.next].pos) d.z = d.z+self.fenceDown

    c:set(self.vertices[v.next].pos) c.z = c.z+self.fenceHeight
    d:set(self.vertices[v.next].pos) d.z = d.z+self.fenceDown
    if self.usePlanes then

    a:set(from) a.z = a.z+down
    b:set(from) b.z = b.z+up

    a:set(from) a.z = a.z+down
    b:set(from) b.z = b.z+up
    c:set(to) c.z = c.z+up

    b:set(from) b.z = b.z+up
    c:set(to) c.z = c.z+up
    d:set(to) d.z = d.z+down

    c:set(to) c.z = c.z+up
    d:set(to) d.z = d.z+down
    if usePlanes then

  p1:set(p.x, p.y + r, p.z + hr)
  p2:set(p.x + 0.8660254037844386 * r, p.y - 0.5 * r, p1.z) -- sin(60) => 0.8660254037844386, cos(60) => 0.5

  p1:set(p.x, p.y + r, p.z + hr)
  p2:set(p.x + 0.8660254037844386 * r, p.y - 0.5 * r, p1.z) -- sin(60) => 0.8660254037844386, cos(60) => 0.5
  local p3 = p2:copy()

  if min(p1.z, p2.z, p3.z) + hr < p.z then
    p3:set(0, 0, 1)
  else

    p1:setSub(p3)
    p3:set(p2.y * p1.z - p2.z * p1.y, p2.z * p1.x - p2.x * p1.z, p2.x * p1.y - p2.y * p1.x) -- p2 x p1
    p3:normalize()

            local n1Pos = nodePositions[n1id]
            edgeVec:set(nodePositions[n2id])
            edgeVec:setSub(n1Pos)

            edgeVec:setSub(n1Pos)
            tmpVec:set(position)
            tmpVec:setSub(n1Pos) -- node1ToPosVec

  velocity:set(v:getVelocityXYZ())
  if velocity:length() < 8 then cancel(); return end

  velocity:normalize()
  -- vpos:set(v:getPositionXYZ())
  vdir:set(v:getDirectionVectorXYZ())

  -- vpos:set(v:getPositionXYZ())
  vdir:set(v:getDirectionVectorXYZ())

      -- log("I","","back"..dumps(simTime))
      backingdir:set(vdir)
      frontTimer = 1

      local pWS_3F = te:gridToWorldByPoint2I(Point2I(gX, gY), tb)
      pWS:set(pWS_3F.x, pWS_3F.y, 0)

      local pWS_3F = te:gridToWorldByPoint2I(Point2I(gX, gY), tb)
      pWS:set(pWS_3F.x, pWS_3F.y, 0)

      pDiv[ctr] = catmullRom(p1, p2, p3, p4, q)
      tmp1:set(p1.x, p1.y, widths[i1] * 0.5)
      tmp2:set(p2.x, p2.y, widths[i2] * 0.5)

      tmp1:set(p1.x, p1.y, widths[i1] * 0.5)
      tmp2:set(p2.x, p2.y, widths[i2] * 0.5)
      tmp3:set(p3.x, p3.y, widths[i3] * 0.5)

      tmp2:set(p2.x, p2.y, widths[i2] * 0.5)
      tmp3:set(p3.x, p3.y, widths[i3] * 0.5)
      tmp4:set(p4.x, p4.y, widths[i4] * 0.5)

      tmp3:set(p3.x, p3.y, widths[i3] * 0.5)
      tmp4:set(p4.x, p4.y, widths[i4] * 0.5)
      wDiv[ctr] = catmullRom(tmp1, tmp2, tmp3, tmp4, q).z

      local d = json[j]
      tmp1:set(d.x, d.y, 0)
      nodes[j] = vec3(d.x, d.y, core_terrain.getTerrainHeight(tmp1))

        local vehPos = veh:getPosition()
        skipEventPos:set(nextEvent.pos[1], nextEvent.pos[2], nextEvent.pos[3])
        local distanceSq = vehPos:squaredDistance(skipEventPos)

                        workerData.dataPoints.push({time, usage: 0});
                        workersDataMap.set(targetId, workerData);
                    }

            if (entry)
                map.set(key, entry + 1);
            else

            else
                map.set(key, 1);
        }

                    else
                        repeatingTimers.set(record.details, {record, count: 1});
                } else

        local oobb = veh:getSpawnWorldOOBB()
        self.zOffset:set(veh:getDirectionVectorUp() * oobb:getHalfExtents().z) -- vertical midpoint of vehicle
        for i, v in ipairs(self.bbPoints) do

        for i, v in ipairs(self.bbPoints) do
          self.points[i]:set(oobb:getPoint(v) + self.zOffset)
        end

        end
        self.points[1]:set(veh:getPosition())
      end

local function transformInstanceActionUndo(data)
  instances[selected.signal].pos:set(data.oldTransform.pos)
  instances[selected.signal].dir = vecY:rotated(data.oldTransform.rot)

local function transformInstanceActionRedo(data)
  instances[selected.signal].pos:set(data.newTransform.pos)
  instances[selected.signal].dir = vecY:rotated(data.newTransform.rot)

    if editor.getAxisGizmoMode() == editor.AxisGizmoMode_Translate then
      instances[selected.signal].pos:set(editor.getAxisGizmoTransform():getColumn(3))
    elseif editor.getAxisGizmoMode() == editor.AxisGizmoMode_Rotate then

    inputWidth = 100 * im.uiscale[0]
    mousePos:set(staticRayCast() or vec3())

        let lineNumberWithIndicator = sourceCodeLocation.formattedLineNumber;
        this._threadTargetMap.set(target, lineNumberWithIndicator);

            threads = [];
            this._threadLineNumberMap.set(lineNumberWithIndicator, threads);
        }

        this._threadWidgetMap.set(lineNumber, widget);

            lineNumberIssues = [];
            this._issuesLineNumberMap.set(lineNumber, lineNumberIssues);
        }

        this._widgetMap.set(lineNumber, widget);

local function calculateDriftAngle(vehData)
  dirVec:set(vehData.dirVec)
  tempVec:set(vehData.vel)

  dirVec:set(vehData.dirVec)
  tempVec:set(vehData.vel)
  tempVec:normalize()

    debugDrawer:drawLine(center, center + dirVec, ColorF(1,0,0,1))
    velocityTip:set(center + vehData.vel:normalized())
    debugDrawer:drawLine(center, velocityTip, ColorF(1,0.3,0,1))

local function calculateVehCenterAndWheels()
  halfAxis0:set(be:getObjectOOBBHalfAxisXYZ(vehId, 0))
  halfAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))

  halfAxis0:set(be:getObjectOOBBHalfAxisXYZ(vehId, 0))
  halfAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))
  halfAxis2:set(be:getObjectOOBBHalfAxisXYZ(vehId, 2))

  halfAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))
  halfAxis2:set(be:getObjectOOBBHalfAxisXYZ(vehId, 2))
  oobbCenter:set(be:getObjectOOBBCenterXYZ(vehId))

  halfAxis2:set(be:getObjectOOBBHalfAxisXYZ(vehId, 2))
  oobbCenter:set(be:getObjectOOBBCenterXYZ(vehId))
  corner_FL:set(-push3(halfAxis1)+push3(oobbCenter)+push3(halfAxis0)-push3(halfAxis2)+push3(raycastHeightVec))

  oobbCenter:set(be:getObjectOOBBCenterXYZ(vehId))
  corner_FL:set(-push3(halfAxis1)+push3(oobbCenter)+push3(halfAxis0)-push3(halfAxis2)+push3(raycastHeightVec))
  corner_FR:set(-push3(halfAxis1)+push3(oobbCenter)-push3(halfAxis0)-push3(halfAxis2)+push3(raycastHeightVec))

  corner_FL:set(-push3(halfAxis1)+push3(oobbCenter)+push3(halfAxis0)-push3(halfAxis2)+push3(raycastHeightVec))
  corner_FR:set(-push3(halfAxis1)+push3(oobbCenter)-push3(halfAxis0)-push3(halfAxis2)+push3(raycastHeightVec))
  corner_BR:set(push3(halfAxis1)+push3(oobbCenter)+push3(halfAxis0)-push3(halfAxis2)+push3(raycastHeightVec))

  corner_FR:set(-push3(halfAxis1)+push3(oobbCenter)-push3(halfAxis0)-push3(halfAxis2)+push3(raycastHeightVec))
  corner_BR:set(push3(halfAxis1)+push3(oobbCenter)+push3(halfAxis0)-push3(halfAxis2)+push3(raycastHeightVec))
  corner_BL:set(push3(halfAxis1)+push3(oobbCenter)-push3(halfAxis0)-push3(halfAxis2)+push3(raycastHeightVec))

  corner_BR:set(push3(halfAxis1)+push3(oobbCenter)+push3(halfAxis0)-push3(halfAxis2)+push3(raycastHeightVec))
  corner_BL:set(push3(halfAxis1)+push3(oobbCenter)-push3(halfAxis0)-push3(halfAxis2)+push3(raycastHeightVec))
  center:set(

  corner_BL:set(push3(halfAxis1)+push3(oobbCenter)-push3(halfAxis0)-push3(halfAxis2)+push3(raycastHeightVec))
  center:set(
    (corner_FL.x + corner_FR.x + corner_BL.x + corner_BR.x) / 4,

  frontCenter:set(
    (corner_FL.x + corner_FR.x + center.x) / 3,

  )
  rearCenter:set(
    (corner_BL.x + corner_BR.x + center.x) / 3,

local function updateReferencePointData(point)
  tempVecPos:set(point.pos)

    if point.vel then
      tempNormalizedVel:set(point.vel)
      tempNormalizedVel:normalize()

  else
    tempVecCurrVel:set(0,0,0)
  end

  point.lastFrameVel:set(tempVecCurrVel)
  point.lastFramePos:set(tempVecPos)

  point.lastFrameVel:set(tempVecCurrVel)
  point.lastFramePos:set(tempVecPos)

  point.vel:set(tempVecCurrVel)
end

  frontPointTempVec:set(dirVec)
  frontPointTempVec:setScaled(distFromCenter)

  rearPointTempVec:set(dirVec)
  rearPointTempVec:setScaled(-distFromCenter)

  frontPoint.pos:set(frontPointTempVec)
  rearPoint.pos:set(rearPointTempVec)

  frontPoint.pos:set(frontPointTempVec)
  rearPoint.pos:set(rearPointTempVec)
  updateReferencePointData(frontPoint)

    crossUpTempVec:set(dirVec:cross(up))
    frontDot = frontPoint.vel:normalized():dot(crossUpTempVec)

  tempVellDiff:setSub2(vehData.vel, lastFrameVel)
  lastFrameVel:set(vehData.vel)
  local gForce = tempVellDiff:length() / dtSim / 9.81

  velDir:set(push3(vehicleData.vel):normalized())

    driftActiveData.lastFrameVelDir:set(velDir)
    driftActiveData.totalDriftTime = driftActiveData.totalDriftTime + dtSim

    driftChainActiveData.totalDriftDistance = driftChainActiveData.totalDriftDistance + vec3DistDiff:length()
    driftActiveData.lastPos:set(vehicleData.pos)
    driftActiveData.driftDistance = driftActiveData.driftDistance + vec3DistDiff:length()

  lastFramePlPos:set(M.getVehPos())
end

  vehPos:set(vehData.pos)

      pFlip[ctr] = pFlip[ctr] or vec3()
      pFlip[ctr]:set(pClipped[i])
      wFlip[ctr] = wClipped[i]

  log('D', logTag,"-setter tests")
  obj:set('shadowDistance', 123)
  obj.shadowDistance = 123

  simTimeAuthority.set(1) -- make sure bullettime is reset
  inputActionFilter.clear(0) -- revert filtered bindings

  --reset bullet time
  simTimeAuthority.set(1)

  extensions.hook('onEndScenario', countDownTime)
  if simTimeAuthority.get() > 1/8 then simTimeAuthority.set(1/8) end -- use slowmotion during end screen
end

    scenario.endScreenController = function()
      if simTimeAuthority.get() > 1/8 then simTimeAuthority.set(1/8) end -- use slowmotion during end screen
      -- This must be the last thing triggered, allows all other systems to process scenario state POST

    scenario.endScreenController = function()
      if simTimeAuthority.get() > 1/8 then simTimeAuthority.set(1/8) end -- use slowmotion during end screen
      -- This must be the last thing triggered, allows all other systems to process scenario state POST

        for (let key in object)
            map.set(key, object[key]);
        return map;

        this.set(key, initialValue);
        return initialValue;

  end
  startEndPosTable.pos:set(pos)
  fixStartEnd(startEndPosTable, self.path[1], self.path[2])

--     local pos = veh:getNodePosition(i)
--     minExtents:set(math.min(minExtents.x, pos.x), math.min(minExtents.y, pos.y), math.min(minExtents.z, pos.z))
--     maxExtents:set(math.max(maxExtents.x, pos.x), math.max(maxExtents.y, pos.y), math.max(maxExtents.z, pos.z))

--     minExtents:set(math.min(minExtents.x, pos.x), math.min(minExtents.y, pos.y), math.min(minExtents.z, pos.z))
--     maxExtents:set(math.max(maxExtents.x, pos.x), math.max(maxExtents.y, pos.y), math.max(maxExtents.z, pos.z))

            let layerGroup = this._createLayerGroup(layer);
            this._layerGroupsById.set(layer.layerId, layerGroup);
            this._scene.add(layerGroup);

            let layerGroup = this._layerGroupsById.get(layer.layerId);
            layerGroup.position.set(layer.bounds.x, -layer.bounds.y, index * zInterval);
        });

            let [plane, outline] = this._selectedLayerGroup.children;
            plane.material.color.set(fill);
            outline.material.color.set(stroke);

            plane.material.color.set(fill);
            outline.material.color.set(stroke);
        };

        let {x, y, width, height} = this._selectedLayerGroup.userData.layer.bounds;
        this._controls.target.set(x + (width / 2), -y - (height / 2), 0);
        this._camera.position.set(x + (width / 2), -y - (height / 2), this._selectedLayerGroup.position.z + WI.Layers3DContentView._zPadding / 2);

        this._controls.target.set(x + (width / 2), -y - (height / 2), 0);
        this._camera.position.set(x + (width / 2), -y - (height / 2), this._selectedLayerGroup.position.z + WI.Layers3DContentView._zPadding / 2);
    }

        let {x, y, width, height} = this._layers[0].bounds;
        this._controls.target.set(x + (width / 2), -y - (height / 2), 0);
        this._camera.position.set(x + (width / 2), -y - (height / 2), this._controls.maxDistance - WI.Layers3DContentView._zPadding / 2);

        this._controls.target.set(x + (width / 2), -y - (height / 2), 0);
        this._camera.position.set(x + (width / 2), -y - (height / 2), this._controls.maxDistance - WI.Layers3DContentView._zPadding / 2);
    }

  data.res.rot:set(self.bigMapCamRotation)
  if self.initialCamData then

  end
  data.res.pos:set(self.bigMapCamPosition)
  return true

  else
    dirVec:set(veh:getDirectionVector())
  end

 *
 * The missing pieces here are that we do not have a transition set (within the CSS code nor within the `$animateCss` options) and the duration of the animation is
 * going to be detected from what the keyframe styles on the CSS class are. In this event, `$animateCss` will automatically create an inline transition

          if newVeh then
            lastPos:set(newVeh:getPosition())
          end

  lastPos:set(vehicleData.pos)
end

    local resolutionFactor = 800 / freeroam_bigMapMode.getVerticalResolution()
    camQuat:set(core_camera.getQuatXYZW())
    camUp:setRotate(camQuat, upVector)

        iconInfo.color = bigMapModeColorI
        tmpVec:set(data.camPos)
        tmpVec:setAdd(iconPos or vecZero)

        local iconPosColumn = quatFromAxisAngle(camToClusterLeft, (resolutionFactor * -0.03 * core_camera.getFovRad())):__mul(camToUpperPoint * 1.1)
        tmpVec:set(data.camPos)
        tmpVec:setAdd(iconPosColumn or vecZero)

  -- setting up the smoothers
  self.bigMapMarkerAlphaSmoother:set(0)
end

function C:setFullAlphaInstant()
  self.bigMapMarkerAlphaSmoother:set(1)
end

            var value = WI.LayoutTimelineRecord.EventType[key];
            typeToLabelMap.set(value, WI.LayoutTimelineRecord.displayNameForEventType(value));
        }

    --print(self.oldSet)
    self.smoother:set(self.oldSet)
  end

      local pos = vec3(vec3(spawnObj:getPosition()) + y*1)
      pos:set(pos.x, pos.y, pos.z)
      local sp = path.startPositions:create(spInfo[2])

            this._mainFrameTreeElement = new WI.FolderTreeElement(mainFrame.securityOrigin, mainFrame);
            this._originTreeElementMap.set(mainFrame.securityOrigin, this._mainFrameTreeElement);
            break;

                    frameTreeElement = new WI.FolderTreeElement(origin, origin === resource.parentFrame.securityOrigin ? resource.parentFrame : null);
                    this._originTreeElementMap.set(origin, frameTreeElement);

        let targetTreeElement = new WI.WorkerTreeElement(target);
        this._workerTargetTreeElementMap.set(target, targetTreeElement);

    // over the maxlength still counts as invalid.
    attr.$set('ngTrim', 'false');
    containerCtrl.element.append(charCountEl);

      if fieldsChanged then
        sendTable.pos:set(self.position[1],self.position[2], self.position[3])
        sendTable.radius = self.radius

  for i = 1, maxMolecules * maxRigidMeshes do
    translationArray[i]:set(0, 0, 0) -- Clear all existing placement caches before use (reset to zero/identity).
    rotationArray[i]:set(0, 0, 0, 1)

    translationArray[i]:set(0, 0, 0) -- Clear all existing placement caches before use (reset to zero/identity).
    rotationArray[i]:set(0, 0, 0, 1)
  end

      local idx = iMinus1 * maxRigidMeshes + rootMeshIdx -- The 1D index of the root mesh (of this molecule), in the translation/rotation arrays.
      translationArray[idx]:set(pos)
      rotationArray[idx]:set(rootRot)

      translationArray[idx]:set(pos)
      rotationArray[idx]:set(rootRot)

          if freedomAxes and #freedomAxes > 0 then
            freedomJitterQuat:set(0, 0, 0, 1)
            for k = 1, #freedomAxes do

          idx = iMinus1 * maxRigidMeshes + toPlaceMeshIdx -- The 1D index of the to-be-placed mesh in the translation/rotation arrays.
          translationArray[idx]:set(posWS)
          rotationArray[idx]:set(aligningRot)

          translationArray[idx]:set(posWS)
          rotationArray[idx]:set(aligningRot)
        end

        local bridgeAttachPointSrc, bridgeAttachPointTgt = bridgeSourceAttachData.attachPos, bridgeTargetAttachData.attachPos
        tmpVec1:set(bridgeAttachPointSrc.x * scaleX, bridgeAttachPointSrc.y, bridgeAttachPointSrc.z * scaleZ)
        tmpVec2:set(bridgeAttachPointTgt.x * scaleX, bridgeAttachPointTgt.y, bridgeAttachPointTgt.z * scaleZ)

        tmpVec1:set(bridgeAttachPointSrc.x * scaleX, bridgeAttachPointSrc.y, bridgeAttachPointSrc.z * scaleZ)
        tmpVec2:set(bridgeAttachPointTgt.x * scaleX, bridgeAttachPointTgt.y, bridgeAttachPointTgt.z * scaleZ)

        mesh:setPosRot(finalPos.x, finalPos.y, finalPos.z, finalRot.x, finalRot.y, finalRot.z, finalRot.w)
        tmpScale:set(scaleX, 1.0, scaleZ) -- The full scaling vector (X to match span distance, Z for user sag).
        mesh.scale = tmpScale

  --self.transform = MatrixF(true)
  --self.transform:set(self.rotation:toEulerYXZ(), self.position)
  --editor.setAxisGizmoMode(self._oldGizmoMode or editor.AxisGizmoMode_Translate)

  if im.DragFloat3("##pos"..self.id,pos, 0.5) then
    self.position:set(pos[0], pos[1], pos[2])
    self:updateTransform()

  if im.DragFloat3("##scl"..self.id,scl, 0.1) then
    self.scale:set(scl[0], scl[1], scl[2])
    self:updateTransform()

    table.clear(wheels)
    point:set(vehicle:getPosition())
    vehCenter:set(vehicle:getSpawnWorldOOBB():getCenter())

    point:set(vehicle:getPosition())
    vehCenter:set(vehicle:getSpawnWorldOOBB():getCenter())
    dirVec:set(vehicle:getDirectionVector())

    vehCenter:set(vehicle:getSpawnWorldOOBB():getCenter())
    dirVec:set(vehicle:getDirectionVector())
    -- We need to identify all vehicle wheels and then calculate the distance from the start line for each wheel

      -- Point inbetween both wheels is calculated so that we can get a somewhat accurate distance measurement
      point:set((wheel1.x + wheel2.x)/2, (wheel1.y + wheel2.y)/2, (wheel1.z + wheel2.z)/2)
    end

      if currentPos and nextPos then
        dotPos:set(currentPos)
        local direction = (nextPos - currentPos):normalized()

  end
  state.crawlerData.dynamicData.prevVehPos:set(state.crawlerData.dynamicData.vehPos)

  state.crawlerData.dynamicData.vehPos:set(veh:getPositionXYZ())
  state.crawlerData.dynamicData.vehDirectionVector:set(veh:getDirectionVector())

  state.crawlerData.dynamicData.vehPos:set(veh:getPositionXYZ())
  state.crawlerData.dynamicData.vehDirectionVector:set(veh:getDirectionVector())
  state.crawlerData.dynamicData.vehDirectionVectorUp:set(veh:getDirectionVectorUp())

  state.crawlerData.dynamicData.vehDirectionVector:set(veh:getDirectionVector())
  state.crawlerData.dynamicData.vehDirectionVectorUp:set(veh:getDirectionVectorUp())
  state.crawlerData.dynamicData.vehRot:set(veh:getRotation())

  state.crawlerData.dynamicData.vehDirectionVectorUp:set(veh:getDirectionVectorUp())
  state.crawlerData.dynamicData.vehRot:set(veh:getRotation())
  state.crawlerData.dynamicData.vehVelocity:set(veh:getVelocity())

  state.crawlerData.dynamicData.vehRot:set(veh:getRotation())
  state.crawlerData.dynamicData.vehVelocity:set(veh:getVelocity())
  state.crawlerData.dynamicData.bbCenter:set(be:getObjectOOBBCenterXYZ(crawlerId))

  state.crawlerData.dynamicData.vehVelocity:set(veh:getVelocity())
  state.crawlerData.dynamicData.bbCenter:set(be:getObjectOOBBCenterXYZ(crawlerId))

  tmp1:set(veh:getDirectionVectorXYZ())
  tmp2:set(veh:getVelocityXYZ())

  tmp1:set(veh:getDirectionVectorXYZ())
  tmp2:set(veh:getVelocityXYZ())
  tmp1.z = 0

        local sy1, sy2 = floor(yy), ceil(yy)
        tmp0:set(sx1, sy1, 0)
        tmp1:set(sx1, sy1, core_terrain.getTerrainHeight(tmp0))

        tmp0:set(sx1, sy1, 0)
        tmp1:set(sx1, sy1, core_terrain.getTerrainHeight(tmp0))
        local dSq = tmp1:squaredDistanceToLineSegment(c1, c2)

        tmp0:set(sx1, sy2, 0)
        tmp1:set(sx1, sy2, core_terrain.getTerrainHeight(tmp0))

        tmp0:set(sx1, sy2, 0)
        tmp1:set(sx1, sy2, core_terrain.getTerrainHeight(tmp0))
        local dSq = tmp1:squaredDistanceToLineSegment(c1, c2)

        tmp0:set(sx2, sy1, 0)
        tmp1:set(sx2, sy1, core_terrain.getTerrainHeight(tmp0))

        tmp0:set(sx2, sy1, 0)
        tmp1:set(sx2, sy1, core_terrain.getTerrainHeight(tmp0))
        local dSq = tmp1:squaredDistanceToLineSegment(c1, c2)

        tmp0:set(sx2, sy2, 0)
        tmp1:set(sx2, sy2, core_terrain.getTerrainHeight(tmp0))

        tmp0:set(sx2, sy2, 0)
        tmp1:set(sx2, sy2, core_terrain.getTerrainHeight(tmp0))
        local dSq = tmp1:squaredDistanceToLineSegment(c1, c2)

            domBreakpointNodeIdentifierMap = new Multimap;
            this._domBreakpointFrameIdentifierMap.set(frameIdentifier, domBreakpointNodeIdentifierMap);
        }

    for (let tabClass of productionTabClasses)
        WI._knownTabClassesByType.set(tabClass.Type, tabClass);

                WI._overridenDeviceSettings.set(setting, value);
                callback(true);

--   if vehicleData then
--     vehPos:set(vehicleData.pos)
--     vehRot:setFromDir(vehicleData.dirVec, vehicleData.dirVecUp)

--     vehRot:setFromDir(vehicleData.dirVec, vehicleData.dirVecUp)
--     vehVel:set(vehicleData.vel)
--   end

  if vehicleData then
    -- vehPos:set(vehicleData.pos)
    vehPos:set(rallyUtil.getVehFrontCenter(veh:getId()))

    -- vehPos:set(vehicleData.pos)
    vehPos:set(rallyUtil.getVehFrontCenter(veh:getId()))
    vehRot:setFromDir(vehicleData.dirVec, vehicleData.dirVecUp)

    vehRot:setFromDir(vehicleData.dirVec, vehicleData.dirVecUp)
    vehVel:set(vehicleData.vel)
  end

        let targetTreeElement = new WI.WorkerTreeElement(target);
        this._targetTreeElementMap.set(target, targetTreeElement);

    local rot = {self.pinIn.x.value or 0, self.pinIn.y.value or 0, self.pinIn.z.value or 0, self.pinIn.w.value or 0}
    quatOut:set(rot[1], rot[2], rot[3], rot[4])
    self.pinOut.value.value = {quatOut.x, quatOut.y, quatOut.z, quatOut.w}

  -- Every node in the output graph is also a node in the input graph.
  -- Every edge in the output graph stores the set (array) of input graph nodes that connect the output graph edge nodes (end nodes included)
  -- ex. edge a <-> b i.e. minorGraph[a][b] = {a, x, y, z, b} -> node a is conected to node b through nodes x, y, z

        nodeLinks = graph[node]
        nodePos:set(positions[node])
      else

    local inFwdFlow, inBackFlow, inDrivability, inGated = radius[prevPath[1]], 0, 1, false
    curSegDir:set(prevPathInitDir.x, prevPathInitDir.y, 0); curSegDir:normalize()

        else
          curSegDir:set(initDir.x, initDir.y, 0); curSegDir:normalize()
          inFwdFlow, inBackFlow, inDrivability, inGated = radius[start], 0, 1, false

        else
          curSegDir:set(prevPathInitDir.x, prevPathInitDir.y, 0); curSegDir:normalize()
          inFwdFlow, inBackFlow, inDrivability, inGated = radius[prevPath[1]], 0, 1, false

    -- randomize dir
    prevDir:set(
      prevDir.x + (random() * rnd2 - rndDirCoef) * rDistCoef,

    local rDistDirCoef = min(1, pathLen * rndDistCoef) * rndDirCoef
    prevDir:set(
      prevDir.x + (random() * 2 - 1) * rDistDirCoef,

  setTargetSpeed(val)
  simulationSpeed_smooth:set(M.simulationSpeed)
end

    else
      simulationSpeed_smooth:set(initialTimeScale) -- start smoother in current value, not in zero
      setTargetSpeed(initialTimeScale) -- restore the original physics scale

      if getPause() then
        simulationSpeed_smooth:set(0)
        be:setEnabled(true)

        targetData = new WI.DebuggerData(target);
        this._targetDebuggerDataMap.set(target, targetData);
        return targetData;

            this._breakpointIdMap.set(breakpointIdentifier, breakpoint);

        this._knownProbeIdentifiersForBreakpoint.set(breakpoint, new Set);

                let newProbe = new WI.Probe(probeIdentifier, breakpoint, probeAction.data);
                this._probesByIdentifier.set(probeIdentifier, newProbe);
                probeSet.addProbe(newProbe);

            probeSet = new WI.ProbeSet(breakpoint);
            this._probeSetsByBreakpoint.set(breakpoint, probeSet);
            this.dispatchEventToListeners(WI.DebuggerManager.Event.ProbeSetAdded, {probeSet});

  self:set()

-- sets the position, rotation and scale of the helper. nil parameters are ignored,
-- so you can only set the rotation with :set(nil, quat(...), nil) for example
function C:set(pos, rot, scl)

-- so you can only set the rotation with :set(nil, quat(...), nil) for example
function C:set(pos, rot, scl)
  if self.oneDimensionalScale then

    local rot = quatFromDir(fwd, mouseInfo._downNormal):normalized()
    self:set(mouseInfo._downPos,
        self._temp.moved and self.allowRotate and rot,

          if self._temp then
            self:set(self._temp.pos, self._temp.rot, self._temp.scl)
            self._temp = nil

function C:helperPositionToCamera()
  self:set(core_camera.getPosition())
end

function C:helperPositionInFrontOfToCamera()
  self:set(vec3(core_camera.getQuat() * vec3(0, 15, 0)) + core_camera.getPosition())
end

  if not core_terrain.getTerrain() then return end
  self:set(vec3(self.pos.x, self.pos.y, core_terrain.getTerrainHeight(self.pos) or self.pos.z))
end

function C:helperRotationToCamera()
  self:set(nil , core_camera.getQuat())
end

  local fwd = (self.rot * vec3(0,1,0)):projectToOriginPlane(terrainNormal)
  self:set(nil, quatFromDir(fwd, terrainNormal))
end

function C:helperRotateWithCamera()
  self:set(nil, core_camera.getQuat())
end

  editor.clearObjectSelection()
  self:set()
end

  lastFramePos:set(gameplay_drift_drift.getVehPos())
end

    elems.set(el, {
      updateFrustum: updateDebounce,

    icon.visible = icon.remaining > 0
    tmpVec:set(icon.pos)
    tmpVec:setSub(camPos)

  oilpanAccXYSmoother:reset()
  oilpanAccZSmoother:set(-powertrain.currentGravity)

  oilpanMaximumSafeG = jbeamData.oilpanMaximumSafeG or 1.2
  oilpanAccZSmoother:set(-powertrain.currentGravity)

  rgbaBuffer:reset()
  rgbaBuffer:set(data, ffi.sizeof(data))
  if not bitmap:fromBuffer(rgbaBuffer) then

  pos1:set(be:getObjectOOBBCenterXYZ(self.pinIn.vehId1.value))
  pos2:set(be:getObjectOOBBCenterXYZ(self.pinIn.vehId2.value))

  pos1:set(be:getObjectOOBBCenterXYZ(self.pinIn.vehId1.value))
  pos2:set(be:getObjectOOBBCenterXYZ(self.pinIn.vehId2.value))

      -- pos = pos + vel * dt
      scaledVel:set(vel); scaledVel:setScaled(dt)
      pos:setAdd(scaledVel)

                      tailPos:set(inPos)
                      tailPos:setAdd2(tailPos, right1 * offset + vec3(0,0,0.5)) -- Offset + height

                         tailPos:setAdd(dispVec)
                         tipPos:set(tailPos)
                         tipPos:setAdd(arrowLengthVec)

    if options[key] and type(options[key].set) == 'function' then
      options[key].set(value)
    end

            this.element.appendChild(tabItemElement);
            this._tabElementsByTabClass.set(tabClass, tabItemElement);
        }

function temporalSpring:set(sample)
  self.state = sample

function temporalSigmoidSmoothing:set(sample)
  self.state = sample

function temporalSmoothingNonLinear:set(sample)
  self.state = sample

function temporalSmoothing:set(v)
  self.state = v

function linearSmoothing:set(v)
  self.state = v

function nopSmoothing:set()
end

function exponentialSmoothing:set(value)
  self.st = value

function exponentialSmoothingT:set(value)
  self.st = value

function lineFitting:set(window, weight, bias)
  self.weight = weight or self.weight

                min.set( minVal, minVal );
                max.set( maxVal, maxVal );

                min.set( minVal, minVal );
                max.set( maxVal, maxVal );

            console.error( 'THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.' );

            this.set(

            this.set(
                xAxis.x, yAxis.x, zAxis.x, 0,

            this.set(

            this.set(

            this.set(

            this.set(

            this.set(

            this.set(

            this.set(

                var sx = vector.set( te[ 0 ], te[ 1 ], te[ 2 ] ).length();
                var sy = vector.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length();

                var sx = vector.set( te[ 0 ], te[ 1 ], te[ 2 ] ).length();
                var sy = vector.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length();
                var sz = vector.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length();

                var sy = vector.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length();
                var sz = vector.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length();

                        v1.set( - vFrom.y, vFrom.x, 0 );

                        v1.set( 0, - vFrom.z, vFrom.y );

                min.set( minVal, minVal, minVal );
                max.set( maxVal, maxVal, maxVal );

                min.set( minVal, minVal, minVal );
                max.set( maxVal, maxVal, maxVal );

            console.error( 'THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.' );

            this.set(

            this.set(

            this.set(
                sx * c, sx * s, - sx * ( c * cx + s * cy ) + cx + tx,

                    this.set( 1, 0, 0, 0 );

                this.set( x, y, z, angle );

                min.set( minVal, minVal, minVal, minVal );
                max.set( maxVal, maxVal, maxVal, maxVal );

                min.set( minVal, minVal, minVal, minVal );
                max.set( maxVal, maxVal, maxVal, maxVal );

            this.viewport.set( 0, 0, width, height );
            this.scissor.set( 0, 0, width, height );

            this.viewport.set( 0, 0, width, height );
            this.scissor.set( 0, 0, width, height );

            this.min.set( minX, minY, minZ );
            this.max.set( maxX, maxY, maxZ );

            this.min.set( minX, minY, minZ );
            this.max.set( maxX, maxY, maxZ );

            this.min.set( minX, minY, minZ );
            this.max.set( maxX, maxY, maxZ );

            this.min.set( minX, minY, minZ );
            this.max.set( maxX, maxY, maxZ );

            return this.isEmpty() ? target.set( 0, 0, 0 ) : target.addVectors( this.min, this.max ).multiplyScalar( 0.5 );

            return this.isEmpty() ? target.set( 0, 0, 0 ) : target.subVectors( this.max, this.min );

            return target.set(
                ( point.x - this.min.x ) / ( this.max.x - this.min.x ),

            target.set( this.center, this.center );
            target.expandByScalar( this.radius );

            this.normal.set( x, y, z );
            this.constant = w;

                sphere.center.set( 0, 0, 0 );
                sphere.radius = 0.7071067811865476;

            // r is THREE.Color, hex or string
            return this.set( r );

                buffers.set( attribute, createBuffer( attribute, bufferType ) );

            return this.set( v.x, v.y, v.z, order || this._order );

                return optionalResult.set( this._x, this._y, this._z );

                    vector.set( x, y, z );

                return target.set( 0, 0, 1 ).applyQuaternion( quaternion );

                return target.set( 0, 0, - 1 ).applyQuaternion( quaternion );

            var matrix = new Matrix4();
            matrix.set(
                s, 0, 0, - s * center.x,

            this.array.set( array );

            this.array.set( value, offset );

                    currentValue.set( newValue );

                return target.set( 0, 0, 0 );

                    // not sure if this is the best idea, maybe should be returning undefined
                    return target.set( - 2, - 1, - 1 );

                // barycentric coordinates must always sum to 1
                return target.set( 1 - u - v, v, u );

                    edgeList[ 0 ].set( this.a, this.b );
                    edgeList[ 1 ].set( this.b, this.c );

                    edgeList[ 0 ].set( this.a, this.b );
                    edgeList[ 1 ].set( this.b, this.c );
                    edgeList[ 2 ].set( this.c, this.a );

                    edgeList[ 1 ].set( this.b, this.c );
                    edgeList[ 2 ].set( this.c, this.a );

                            vA.set( 0, 0, 0 );
                            vB.set( 0, 0, 0 );

                            vA.set( 0, 0, 0 );
                            vB.set( 0, 0, 0 );
                            vC.set( 0, 0, 0 );

                            vB.set( 0, 0, 0 );
                            vC.set( 0, 0, 0 );

                clearColor.set( color );
                clearAlpha = alpha !== undefined ? alpha : 1;

     *
     * .set( gl, obj, prop )
     *

            mat2array.set( elements );

            mat3array.set( elements );

            mat4array.set( elements );

                map = {};
                properties.set( object, map );

                    uniforms.halfWidth.set( light.width * 0.5, 0.0, 0.0 );
                    uniforms.halfHeight.set( 0.0, light.height * 0.5, 0.0 );

                    uniforms.halfWidth.set( light.width * 0.5, 0.0, 0.0 );
                    uniforms.halfHeight.set( 0.0, light.height * 0.5, 0.0 );

                    // positive X
                    cube2DViewPorts[ 0 ].set( vpWidth * 2, vpHeight, vpWidth, vpHeight );
                    // negative X

                    // negative X
                    cube2DViewPorts[ 1 ].set( 0, vpHeight, vpWidth, vpHeight );
                    // positive Z

                    // positive Z
                    cube2DViewPorts[ 2 ].set( vpWidth * 3, vpHeight, vpWidth, vpHeight );
                    // negative Z

                    // negative Z
                    cube2DViewPorts[ 3 ].set( vpWidth, vpHeight, vpWidth, vpHeight );
                    // positive Y

                    // positive Y
                    cube2DViewPorts[ 4 ].set( vpWidth * 3, 0, vpWidth, vpHeight );
                    // negative Y

                    // negative Y
                    cube2DViewPorts[ 5 ].set( vpWidth, 0, vpWidth, vpHeight );

                    shadowMatrix.set(
                        0.5, 0.0, 0.0, 0.5,

                    color.set( r, g, b, a );

                    currentColorMask = null;
                    currentColorClear.set( - 1, 0, 0, 0 ); // set to invalid state

                    if ( pose.hasPosition === false ) controller.position.set( 0.2, - 0.6, - 0.05 );

                camera.position.set( 0, scope.userHeight, 0 );
                return camera;

                    camera.projectionMatrix.fromArray( view.projectionMatrix );
                    camera.viewport.set( viewport.x, viewport.y, viewport.width, viewport.height );

            _viewport.set( x, _height - y - height, width, height );
            state.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ) );

            _scissor.set( x, _height - y - height, width, height );
            state.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ) );

            _sphere.center.set( 0, 0, 0 );
            _sphere.radius = 0.7071067811865476;

                                state.viewport( _currentViewport.set( x, y, width, height ).multiplyScalar( _pixelRatio ) );

                            var boneMatrices = new Float32Array( size * size * 4 ); // 4 floats per RGBA pixel
                            boneMatrices.set( skeleton.boneMatrices ); // copy current values

                transformVertex( vA.set( - 0.5, - 0.5, 0 ), mvPosition, center, worldScale, sin, cos );
                transformVertex( vB.set( 0.5, - 0.5, 0 ), mvPosition, center, worldScale, sin, cos );

                transformVertex( vA.set( - 0.5, - 0.5, 0 ), mvPosition, center, worldScale, sin, cos );
                transformVertex( vB.set( 0.5, - 0.5, 0 ), mvPosition, center, worldScale, sin, cos );
                transformVertex( vC.set( 0.5, 0.5, 0 ), mvPosition, center, worldScale, sin, cos );

                transformVertex( vB.set( 0.5, - 0.5, 0 ), mvPosition, center, worldScale, sin, cos );
                transformVertex( vC.set( 0.5, 0.5, 0 ), mvPosition, center, worldScale, sin, cos );

                    // check second triangle
                    transformVertex( vB.set( - 0.5, 0.5, 0 ), mvPosition, center, worldScale, sin, cos );
                    intersect = raycaster.ray.intersectTriangle( vA, vC, vB, false, intersectPoint );

                        sw.set( 1, 0, 0, 0 ); // do something reasonable

                        vec.set( 1, 0, 0, 0 ); // do something reasonable

                a.set( vertexBuffer[ i + 0 ], vertexBuffer[ i + 1 ], vertexBuffer[ i + 2 ] );
                b.set( vertexBuffer[ i + 3 ], vertexBuffer[ i + 4 ], vertexBuffer[ i + 5 ] );

                a.set( vertexBuffer[ i + 0 ], vertexBuffer[ i + 1 ], vertexBuffer[ i + 2 ] );
                b.set( vertexBuffer[ i + 3 ], vertexBuffer[ i + 4 ], vertexBuffer[ i + 5 ] );
                c.set( vertexBuffer[ i + 6 ], vertexBuffer[ i + 7 ], vertexBuffer[ i + 8 ] );

                b.set( vertexBuffer[ i + 3 ], vertexBuffer[ i + 4 ], vertexBuffer[ i + 5 ] );
                c.set( vertexBuffer[ i + 6 ], vertexBuffer[ i + 7 ], vertexBuffer[ i + 8 ] );

                uvA.set( uvBuffer[ j + 0 ], uvBuffer[ j + 1 ] );
                uvB.set( uvBuffer[ j + 2 ], uvBuffer[ j + 3 ] );

                uvA.set( uvBuffer[ j + 0 ], uvBuffer[ j + 1 ] );
                uvB.set( uvBuffer[ j + 2 ], uvBuffer[ j + 3 ] );
                uvC.set( uvBuffer[ j + 4 ], uvBuffer[ j + 5 ] );

                uvB.set( uvBuffer[ j + 2 ], uvBuffer[ j + 3 ] );
                uvC.set( uvBuffer[ j + 4 ], uvBuffer[ j + 5 ] );

                normal.set( vertex.x, vertex.y, vertex.z ).normalize();
                normals.push( normal.x, normal.y, normal.z );

                    normal.set( sinTheta, slope, cosTheta ).normalize();
                    normals.push( normal.x, normal.y, normal.z );

                min = tx;
                normal.set( 1, 0, 0 );

                min = ty;
                normal.set( 0, 1, 0 );

                normal.set( 0, 0, 1 );

        return point.set( x, y );

        point.set(
            px.calc( weight ),

        point.set(
            CubicBezier( t, v0.x, v1.x, v2.x, v3.x ),

        point.set(
            CubicBezier( t, v0.x, v1.x, v2.x, v3.x ),

        point.set(
            QuadraticBezier( t, v0.x, v1.x, v2.x ),

        point.set(
            QuadraticBezier( t, v0.x, v1.x, v2.x ),

        point.set(
            CatmullRom( weight, p0.x, p1.x, p2.x, p3.x ),

            this.currentPoint.set( x, y ); // TODO consider referencing vectors instead of copying?

            this.currentPoint.set( x, y );

            this.currentPoint.set( aX, aY );

            this.currentPoint.set( aX, aY );

                            faceA.normal.set(
                                normals[ normalIndex ++ ],

                            face.normal.set(
                                normals[ normalIndex ++ ],

        var cameraPX = new PerspectiveCamera( fov, aspect, near, far );
        cameraPX.up.set( 0, - 1, 0 );
        cameraPX.lookAt( new Vector3( 1, 0, 0 ) );

        var cameraNX = new PerspectiveCamera( fov, aspect, near, far );
        cameraNX.up.set( 0, - 1, 0 );
        cameraNX.lookAt( new Vector3( - 1, 0, 0 ) );

        var cameraPY = new PerspectiveCamera( fov, aspect, near, far );
        cameraPY.up.set( 0, 0, 1 );
        cameraPY.lookAt( new Vector3( 0, 1, 0 ) );

        var cameraNY = new PerspectiveCamera( fov, aspect, near, far );
        cameraNY.up.set( 0, 0, - 1 );
        cameraNY.lookAt( new Vector3( 0, - 1, 0 ) );

        var cameraPZ = new PerspectiveCamera( fov, aspect, near, far );
        cameraPZ.up.set( 0, - 1, 0 );
        cameraPZ.lookAt( new Vector3( 0, 0, 1 ) );

        var cameraNZ = new PerspectiveCamera( fov, aspect, near, far );
        cameraNZ.up.set( 0, - 1, 0 );
        cameraNZ.lookAt( new Vector3( 0, 0, - 1 ) );

                orientation.set( 0, 0, - 1 ).applyQuaternion( quaternion );

                orientation.set( 0, 0, 1 ).applyQuaternion( quaternion );

            this.array.set( value, offset );

            this.ray.set( origin, direction );

                this.ray.origin.setFromMatrixPosition( camera.matrixWorld );
                this.ray.direction.set( coords.x, coords.y, 0.5 ).unproject( camera ).sub( this.ray.origin ).normalize();

                this.ray.origin.set( coords.x, coords.y, ( camera.near + camera.far ) / ( camera.near - camera.far ) ).unproject( camera ); // set origin in plane of camera
                this.ray.direction.set( 0, 0, - 1 ).transformDirection( camera.matrixWorld );

                this.ray.origin.set( coords.x, coords.y, ( camera.near + camera.far ) / ( camera.near - camera.far ) ).unproject( camera ); // set origin in plane of camera
                this.ray.direction.set( 0, 0, - 1 ).transformDirection( camera.matrixWorld );

            return this.isEmpty() ? target.set( 0, 0 ) : target.addVectors( this.min, this.max ).multiplyScalar( 0.5 );

            return this.isEmpty() ? target.set( 0, 0 ) : target.subVectors( this.max, this.min );

            return target.set(
                ( point.x - this.min.x ) / ( this.max.x - this.min.x ),

                    v1.set( objPos.getX( j ), objPos.getY( j ), objPos.getZ( j ) ).applyMatrix4( matrixWorld );

                    v2.set( objNorm.getX( j ), objNorm.getY( j ), objNorm.getZ( j ) );

            this.cone.scale.set( coneWidth, coneWidth, coneLength );

                this.cone.material.color.set( this.color );

            this.lightDistance.scale.set( d, d, d );

            this.material.color.set( this.color );

            this.lightDistance.visible = true;
            this.lightDistance.scale.set( d, d, d );

            this.line.material.color.set( this.color );

                this.material.color.set( this.color );

                this.lightPlane.material.color.set( this.color );
                this.targetLine.material.color.set( this.color );

                this.lightPlane.material.color.set( this.color );
                this.targetLine.material.color.set( this.color );

            vector.set( x, y, z ).unproject( camera );

        this.scale.set( 0.5 * this.size, 0.5 * this.size, scale );

                this.quaternion.set( 0, 0, 0, 1 );

                this.quaternion.set( 1, 0, 0, 0 );

                axis.set( dir.z, 0, - dir.x ).normalize();

        this.line.scale.set( 1, Math.max( 0, length - headLength ), 1 );
        this.line.updateMatrix();

        this.cone.scale.set( headWidth, headLength, headWidth );
        this.cone.position.y = length;

        var newSection = new WI.ProbeSetDetailsSection(probeSet);
        this._probeSetSections.set(probeSet, newSection);
    }

  end
  avgConsumptionSmoother:set(20000)
  currentConsumptionSmoother:set(0)

  avgConsumptionSmoother:set(20000)
  currentConsumptionSmoother:set(0)
  currentPowerSmoother:set(0)

  currentConsumptionSmoother:set(0)
  currentPowerSmoother:set(0)
end

    scl = scale*4 * size * dpi
    f:set(fwd)
    f:setScaled(2*scl)

    side:set(fwd)
    side:setCross(side, localUp)

    side:normalize()
    tmp2:set(side)
    tmp2:setScaled(1*scl)

    tmp2:setScaled(1*scl)
    bl:set(pos)
    bl:setSub(tmp2)

    bl:setSub(tmp2)
    br:set(pos)
    br:setAdd(tmp2)

    -- Draw the circle
    tmp1:set(pos)
    ui_apps_minimap_utils.worldToMapXYZ(tmp1,tmp1)

    side:set(fwd)
    side:setCross(side, localUp)

    side:normalize()
    f:set(fwd)
    f:setScaled(1.5*scl)

    f:setAdd(pos)
    bc:set(fwd)
    bc:setScaled(-scl)

    tmp1:set(fwd)
    tmp1:setScaled(1.5*scl)

    tmp1:setScaled(1.5*scl)
    tmp2:set(side)
    tmp2:setScaled(1*scl)

    tmp2:setScaled(1*scl)
    bl:set(pos)
    bl:setSub(tmp1)

    bl:setSub(tmp2)
    br:set(pos)
    br:setSub(tmp1)

  if isWalking then
    pos:set(gameplay_walk.getPosXYZ())
    rot:set(gameplay_walk.getRotXYZW())

    pos:set(gameplay_walk.getPosXYZ())
    rot:set(gameplay_walk.getRotXYZW())
    fwd:setRotate(rot, localFwd)

    if not vehicleData then return end
    pos:set(vehicleData.pos)
    fwd:set(vehicleData.dirVec.x,vehicleData.dirVec.y,0)

    pos:set(vehicleData.pos)
    fwd:set(vehicleData.dirVec.x,vehicleData.dirVec.y,0)
    fwd:normalize()

    --drawVehicle(camPos, cameraLook, clrOrange, 1, true, layers.VEHICLE_PLAYER)
    tmp1:set(cameraLook)

    tmp1:setScaled(scale * 10 * dpi)
    tmp2:set(adjustedCamPos)
    tmp2:setAdd(tmp1)

    tmp1:setScaled(1.25)
    tmp3:set(adjustedCamPos)
    tmp3:setSub(tmp1)

    tmp3:setSub(tmp1)
    tmp1:set(adjustedCamPos)
    ui_apps_minimap_utils.worldToMapXYZ(tmp1,tmp1)

  -- nightmare to fix dtSim not being in sync with the map data
  lastPos2:set(lastPos)
  lastPos:set(pos)

  lastPos2:set(lastPos)
  lastPos:set(pos)
  lastDtSim, lastVel = dtSim, vel

      pos:set(otherVeh:getPositionXYZ())
      fwd:set(otherVeh:getDirectionVectorXYZ())

      pos:set(otherVeh:getPositionXYZ())
      fwd:set(otherVeh:getDirectionVectorXYZ())
      fwd.z = 0

    else
      ui_visibility.set(false)
      simTimeAuthority.setInstant(0.15)

      if previousSimSpeed and simTimeAuthority.get() ~= previousSimSpeed then
        simTimeAuthority.set(previousSimSpeed)
      end

      if previousUiVisibility ~= nil then
        ui_visibility.set(previousUiVisibility)
      end

  -- start the path cam
  ui_visibility.set(false)
  simTimeAuthority.pauseSmooth(true, nil, nil, nil, false)

  otherVehPos:set(be:getObjectPositionXYZ(otherId))
  if otherVehPos:distance(futurePlayerBBCenter) > 30 then return false end

  otherVel:set(be:getObjectVelocityXYZ(otherId))
  if otherVel:length() > 300 then return false end -- dont check any traffic vehicle going over 300 m/s because that is probably a teleport

  futureOtherBBCenter:set(push3(be:getObjectOOBBCenterXYZ(otherId)) + push3(otherVel) * lookAheadTime)

  otherBBHalfAxis0:set(be:getObjectOOBBHalfAxisXYZ(otherId, 0))
  otherBBHalfAxis0:setScaled(bbSizeFactor)

  otherBBHalfAxis0:setScaled(bbSizeFactor)
  otherBBHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(otherId, 1))
  otherBBHalfAxis1:setScaled(bbSizeFactor)

  otherBBHalfAxis1:setScaled(bbSizeFactor)
  otherBBHalfAxis2:set(be:getObjectOOBBHalfAxisXYZ(otherId, 2))
  otherBBHalfAxis2:setScaled(bbSizeFactor)

  playerVelNormalized:set(push3(playerVel):normalized())
  playerBBCenter:set(be:getObjectOOBBCenterXYZ(playerVehId))

  playerVelNormalized:set(push3(playerVel):normalized())
  playerBBCenter:set(be:getObjectOOBBCenterXYZ(playerVehId))
  playerAxis0:set(be:getObjectOOBBAxisNormalizedXYZ(playerVehId, 0))

  playerBBCenter:set(be:getObjectOOBBCenterXYZ(playerVehId))
  playerAxis0:set(be:getObjectOOBBAxisNormalizedXYZ(playerVehId, 0))
  playerAxis1:set(be:getObjectOOBBAxisNormalizedXYZ(playerVehId, 1))

  playerAxis0:set(be:getObjectOOBBAxisNormalizedXYZ(playerVehId, 0))
  playerAxis1:set(be:getObjectOOBBAxisNormalizedXYZ(playerVehId, 1))
  playerAxis2:set(be:getObjectOOBBAxisNormalizedXYZ(playerVehId, 2))

  playerAxis1:set(be:getObjectOOBBAxisNormalizedXYZ(playerVehId, 1))
  playerAxis2:set(be:getObjectOOBBAxisNormalizedXYZ(playerVehId, 2))

  futurePlayerBBCenter:set(push3(playerBBCenter) + push3(playerVel) * lookAheadTime)

  playerBBHalfAxis0:set(be:getObjectOOBBHalfAxisXYZ(playerVehId, 0))
  playerBBHalfAxis0:setScaled(bbSizeFactor)

  playerBBHalfAxis0:setScaled(bbSizeFactor)
  playerBBHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(playerVehId, 1))
  playerBBHalfAxis1:setScaled(bbSizeFactor)

  playerBBHalfAxis1:setScaled(bbSizeFactor)
  playerBBHalfAxis2:set(be:getObjectOOBBHalfAxisXYZ(playerVehId, 2))
  playerBBHalfAxis2:setScaled(bbSizeFactor)

    if not bottomPoints[1] then bottomPoints[1] = vec3() end
    bottomPoints[1]:set(push3(playerBBCenter) - push3(playerAxis1) * (halfExtentsY - 0.2))

      if not bottomPoints[counter] then bottomPoints[counter] = vec3() end
      bottomPoints[counter]:set(push3(bottomPoints[1]) - push3(playerAxis0) * offset)
      counter = counter + 1

      if not bottomPoints[counter] then bottomPoints[counter] = vec3() end
      bottomPoints[counter]:set(push3(bottomPoints[1]) + push3(playerAxis0) * offset)
      counter = counter + 1

  local playerVehId = be:getPlayerVehicleID(0)
  playerUpVec:set(be:getObjectOOBBHalfAxisXYZ(playerVehId, 2))
  if playerUpVec.z < 0 then

    local halfExtentsX, halfExtentsY, halfExtentsZ = be:getObjectOOBBHalfExtentsXYZ(crashCamData.id1)
    bbCenter:set(be:getObjectOOBBCenterXYZ(crashCamData.id1))
    local playerVehNormalized = playerVel:normalized()

  playerVelAtLastCheckpoint = playerVelAtLastCheckpoint or vec3()
  playerVelAtLastCheckpoint:set(playerVel)
  deltaSinceLastCheckpoint = 0

  playerPos:set(be:getObjectPositionXYZ(playerVehId))
  playerVel:set(be:getObjectVelocityXYZ(playerVehId))

  playerPos:set(be:getObjectPositionXYZ(playerVehId))
  playerVel:set(be:getObjectVelocityXYZ(playerVehId))

  end
  playerPosLast:set(playerPos)
  playerVelLast:set(playerVel)

  playerPosLast:set(playerPos)
  playerVelLast:set(playerVel)
end

          const appendCount = statsProcessor.append.get(call.type) || 0
          statsProcessor.append.set(call.type, appendCount + 1)
        } else {

          const typeCount = statsProcessor.types.get(call.type) || 0
          statsProcessor.types.set(call.type, typeCount + 1)
        }

          const count = statsProcessor.uiApps.get(targetElement) || 0
          statsProcessor.uiApps.set(targetElement, count + 1)
        }

          const fileCount = statsProcessor.files.get(filePath) || 0
          statsProcessor.files.set(filePath, fileCount + 1)
        }

    const currentCount = chainStats.get(chain) || 0
    chainStats.set(chain, currentCount + 1)
  }

      overlayElement.appendChild(overlayDiv)
      overlayDivs.set(element, overlayDiv)
    } catch (e) {

            listenersTable = new ListMultimap();
            this._listeners.set(eventType, listenersTable);
        }

      view.control.renderView.resolution = Point2I(availSize.x, availSize.y)
      tmpRect:set(0, 0, availSize.x, availSize.y)
      view.control.renderView.viewPort = tmpRect

end
function C:set(name, value)
  if not self.values[name] then

  adjustedPoint:set(intX * (math.sqrt(3) / 2) * trackPosition.unitX + intY * 0.5 * trackPosition.unitY)
  adjustedPoint.z = originalZ

    {
        this._detailNavigationItemMap.set(identifier, new WI.RadioButtonNavigationItem(identifier, toolTip));
    }

  self.columnAlphaSmoother = newTemporalSpring()
  self.columnAlphaSmoother:set(0.0)
end

  local playerPosition = vec3(0,0,0)
  playerPosition:set(core_camera.getPosition())

  if self.arrow then
    self.arrowHeightSmoother:set(arrowStartHeight)
    self.arrow:setPosition(vec3(0,0,arrowStartHeight)+self.pos)

    if self.arrowScaleSmoother then
      self.arrowScaleSmoother:set(initialScale)
    end

    }
    data.set(
      data.id,

    data.posObserver = observePosition(el, data.observe)
    elms.set(el, data)
    // run

        let snapshot = new HeapSnapshot(objectId, snapshotString, title, imported);
        this._objects.set(objectId, snapshot);

        let snapshotDiff = new HeapSnapshotDiff(objectId, snapshot1, snapshot2);
        this._objects.set(objectId, snapshotDiff);
        return {objectId, snapshotDiff: snapshotDiff.serialize()};

    {
        this._resourceDataMap.set(resource, {});
    }

        }
        this.columns.set(columnIdentifier, column);

            headerCellElement.classList.add(column["aligned"]);
        this._headerTableCellElements.set(columnIdentifier, headerCellElement);
        var referenceElement = this._headerTableRowElement.children[insertionIndex];

        this._pendingResponses.set(sequenceId, responseData);
        this._sendMessageToBackend(messageObject);

        this._pendingResponses.set(sequenceId, responseData);
        this._sendMessageToBackend(messageObject);

function C:set(id, field, val) self.variables:change(id..field, val) self.buttonsChanged = true end

    obj:queueGameEngineLua('be:queueObjectLua('..tostring(obj:getId())..', "if recovery.getFreeCamActiveFlag() ~= nil then recovery.setFreeCamActiveFlag(" .. tostring(commands.isFreeCamera()) .. ") end") commands.setFreeCamera()')
    snapshotTimeSmoother:set(1)
    blendTime = 0

      if not nodeRenderPositionsUpToDate[beam.id1] then
        t1:set(relativeNodePositions[beam.id1])
        t1:setRotate(rot)

        nodeRenderPositionsUpToDate[beam.id1] = true
        nodeRenderPositions[beam.id1]:set(p1)
      end

      if not nodeRenderPositionsUpToDate[beam.id2] then
        t2:set(relativeNodePositions[beam.id2])
        t2:setRotate(rot)

        nodeRenderPositionsUpToDate[beam.id2] = true
        nodeRenderPositions[beam.id2]:set(p2)
      end

    if not isFreeCamActive then
      camPos:set((push3(oobb[1])+oobb[4])/2 + push3(upVector) * (oobb[2].z-oobb[1].z) * 1.3 + (push3(oobb[3])-oobb[1]) * 1.5 + push3(backVec))
      tempVec:setSub2(dirFront, camOffsetVec)

local function lineTo2DPoly(start, length, hdg)
  tmp0:set(cos(hdg), sin(hdg), 0.0)
  tmp0:normalize()

  local hCos, hSin = cos(hdg), sin(hdg)
  tmp0:set(hCos, hSin, 0.0)
  tmp0:normalize()

  tmp0:normalize()
  tmp1:set(-hSin, hCos, 0.0)
  tmp1:normalize()

  local hCos, hSin = cos(hdg), sin(hdg)
  tmp0:set(hCos, hSin, 0.0)
  tmp0:normalize()

  tmp0:normalize()
  tmp1:set(-hSin, hCos, 0.0)
  tmp1:normalize()

        let canvas = WI.Canvas.fromPayload(canvasPayload);
        this._canvasIdentifierMap.set(canvas.identifier, canvas);

        let program = new WI.ShaderProgram(programIdentifier, canvas);
        this._shaderProgramIdentifierMap.set(program.identifier, program);

  vehPos:set(vEditor.vehicle:getPositionXYZ())
  local refNodeRot = vEditor.vehicle:getRefNodeRotation()

  local refNodeRot = vEditor.vehicle:getRefNodeRotation()
  rotInv:set(refNodeRot.x, refNodeRot.y, refNodeRot.z, refNodeRot.w)
  rotInv:inverse()

    end
    localVertPos:set(flexbodyObj:getDebugVertexPos(i))

          if renderNode then
            nodePos:set(flexNodePositions[nodeID])
            tempVec:setSub2(vertPos, nodePos)

  prevMinBounds:set(minBounds)
  prevMaxBounds:set(maxBounds)

  prevMinBounds:set(minBounds)
  prevMaxBounds:set(maxBounds)
  minBounds:set(huge,huge,huge)

  prevMaxBounds:set(maxBounds)
  minBounds:set(huge,huge,huge)
  maxBounds:set(-huge,-huge,-huge)

  minBounds:set(huge,huge,huge)
  maxBounds:set(-huge,-huge,-huge)

    for _, nodeID in ipairs(flexbody._group_nodes) do
      nodePos:set(flexNodePositions[nodeID])
      local nodeColor = nodesUsed[nodeID] and nodeUsedColor or nodeUnusedColor

    local node = vEditor.vdata.nodes[state.pickedNodesID[1]]
    nodePos:set(vEditor.vehicle:getNodeAbsPositionXYZ(state.pickedNodesID[1]))

            local node = vEditor.vdata.nodes[nodeID]
            nodePos:set(vEditor.vehicle:getNodeAbsPositionXYZ(nodeID))
            local nodeName = ""

    for _, nodeID in ipairs(flexbody._group_nodes) do
      nodePos:set(vEditor.vehicle:getNodeAbsPositionXYZ(nodeID))
      debugDrawer:drawSphere(nodePos, nodeRenderRadius, nodeUnusedColor)

  if iconInfo and not isInArea then
    tmpVec:set(iconInfo.worldPosition)
    tmpVec:setSub(data.camPos)

      tmpVec:set(0,0,iconHeight)
      tmpVec:setAdd(self.pos)

      -- Set position
      tmpVec:set(0,0,iconHeight)
      tmpVec:setAdd(self.pos)

    self.iconDataById = {}
    tmpVec:set(0,0,iconHeightBottom)
    tmpVec:setAdd(self.pos)

  -- setting up the smoothers
  self.decalAlphaSmoother:set(0)
  self.ringAlphaSmoother:set(0)

  self.decalAlphaSmoother:set(0)
  self.ringAlphaSmoother:set(0)
  self.iconAlphaSmoother:set(0)

  self.ringAlphaSmoother:set(0)
  self.iconAlphaSmoother:set(0)
  self.iconPositionSmoother:set(iconHeightBottom)

  self.iconAlphaSmoother:set(0)
  self.iconPositionSmoother:set(iconHeightBottom)
  self.cruisingSmoother:set(1)

  self.iconPositionSmoother:set(iconHeightBottom)
  self.cruisingSmoother:set(1)
  self.bigMapSmoother:set(0)

  self.cruisingSmoother:set(1)
  self.bigMapSmoother:set(0)

function C:drawOnMinimap(td, dpi)
  a:set(self.pos)
  ui_apps_minimap_utils.worldToMapXYZ(a, a)

  a.y = a.y + offsetForTriangle[1].y*radius*dpi
  b:set(self.pos)
  ui_apps_minimap_utils.worldToMapXYZ(b, b)

  b.y = b.y + offsetForTriangle[2].y*radius*dpi
  c:set(self.pos)
  ui_apps_minimap_utils.worldToMapXYZ(c, c)

            if (currentHeader)
                this._headerMap.set(section.style, currentHeader);

    focus = gameplay_traffic.getFocus()
    aheadPos:set(focus.pos)
    lastPos:set(aheadPos)

    aheadPos:set(focus.pos)
    lastPos:set(aheadPos)
  end

    if psList[1] then
      lastPos:set(psList[1].ps.pos)
    end

  local vehData = trackedVehData[vehId]
  bbCenter:set(be:getObjectOOBBCenterXYZ(vehId))
  vehDirection:set(obj:getDirectionVectorXYZ())

  bbCenter:set(be:getObjectOOBBCenterXYZ(vehId))
  vehDirection:set(obj:getDirectionVectorXYZ())
  bbHalfExtents:set(be:getObjectOOBBHalfExtentsXYZ(vehId))

  vehDirection:set(obj:getDirectionVectorXYZ())
  bbHalfExtents:set(be:getObjectOOBBHalfExtentsXYZ(vehId))

    vehData.psList = filterParkingSpots(vehData.psList, emptyFilters)
    vehData.focusPos:set(vehData.aheadPos)
  end

  tempVec:set(focus.dirVec)
  tempVec.z = 0

    tempVec:set(focus.dirVec)
    tempVec.z = 0

    if M.debugLevel >= 3 then
      debugPos:set(aheadPos)
    end

    aheadPos.z = 0
    lastPos:set(aheadPos)

  if be:getObjectActive(currId) and not currVeh.ignoreTeleport then
    vehPos:set(be:getObjectPositionXYZ(currId))

    },
    set(newValue) {
      sendUpdatedSelection(newValue)

        id = WI.Resource.nextConnectionIdentifier++;
        WI.Resource.connectionIdentifierMap.set(connectionIdentifier, id);
        return id;

function C:_executionStopped()
  simTimeAuthority.set(1)
end

      else
        simTimeAuthority.set(self.pinIn.value.value or 1)
      end

    nodes[i] = nodes[i] or { vec3(), vec3(), vec3(), 0.0, "no part origin" }
    nodes[i][1]:set(obj:getNodePositionRelativeXYZ(i))
    nodes[i][2]:set(obj:getNodeForceVectorXYZ(i))

    nodes[i][1]:set(obj:getNodePositionRelativeXYZ(i))
    nodes[i][2]:set(obj:getNodeForceVectorXYZ(i))
    nodes[i][3]:set(obj:getNodeVelocityVector(i))

    nodes[i][2]:set(obj:getNodeForceVectorXYZ(i))
    nodes[i][3]:set(obj:getNodeVelocityVector(i))
    nodes[i][4] = obj:getNodeMass(i)

  -- Calculate the plane normal (y-axis since plane is drawn in x-z)
  tmpPlaneNormal:set(0, 1, 0)
  tmpPlaneNormal:set(rot * tmpPlaneNormal)

  tmpPlaneNormal:set(0, 1, 0)
  tmpPlaneNormal:set(rot * tmpPlaneNormal)
  tmpPlaneNormal:normalize()

  -- Calculate closest point on plane
  tmpClosestPoint:set(tmpPlaneNormal)
  tmpClosestPoint:setScaled(-signedDistance)

  for i, p in ipairs(self.aiPath) do
    dbgPt:set(p.x, p.y, p.z)
    if dbgPt:squaredDistance(camPos) < cutoffPointSq then -- 100 x 100 m

    end
    lastPt:set(dbgPt)
  end

  twt.targetSpeed = 0
  twt.speedSmoother:set(0)
  twt.steerSmoother:set(0)

  twt.speedSmoother:set(0)
  twt.steerSmoother:set(0)
end

    outDeviation = sign(outDeviation) * min(1, abs(outDeviation))
    egoDeviationSmoother:set(outDeviation)
    egoDeviationSmoother:getUncapped(0, dt)

  else
    egoDeviationSmoother:set(0)
  end

    twt.dirTable[1]:setScaled2(ego.rightVec, -1)
    twt.dirTable[2]:set(ego.dirVec)
    twt.dirTable[3]:set(ego.rightVec)

    twt.dirTable[2]:set(ego.dirVec)
    twt.dirTable[3]:set(ego.rightVec)
    twt.dirTable[4]:setScaled2(ego.dirVec, -1)

    plan[i].vec:setSub2(plan[i-1].pos, plan[i].pos); plan[i].vec.z = 0
    plan[i].dirVec:set(plan[i].vec)
    plan[i].dirVec:normalize()

      if #newNode.outEdgeLanes == #laneConfig then -- TODO: this might not be correct
        dirVec:set(0, 0, 0)
      end

  local newNode = getNewNode()
  newNode.posOrig:set(getPathNodePosition(route, nextPathIdx))
  newNode.pos:set(newNode.posOrig)

  newNode.posOrig:set(getPathNodePosition(route, nextPathIdx))
  newNode.pos:set(newNode.posOrig)
  newNode.vec:set(0, 0, 0)

  newNode.pos:set(newNode.posOrig)
  newNode.vec:set(0, 0, 0)
  newNode.dirVec:set(0, 0, 0)

  newNode.vec:set(0, 0, 0)
  newNode.dirVec:set(0, 0, 0)
  newNode.turnDir:set(0, 0, 0)

  newNode.dirVec:set(0, 0, 0)
  newNode.turnDir:set(0, 0, 0)
  newNode.biNormal:setScaled2(mapmgr.surfaceNormalBelow(mapData.positions[newNodeId], mapData.radius[newNodeId] * 0.5), -1)

  newNode.biNormal:setScaled2(mapmgr.surfaceNormalBelow(mapData.positions[newNodeId], mapData.radius[newNodeId] * 0.5), -1)
  newNode.normal:set(0, 0, 0)
  newNode.radiusOrig = getPathNodeRadius(path, nextPathIdx)

  else
    plan[planCount].normal:set((push3(plan[planCount].posOrig) - newNode.posOrig):cross(plan[planCount].biNormal):normalized())
  end

    newNode.inEdgeNormal:set((push3(plan[planCount].pos) - newNode.pos):cross(newNode.biNormal):normalized())

  newNode.pos:set(newNode.lateralXnorm * push3(newNode.normal) + newNode.posOrig)

  newNode.vec:setSub2(lastPlanPos, newNode.pos); newNode.vec.z = 0
  newNode.dirVec:set(newNode.vec); newNode.dirVec:normalize()

      n.vec:setSub2(n_1.pos, n.pos); n.vec.z = 0
      n.dirVec:set(n.vec); n.dirVec:normalize()
      n_1.turnDir:setSub2(n_1.dirVec, n.dirVec); n_1.turnDir:normalize()

      if newPlan[i] then
        newPlan[i].pos:set(tabentry.pos)
        newPlan[i].normal:set(tabentry.normal)

        newPlan[i].pos:set(tabentry.pos)
        newPlan[i].normal:set(tabentry.normal)
        newPlan[i].posOrig:set(tabentry.posOrig)

        newPlan[i].normal:set(tabentry.normal)
        newPlan[i].posOrig:set(tabentry.posOrig)
        newPlan[i].biNormal:set(tabentry.biNormal)

        newPlan[i].posOrig:set(tabentry.posOrig)
        newPlan[i].biNormal:set(tabentry.biNormal)
        newPlan[i].dirVec:set(tabentry.dirVec)

        newPlan[i].biNormal:set(tabentry.biNormal)
        newPlan[i].dirVec:set(tabentry.dirVec)
        newPlan[i].vec:set(tabentry.vec)

        newPlan[i].dirVec:set(tabentry.dirVec)
        newPlan[i].vec:set(tabentry.vec)
      else

      newNode.vec:setSub2(n1.pos, newNode.pos); newNode.vec.z = 0
      newNode.dirVec:set(newNode.vec); newNode.dirVec:normalize()

      local _, t2 = closestLinePoints(newNode.pos, newNode.pos + newNode.normal, n1.posOrig, n2.posOrig)
      newNode.posOrig:set(t2 * (push3(n2.posOrig) - n1.posOrig) + n1.posOrig)
      local edgeNormal = (push3(n1.posOrig) - n2.posOrig):cross(newNode.biNormal):normalized():copy()

      n2.vec:set(newNode.vec)
      n2.dirVec:set(newNode.dirVec)

      n2.vec:set(newNode.vec)
      n2.dirVec:set(newNode.dirVec)

        planL[planL.planCount].lateralXnorm = planL[planL.planCount].lateralXnorm + (planL.offset or 0)
        planL[planL.planCount].pos:set(planL[planL.planCount].lateralXnorm * push3(planL[planL.planCount].normal) + planL[planL.planCount].posOrig)
        planL[planL.planCount].vec:setSub2(planL[planL.planCount-1].pos, planL[planL.planCount].pos); planL[planL.planCount].vec.z = 0

        planR[planR.planCount].lateralXnorm = planR[planR.planCount].lateralXnorm + (planR.offset or 0)
        planR[planR.planCount].pos:set(planR[planR.planCount].lateralXnorm * push3(planR[planR.planCount].normal) + planR[planR.planCount].posOrig)
        planR[planR.planCount].vec:setSub2(planR[planR.planCount-1].pos, planR[planR.planCount].pos); planR[planR.planCount].vec.z = 0

        plan[i].vec:setSub2(plan[i-1].pos, plan[i].pos); plan[i].vec.z = 0
        plan[i].dirVec:set(plan[i].vec)
        plan[i].dirVec:normalize()

      else
        forces[i]:set(0,0,0)
      end

    n.vec:setSub2(plan[i-1].pos, n.pos); n.vec.z = 0
    n.dirVec:set(n.vec); n.dirVec:normalize()

      if forces[i] then
        forces[i]:set(0, 0, 0)
      else

      if forces[i] then
        forces[i]:set(0, 0, 0)
      else

      if velocities[i] then
        velocities[i]:set(0, 0, 0)
      else

        plan[i].vec:setSub2(plan[i-1].pos, plan[i].pos); plan[i].vec.z = 0
        plan[i].dirVec:set(plan[i].vec)
        plan[i].dirVec:normalize()

    n.vec:setSub2(plan[i-1].pos, n.pos); n.vec.z = 0
    n.dirVec:set(n.vec); n.dirVec:normalize()

      v1z:set(plan[i-1].length, 0, n1.posOrig.z - plan[i-1].posOrig.z)
      v2z:set(n1.length, 0, n2.posOrig.z - n1.posOrig.z)

      v1z:set(plan[i-1].length, 0, n1.posOrig.z - plan[i-1].posOrig.z)
      v2z:set(n1.length, 0, n2.posOrig.z - n1.posOrig.z)
      v3z:set(n1.length + (n2.length or 0), 0, plan[min(plan.planCount, i + 2)].posOrig.z - n1.posOrig.z)

      v2z:set(n1.length, 0, n2.posOrig.z - n1.posOrig.z)
      v3z:set(n1.length + (n2.length or 0), 0, plan[min(plan.planCount, i + 2)].posOrig.z - n1.posOrig.z)

            prevNode = nil
            nDir:set(ego.dirVec)
          end

  ego.pos:set(obj:getFrontPosition())
  ego.pos.z = max(ego.pos.z - 1, obj:getSurfaceHeightBelow(ego.pos))

  ego.pos.z = max(ego.pos.z - 1, obj:getSurfaceHeightBelow(ego.pos))
  ego.prevDirVec:set(ego.dirVec)
  ego.dirVec:set(obj:getDirectionVectorXYZ())

  ego.prevDirVec:set(ego.dirVec)
  ego.dirVec:set(obj:getDirectionVectorXYZ())
  ego.upVec:set(obj:getDirectionVectorUpXYZ())

  ego.dirVec:set(obj:getDirectionVectorXYZ())
  ego.upVec:set(obj:getDirectionVectorUpXYZ())
  ego.rightVec:setCross(ego.dirVec, ego.upVec); ego.rightVec:normalize()

  ego.rightVec:setCross(ego.dirVec, ego.upVec); ego.rightVec:normalize()
  ego.vel:set(obj:getSmoothRefVelocityXYZ())
  ego.speed = ego.vel:length()

            -- acc_check: check if overtake respects grip limit
            d:set(-0.1 * push3(mainPlan[mainPlan.targetSeg].normal) + rearEgoPos2TargetPos) -- (targetPos + dispLim) - (ego.pos - ego.length * ego.dirVec)
            local dSqLengthInv = 1/(d:squaredLength() + 1e-30)

            -- acc_check: check if overtake respects grip limit
            d:set(0.1 * push3(mainPlan[mainPlan.targetSeg].normal) + rearEgoPos2TargetPos) -- (targetPos + dispLim) - (ego.pos - ego.length * ego.dirVec)
            local dSqLengthInv = 1/(d:squaredLength() + 1e-30)

          -- actuall speed
          tmpVec1:set(0, 0, prevEntry[2] * 0.2)
          tmpVec2:set(0, 0, v[2] * 0.2)

          tmpVec1:set(0, 0, prevEntry[2] * 0.2)
          tmpVec2:set(0, 0, v[2] * 0.2)
          debugDrawer:drawCylinder(prevEntry[1] + tmpVec1, v[1] + tmpVec2, 0.02, yellow)

          -- target speed
          tmpVec1:set(0, 0, prevEntry[3] * 0.2)
          tmpVec2:set(0, 0, v[3] * 0.2)

          tmpVec1:set(0, 0, prevEntry[3] * 0.2)
          tmpVec2:set(0, 0, v[3] * 0.2)
          debugDrawer:drawCylinder(prevEntry[1] + tmpVec1, v[1] + tmpVec2, 0.02, blue)

        tmpVec1:set(0, 0, v[3] * 0.2)
        debugDrawer:drawCylinder(v[1], v[1] + tmpVec1, 0.01, blue)

        if focusPos:squaredDistance(v[1]) < visDebug.labelRenderDistance * visDebug.labelRenderDistance then
          tmpVec1:set(0, 0, v[2] * 0.2)
          debugDrawer:drawText(v[1] + tmpVec1 + zOffSet, yellow, strFormat("%2.0f", v[2]*3.6).." kph")

          tmpVec1:set(0, 0, v[3] * 0.2)
          debugDrawer:drawText(v[1] + tmpVec1 + zOffSet, blue, strFormat("%2.0f", v[3]*3.6).." kph")

          local speed = (n.speed >= 0 and n.speed) or prevSpeed
          tmpVec:set(0, 0, speed * 0.2)
          local p1 = n.pos + tmpVec

            local legalSpeed = (n.legalSpeed >= 0 and n.legalSpeed) or prevLegalSpeed
            tmpVec:set(0, 0, legalSpeed * 0.2)
            local p1_ = n.pos + tmpVec

      M.updateGFX = updateGFX
      targetSpeedDifSmoother:set(0)
      targetSpeedSmoother:set(ego.speed)

      targetSpeedDifSmoother:set(0)
      targetSpeedSmoother:set(ego.speed)

  throttleSmoother:set(0)
  smoothTcs:set(1)

  throttleSmoother:set(0)
  smoothTcs:set(1)

      for i = 2, #script do
        scriptPosi:set(script[i].x, script[i].y, 0)
        if p1z0:squaredDistance(scriptPosi) > 0.2 * 0.2 then

  tempFwd:set(vecY:rotated(rot)) -- expected to be parallel to the road
  tempUp:set(map.surfaceNormal(pos, 1))

  tempFwd:set(vecY:rotated(rot)) -- expected to be parallel to the road
  tempUp:set(map.surfaceNormal(pos, 1))
  tempRight:setCross(tempFwd, tempUp)

    if veh then
      tempPos:set(veh:getInitialNodePosition(veh:getRefNodeId())) -- position offset of vehicle

      newQuat:setMul2(newQuat, quatFromAxisAngle(tempUp, math.rad(angle * dir)))
      tempFwd2:set(tempPos:rotated(newQuat)) -- actual direction vector for vehicle
      local x, y, z = -tempFwd2.x, -tempFwd2.y, tempPos.z

  mainRVData.renderView.resolution = Point2I(mainRVSize.x, mainRVSize.y)
  tmpRect:set(0, 0, mainRVSize.x, mainRVSize.y)
  mainRVData.renderView.viewPort = tmpRect

  axisGizmoRVData.renderView.resolution = Point2I(axisGizmoRVSize.x, axisGizmoRVSize.y)
  tmpRect:set(0, 0, axisGizmoRVSize.x, axisGizmoRVSize.y)
  axisGizmoRVData.renderView.viewPort = tmpRect

    racer._wheelDistances[k] = racer._wheelDistances[k] or vec3()
    racer._wheelDistances[k]:set(wheel.pos)
    racer._wheelDistances[k]:setSub(stagePos)

  racer.vehPos:set(racer.vehObj:getPositionXYZ())
  racer.vehDirectionVector:set(racer.vehObj:getDirectionVectorXYZ())

  racer.vehPos:set(racer.vehObj:getPositionXYZ())
  racer.vehDirectionVector:set(racer.vehObj:getDirectionVectorXYZ())
  racer.vehDirectionVectorUp:set(racer.vehObj:getDirectionVectorUpXYZ())

  racer.vehDirectionVector:set(racer.vehObj:getDirectionVectorXYZ())
  racer.vehDirectionVectorUp:set(racer.vehObj:getDirectionVectorUpXYZ())
  racer.vehRot = quatFromDir(racer.vehDirectionVector, racer.vehDirectionVectorUp)

  racer.vehVelocity:set(racer.vehObj:getVelocityXYZ())
  racer.prevSpeed = racer.vehSpeed or 0

    end
    racer.wheelsCenter[k].pos:set(0, 0, 0)
    for _, wheel in ipairs(offset) do

    splines[dragSplineIdx].isDirty = true
    lastDragMousePos:set(mousePos) -- Update last position for next frame.
  end

  local mouseRawY = im.GetMousePos().y
  mouseVel2D:set(mousePos.x - mouseLast.x, mousePos.y - mouseLast.y, 0.0)
  local isShiftDown, isAltDown, isCtrlDown = im.IsKeyDown(shiftKeyIdx), im.IsKeyDown(altKeyIdx), im.IsKeyDown(ctrlKeyIdx)

  local mousePos = util.mouseOnMapPos() -- The current mouse position on the map (3D).
  mouseVel2D:set(mousePos.x - mouseLast.x, mousePos.y - mouseLast.y, 0.0) -- The 2D mouse velocity (XY).
  if mouseVel2D:squaredLength() > isMouseMoveTolSq then

  self.camLastPosRel:set(data.res.pos)

  end
  self.camLastPosAbs:set(data.res.pos)
  self.firstTime = true

  self.camLastQDir:set(data.res.rot)
  self.camLastFOV = data.res.fov

      }
      this.profiles.set(listenerId, profile)
    }

        }
        this.uiAppProfiles.set(uiApp.name, uiAppProfile)
      }

      local iconPos = iconInfo.worldPosition
      tmpVec:set(data.camPos)
      tmpVec:setSub(iconPos)

      local smootherVal = area.iconPosSmoother:get((not data.bigMapActive and overlap) and 1 or 0, data.dt)
      tmpVec:set(0,0,self.iconOffsetHeight + smootherVal*self.iconLift)
      tmpVec:setAdd(area.iconPos)

 * storage.get("name", "n/a") // "n/a" -- default value specified
 * storage.set("name", "John Doe")
 * storage.get("name") // "John Doe"

        },
        set(value) {
          const item = that._values[key]

          item.value = value
          that.set(key, value)
        },

  set(key, value) {
    const data = JSON.stringify(value)

      local iconPos = iconInfo.worldPosition
      tmpVec:set(data.camPos)
      tmpVec:setSub(iconPos)

      local smootherVal = area.iconPosSmoother:get((not data.bigMapActive and overlap) and 1 or 0, data.dt)
      tmpVec:set(0,0,self.iconOffsetHeight + smootherVal*self.iconLift)
      tmpVec:setAdd(area.iconPos)

--			lo('?? U_draw_set:')
		Render.set(s.set, s.c, s.w)
	end

                    values = attribute.value.split(/\s+/);
                uniqueAttributes.set(attribute.name, new Set(values));
            }

  if vEditor.vehicle then
    vEditor.vehiclePos:set(vEditor.vehicle:getPositionXYZ())
  end

  -- Get vehicle front center (set module-level vehPos, vehVel)
  vehPos:set(rallyUtil.getVehFrontCenter(veh:getId()))
  vehVel:set(vehicleData.vel)

  vehPos:set(rallyUtil.getVehFrontCenter(veh:getId()))
  vehVel:set(vehicleData.vel)

  if sp then
    self.pos:set(sp.pos)
    self.rot:set(sp.rot)

    self.pos:set(sp.pos)
    self.rot:set(sp.rot)
    self.startPosValid = true

  -- The plane normal is the y-axis (since plane is drawn in x-z) - reuse tmpPlaneNormal
  tmpPlaneNormal:set(0, 1, 0)
  tmpPlaneNormal:set(rot * tmpPlaneNormal)

  tmpPlaneNormal:set(0, 1, 0)
  tmpPlaneNormal:set(rot * tmpPlaneNormal)
  tmpPlaneNormal:normalize()

        function listenForChange(setting) {
            initialValues.set(setting, setting.value);
            setting.addEventListener(WI.Setting.Event.Changed, () => {

    rootObservers = new Map()
    observers.set(root, rootObservers)
  }

  if (!rootObservers.has(key)) {
    rootObservers.set(key, createObserver(root, rootMargin))
  }

  mounted(el, { value }) {
    observed.set(el, {
      enabled: true,

  dir:set(push3(data.res.pos) - data.res.targetPos)
  local dirLength = dir:length()

  -- Calculate nearClip dimensions
  nearClipCenter:set(push3(data.res.targetPos) + push3(dir) * ((dirLength - assumedNearClipDist) / dirLength))

  -- set the ray destinations
  rayDestinations[1]:set(nearClipCenter); rayDestinations[1]:setAdd(camUp); rayDestinations[1]:setAdd(camRight)
  rayDestinations[2]:set(nearClipCenter); rayDestinations[2]:setSub(camUp); rayDestinations[2]:setAdd(camRight)

  rayDestinations[1]:set(nearClipCenter); rayDestinations[1]:setAdd(camUp); rayDestinations[1]:setAdd(camRight)
  rayDestinations[2]:set(nearClipCenter); rayDestinations[2]:setSub(camUp); rayDestinations[2]:setAdd(camRight)
  rayDestinations[3]:set(nearClipCenter); rayDestinations[3]:setSub(camUp); rayDestinations[3]:setSub(camRight)

  rayDestinations[2]:set(nearClipCenter); rayDestinations[2]:setSub(camUp); rayDestinations[2]:setAdd(camRight)
  rayDestinations[3]:set(nearClipCenter); rayDestinations[3]:setSub(camUp); rayDestinations[3]:setSub(camRight)
  rayDestinations[4]:set(nearClipCenter); rayDestinations[4]:setAdd(camUp); rayDestinations[4]:setSub(camRight)

  rayDestinations[3]:set(nearClipCenter); rayDestinations[3]:setSub(camUp); rayDestinations[3]:setSub(camRight)
  rayDestinations[4]:set(nearClipCenter); rayDestinations[4]:setAdd(camUp); rayDestinations[4]:setSub(camRight)

    smoother = newTemporalSmoothingNonLinear(1, 7, 0)
    smoother:set(closestHit)
  end

    else
      smoother:set(smoothedDistance)
    end

  lastNearClipCenter = lastNearClipCenter or vec3()
  lastNearClipCenter:set(nearClipCenter)
  newCamPos:set(push3(data.res.targetPos) + push3(dir):normalized() * (smoothedDistance + assumedNearClipDist))

  lastNearClipCenter:set(nearClipCenter)
  newCamPos:set(push3(data.res.targetPos) + push3(dir):normalized() * (smoothedDistance + assumedNearClipDist))
  if useRaycast then

                styleDeclarations = [];
                declarationsForStyleSheet.set(style.ownerStyleSheet, styleDeclarations);
            }

        if vehicle then
          tempPos:set(vehicle:getPositionXYZ())
          tempPos:setSub(instance.initialPos)

        if vehicle then
          tempPos:set(vehicle:getPositionXYZ())
          instance.value = math.abs(tempPos.z - instance.initialZPos)

        this._callbacks.set(callId, callback);
        this._postMessage({callId, actionName, actionArguments});

        this._callbacks.set(callId, callback);
        this._postMessage({callId, objectId, methodName, methodArguments});

-- How to use: print(extensions.util_richPresence.set('yolo'))
M.state = { levelName = "", vehicleName = "" ,levelIdentifier=""}

    M.set(msg)
    -- only set discord state is there is a msg for steam

  if enabled then
    M.set('Level editing')
  else

-- returns true on success
local function set(v)
  log("D","Rich Presence", tostring(v))

    --local txt = string.format("%.0fkmh, %0.1fs", vel, node.time)
    tagPos:set(node.pos)
    tagPos.z = tagPos.z + 2

    if i == 1 then
      tagPos:set(node.pos)
      tagPos.z = tagPos.z + 2

  if veh then
    vehPos:set(veh:getPositionXYZ())
    vehVel:set(veh:getVelocityXYZ())

    vehPos:set(veh:getPositionXYZ())
    vehVel:set(veh:getVelocityXYZ())
    vel = vehVel:length()

    gs = absgx
    kbdSmoother:set(gs)
  end

      local wheelSpeed = electrics.values["wheelspeed"]
      velVec:set(obj:getSmoothRefVelocityXYZ())
      local spd = max(abs(wheelSpeed), velVec:length()) -- ensure the fallback case is a high speed (using max instead of the usual min), so that autocentering happens when in doubt (airplane carriers, tanks with reported wheelspeed of zero, etc)

  if signx == -signgx and signv == -signgx then
    kbdSmoother:set(0)
    local gLateral = min(absgx, g) / (g + 1e-30)

    ps = absdiff
    padSmoother:set(ps)
  end

  local wheelSpeed = electrics.values["wheelspeed"]
  velVec:set(obj:getSmoothRefVelocityXYZ())
  rightVec:set(obj:getDirectionVectorRightXYZ())

  velVec:set(obj:getSmoothRefVelocityXYZ())
  rightVec:set(obj:getDirectionVectorRightXYZ())
  local velSqLen = velVec:squaredLength()

    -- determine if we're oversteering and therefore we should not be providing any understeer assistance
    frontVec:set(obj:getDirectionVectorXYZ())
    local margin = sign(st) == sign(oversteer) and -1 or 0.15

  if absgx > gxSmoothMax then
    gx_Smoother:set(absgx)
    gxSmoothMax = absgx

                    properties = [];
                    result.set(property.name, properties);
                }

 */
"undefined"!=typeof module&&"undefined"!=typeof exports&&module.exports===exports&&(module.exports="ui.router"),function(a,b,c){"use strict";function d(a,b){return S(new(S(function(){},{prototype:a})),b)}function e(a){return R(arguments,function(b){b!==a&&R(b,function(b,c){a.hasOwnProperty(c)||(a[c]=b)})}),a}function f(a,b){var c=[];for(var d in a.path){if(a.path[d]!==b.path[d])break;c.push(a.path[d])}return c}function g(a){if(Object.keys)return Object.keys(a);var b=[];return R(a,function(a,c){b.push(c)}),b}function h(a,b){if(Array.prototype.indexOf)return a.indexOf(b,Number(arguments[2])||0);var c=a.length>>>0,d=Number(arguments[2])||0;for(d=d<0?Math.ceil(d):Math.floor(d),d<0&&(d+=c);d=0||(k.push(e[m]),j[e[m]]=a[e[m]]);return S({},j,b)}function j(a,b,c){if(!c){c=[];for(var d in a)c.push(d)}for(var e=0;e "));if(s[c]=d,O(a))q.push(c,[function(){return b.get(a)}],j);else{var e=b.annotate(a);R(e,function(a){a!==c&&i.hasOwnProperty(a)&&n(i[a],a)}),q.push(c,a,e)}r.pop(),s[c]=f}}function o(a){return P(a)&&a.then&&a.$$promises}if(!P(i))throw new Error("'invocables' must be an object");var p=g(i||{}),q=[],r=[],s={};return R(i,n),i=r=s=null,function(d,f,g){function h(){--u||(v||e(t,f.$$values),r.$$values=t,r.$$promises=r.$$promises||!0,delete r.$$inheritedValues,n.resolve(t))}function i(a){r.$$failure=a,n.reject(a)}function j(c,e,f){function j(a){l.reject(a),i(a)}function k(){if(!M(r.$$failure))try{l.resolve(b.invoke(e,g,t)),l.promise.then(function(a){t[c]=a,h()},j)}catch(a){j(a)}}var l=a.defer(),m=0;R(f,function(a){s.hasOwnProperty(a)&&!d.hasOwnProperty(a)&&(m++,s[a].then(function(b){t[a]=b,--m||k()},j))}),m||k(),s[c]=l.promise}if(o(d)&&g===c&&(g=f,f=d,d=null),d){if(!P(d))throw new Error("'locals' must be an object")}else d=k;if(f){if(!o(f))throw new Error("'parent' must be a promise returned by $resolve.resolve()")}else f=l;var n=a.defer(),r=n.promise,s=r.$$promises={},t=S({},d),u=1+q.length/3,v=!1;if(M(f.$$failure))return i(f.$$failure),r;f.$$inheritedValues&&e(t,m(f.$$inheritedValues,p)),S(s,f.$$promises),f.$$values?(v=e(t,m(f.$$values,p)),r.$$inheritedValues=m(f.$$values,p),h()):(f.$$inheritedValues&&(r.$$inheritedValues=m(f.$$inheritedValues,p)),f.then(h,i));for(var w=0,x=q.length;w=0));)s=f(r.id,r.type,r.cfg,"path"),l+=g(r.segment,s.type.pattern.source,s.squash,s.isOptional),n.push(r.segment),m=j.lastIndex;t=a.substring(m);var u=t.indexOf("?");if(u>=0){var v=this.sourceSearch=t.substring(u);if(t=t.substring(0,u),this.sourcePath=a.substring(0,m+u),v.length>0)for(m=0;i=k.exec(v);)r=h(i,!0),s=f(r.id,r.type,r.cfg,"search"),m=j.lastIndex}else this.sourcePath=a,this.sourceSearch="";l+=g(t)+(b.strict===!1?"/?":"")+"$",n.push(t),this.regexp=new RegExp(l,b.caseInsensitive?"i":c),this.prefix=n[0],this.$$paramNames=q}function t(a){S(this,a)}function u(){function a(a){return null!=a?a.toString().replace(/(~|\/)/g,function(a){return{"~":"~~","/":"~2F"}[a]}):a}function e(a){return null!=a?a.toString().replace(/(~~|~2F)/g,function(a){return{"~~":"~","~2F":"/"}[a]}):a}function f(){return{strict:p,caseInsensitive:m}}function i(a){return N(a)||Q(a)&&N(a[a.length-1])}function j(){for(;w.length;){var a=w.shift();if(a.pattern)throw new Error("You cannot override a type's .pattern at runtime.");b.extend(r[a.name],l.invoke(a.def))}}function k(a){S(this,a||{})}V=this;var l,m=!1,p=!0,q=!1,r={},v=!0,w=[],x={string:{encode:a,decode:e,is:function(a){return null==a||!M(a)||"string"==typeof a},pattern:/[^\/]*/},int:{encode:a,decode:function(a){return parseInt(a,10)},is:function(a){return M(a)&&this.decode(a.toString())===a},pattern:/\d+/},bool:{encode:function(a){return a?1:0},decode:function(a){return 0!==parseInt(a,10)},is:function(a){return a===!0||a===!1},pattern:/0|1/},date:{encode:function(a){return this.is(a)?[a.getFullYear(),("0"+(a.getMonth()+1)).slice(-2),("0"+a.getDate()).slice(-2)].join("-"):c},decode:function(a){if(this.is(a))return a;var b=this.capture.exec(a);return b?new Date(b[1],b[2]-1,b[3]):c},is:function(a){return a instanceof Date&&!isNaN(a.valueOf())},equals:function(a,b){return this.is(a)&&this.is(b)&&a.toISOString()===b.toISOString()},pattern:/[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[1-2][0-9]|3[0-1])/,capture:/([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])/},json:{encode:b.toJson,decode:b.fromJson,is:b.isObject,equals:b.equals,pattern:/[^\/]*/},any:{encode:b.identity,decode:b.identity,equals:b.equals,pattern:/.*/}};u.$$getDefaultValue=function(a){if(!i(a.value))return a.value;if(!l)throw new Error("Injectable functions cannot be called at configuration time");return l.invoke(a.value)},this.caseInsensitive=function(a){return M(a)&&(m=a),m},this.strictMode=function(a){return M(a)&&(p=a),p},this.defaultSquashPolicy=function(a){if(!M(a))return q;if(a!==!0&&a!==!1&&!O(a))throw new Error("Invalid squash policy: "+a+". Valid policies: false, true, arbitrary-string");return q=a,a},this.compile=function(a,b){return new s(a,S(f(),b))},this.isMatcher=function(a){if(!P(a))return!1;var b=!0;return R(s.prototype,function(c,d){N(c)&&(b=b&&M(a[d])&&N(a[d]))}),b},this.type=function(a,b,c){if(!M(b))return r[a];if(r.hasOwnProperty(a))throw new Error("A type named '"+a+"' has already been defined.");return r[a]=new t(S({name:a},b)),c&&(w.push({name:a,def:c}),v||j()),this},R(x,function(a,b){r[b]=new t(S({name:b},a))}),r=d(r,{}),this.$get=["$injector",function(a){return l=a,v=!1,j(),R(x,function(a,b){r[b]||(r[b]=new t(a))}),this}],this.Param=function(a,d,e,f){function j(a){var b=P(a)?g(a):[],c=h(b,"value")===-1&&h(b,"type")===-1&&h(b,"squash")===-1&&h(b,"array")===-1;return c&&(a={value:a}),a.$$fn=i(a.value)?a.value:function(){return a.value},a}function k(c,d,e){if(c.type&&d)throw new Error("Param '"+a+"' has two type configurations.");return d?d:c.type?b.isString(c.type)?r[c.type]:c.type instanceof t?c.type:new t(c.type):"config"===e?r.any:r.string}function m(){var b={array:"search"===f&&"auto"},c=a.match(/\[\]$/)?{array:!0}:{};return S(b,c,e).array}function p(a,b){var c=a.squash;if(!b||c===!1)return!1;if(!M(c)||null==c)return q;if(c===!0||O(c))return c;throw new Error("Invalid squash policy: '"+c+"'. Valid policies: false, true, or arbitrary string")}function s(a,b,d,e){var f,g,i=[{from:"",to:d||b?c:""},{from:null,to:d||b?c:""}];return f=Q(a.replace)?a.replace:[],O(e)&&f.push({from:e,to:c}),g=o(f,function(a){return a.from}),n(i,function(a){return h(g,a.from)===-1}).concat(f)}function u(){if(!l)throw new Error("Injectable functions cannot be called at configuration time");var a=l.invoke(e.$$fn);if(null!==a&&a!==c&&!x.type.is(a))throw new Error("Default value ("+a+") for parameter '"+x.id+"' is not an instance of Type ("+x.type.name+")");return a}function v(a){function b(a){return function(b){return b.from===a}}function c(a){var c=o(n(x.replace,b(a)),function(a){return a.to});return c.length?c[0]:a}return a=c(a),M(a)?x.type.$normalize(a):u()}function w(){return"{Param:"+a+" "+d+" squash: '"+A+"' optional: "+z+"}"}var x=this;e=j(e),d=k(e,d,f);var y=m();d=y?d.$asArray(y,"search"===f):d,"string"!==d.name||y||"path"!==f||e.value!==c||(e.value="");var z=e.value!==c,A=p(e,z),B=s(e,y,z,A);S(this,{id:a,type:d,location:f,array:y,squash:A,replace:B,isOptional:z,value:v,dynamic:c,config:e,toString:w})},k.prototype={$$new:function(){return d(this,S(new k,{$$parent:this}))},$$keys:function(){for(var a=[],b=[],c=this,d=g(k.prototype);c;)b.push(c),c=c.$$parent;return b.reverse(),R(b,function(b){R(g(b),function(b){h(a,b)===-1&&h(d,b)===-1&&a.push(b)})}),a},$$values:function(a){var b={},c=this;return R(c.$$keys(),function(d){b[d]=c[d].value(a&&a[d])}),b},$$equals:function(a,b){var c=!0,d=this;return R(d.$$keys(),function(e){var f=a&&a[e],g=b&&b[e];d[e].type.equals(f,g)||(c=!1)}),c},$$validates:function(a){var d,e,f,g,h,i=this.$$keys();for(d=0;d=0)throw new Error("State must have a valid name");if(A.hasOwnProperty(c))throw new Error("State '"+c+"' is already defined");var e=c.indexOf(".")!==-1?c.substring(0,c.lastIndexOf(".")):O(b.parent)?b.parent:P(b.parent)&&O(b.parent.name)?b.parent.name:"";if(e&&!A[e])return n(e,b.self);for(var f in D)N(D[f])&&(b[f]=D[f](b,D.$delegates[f]));return A[c]=b,!b[C]&&b.url&&a.when(b.url,["$match","$stateParams",function(a,c){z.$current.navigable==b&&j(a,c)||z.transitionTo(b,a,{inherit:!0,location:!1})}]),q(c),b}function s(a){return a.indexOf("*")>-1}function t(a){for(var b=a.split("."),c=z.$current.name.split("."),d=0,e=b.length;d=A;d--)g=o[d],g.self.onExit&&h.invoke(g.self.onExit,g.self,g.locals.globals),g.locals=null;for(d=A;d2?k.enter(a,null,c).then(d):k.enter(a,null,c,d)},leave:function(a,c){b.version.minor>2?k.leave(a).then(c):k.leave(a,c)}};if(j){var e=j&&j(c,a);return{enter:function(a,b,c){e.enter(a,null,b),c()},leave:function(a,b){e.leave(a),b()}}}return d()}var i=g(),j=i("$animator"),k=i("$animate"),l={restrict:"ECA",terminal:!0,priority:400,transclude:"element",compile:function(c,g,i){return function(c,g,j){function k(){if(m&&(m.remove(),m=null),o&&(o.$destroy(),o=null),n){var a=n.data("$uiViewAnim");s.leave(n,function(){a.$$animLeave.resolve(),m=null}),m=n,n=null}}function l(h){var l,m=B(c,j,g,e),t=m&&a.$current&&a.$current.locals[m];if(h||t!==p){l=c.$new(),p=a.$current.locals[m],l.$emit("$viewContentLoading",m);var u=i(l,function(a){var e=f.defer(),h=f.defer(),i={$animEnter:e.promise,$animLeave:h.promise,$$animLeave:h};a.data("$uiViewAnim",i),s.enter(a,g,function(){e.resolve(),o&&o.$emit("$viewContentAnimationEnded"),(b.isDefined(r)&&!r||c.$eval(r))&&d(a)}),k()});n=u,o=l,o.$emit("$viewContentLoaded",m),o.$eval(q)}}var m,n,o,p,q=j.onload||"",r=j.autoscroll,s=h(j,c);g.inheritedData("$uiView");c.$on("$stateChangeSuccess",function(){l(!1)}),l(!0)}}};return l}function A(a,c,d,e){return{restrict:"ECA",priority:-400,compile:function(f){var g=f.html();return function(f,h,i){var j=d.$current,k=B(f,i,h,e),l=j&&j.locals[k];if(l){h.data("$uiView",{name:k,state:l.$$state}),h.html(l.$template?l.$template:g);var m=b.extend({},l);f[l.$$resolveAs]=m;var n=a(h.contents());if(l.$$controller){l.$scope=f,l.$element=h;var o=c(l.$$controller,l);l.$$controllerAs&&(f[l.$$controllerAs]=o,f[l.$$controllerAs][l.$$resolveAs]=m),N(o.$onInit)&&o.$onInit(),h.data("$ngControllerController",o),h.children().data("$ngControllerController",o)}n(f)}}}}}function B(a,b,c,d){var e=d(b.uiView||b.name||"")(a),f=c.inheritedData("$uiView");return e.indexOf("@")>=0?e:e+"@"+(f?f.state.name:"")}function C(a,b){var c,d=a.match(/^\s*({[^}]*})\s*$/);if(d&&(a=b+"("+d[1]+")"),c=a.replace(/\n/g," ").match(/^([^(]+?)\s*(\((.*)\))?$/),!c||4!==c.length)throw new Error("Invalid state ref '"+a+"'");return{state:c[1],paramExpr:c[3]||null}}function D(a){var b=a.parent().inheritedData("$uiView");if(b&&b.state&&b.state.name)return b.state}function E(a){var b="[object SVGAnimatedString]"===Object.prototype.toString.call(a.prop("href")),c="FORM"===a[0].nodeName;return{attr:c?"action":b?"xlink:href":"href",isAnchor:"A"===a.prop("tagName").toUpperCase(),clickable:!c}}function F(a,b,c,d,e){return function(f){var g=f.which||f.button,h=e();if(!(g>1||f.ctrlKey||f.metaKey||f.shiftKey||a.attr("target"))){var i=c(function(){b.go(h.state,h.params,h.options)});f.preventDefault();var j=d.isAnchor&&!h.href?1:0;f.preventDefault=function(){j--<=0&&c.cancel(i)}}}}function G(a,b){return{relative:D(a)||b.$current,inherit:!0}}function H(a,c){return{restrict:"A",require:["?^uiSrefActive","?^uiSrefActiveEq"],link:function(d,e,f,g){var h,i=C(f.uiSref,a.current.name),j={state:i.state,href:null,params:null},k=E(e),l=g[1]||g[0],m=null;j.options=S(G(e,a),f.uiSrefOpts?d.$eval(f.uiSrefOpts):{});var n=function(c){c&&(j.params=b.copy(c)),j.href=a.href(i.state,j.params,j.options),m&&m(),l&&(m=l.$$addStateInfo(i.state,j.params)),null!==j.href&&f.$set(k.attr,j.href)};i.paramExpr&&(d.$watch(i.paramExpr,function(a){a!==j.params&&n(a)},!0),j.params=b.copy(d.$eval(i.paramExpr))),n(),k.clickable&&(h=F(e,a,c,k,function(){return j}),e[e.on?"on":"bind"]("click",h),d.$on("$destroy",function(){e[e.off?"off":"unbind"]("click",h)}))}}}function I(a,b){return{restrict:"A",require:["?^uiSrefActive","?^uiSrefActiveEq"],link:function(c,d,e,f){function g(b){m.state=b[0],m.params=b[1],m.options=b[2],m.href=a.href(m.state,m.params,m.options),n&&n(),j&&(n=j.$$addStateInfo(m.state,m.params)),m.href&&e.$set(i.attr,m.href)}var h,i=E(d),j=f[1]||f[0],k=[e.uiState,e.uiStateParams||null,e.uiStateOpts||null],l="["+k.map(function(a){return a||"null"}).join(", ")+"]",m={state:null,params:null,options:null,href:null},n=null;c.$watch(l,g,!0),g(c.$eval(l)),i.clickable&&(h=F(d,a,b,i,function(){return m}),d[d.on?"on":"bind"]("click",h),c.$on("$destroy",function(){d[d.off?"off":"unbind"]("click",h)}))}}}function J(a,b,c){return{restrict:"A",controller:["$scope","$element","$attrs","$timeout",function(b,d,e,f){function g(b,c,e){var f=a.get(b,D(d)),g=h(b,c),i={state:f||{name:b},params:c,hash:g};return p.push(i),q[g]=e,function(){var a=p.indexOf(i);a!==-1&&p.splice(a,1)}}function h(a,c){if(!O(a))throw new Error("state should be a string");return P(c)?a+U(c):(c=b.$eval(c),P(c)?a+U(c):a)}function i(){for(var a=0;a0)){var c=g(a,b,o);return i(),c}},b.$on("$stateChangeSuccess",i),i()}]}}function K(a){var b=function(b,c){return a.is(b,c)};return b.$stateful=!0,b}function L(a){var b=function(b,c,d){return a.includes(b,c,d)};return b.$stateful=!0,b}var M=b.isDefined,N=b.isFunction,O=b.isString,P=b.isObject,Q=b.isArray,R=b.forEach,S=b.extend,T=b.copy,U=b.toJson;b.module("ui.router.util",["ng"]),b.module("ui.router.router",["ui.router.util"]),b.module("ui.router.state",["ui.router.router","ui.router.util"]),b.module("ui.router",["ui.router.state"]),b.module("ui.router.compat",["ui.router"]),q.$inject=["$q","$injector"],b.module("ui.router.util").service("$resolve",q),r.$inject=["$http","$templateCache","$injector"],b.module("ui.router.util").service("$templateFactory",r);var V;s.prototype.concat=function(a,b){var c={caseInsensitive:V.caseInsensitive(),strict:V.strictMode(),squash:V.defaultSquashPolicy()};return new s(this.sourcePath+a+this.sourceSearch,S(c,b),this)},s.prototype.toString=function(){return this.source},s.prototype.exec=function(a,b){function c(a){function b(a){return a.split("").reverse().join("")}function c(a){return a.replace(/\\-/g,"-")}var d=b(a).split(/-(?!\\)/),e=o(d,b);return o(e,c).reverse()}var d=this.regexp.exec(a);if(!d)return null;b=b||{};var e,f,g,h=this.parameters(),i=h.length,j=this.segments.length-1,k={};if(j!==d.length-1)throw new Error("Unbalanced capture group in route '"+this.source+"'");var l,m;for(e=0;e

 */
"undefined"!=typeof module&&"undefined"!=typeof exports&&module.exports===exports&&(module.exports="ui.router"),function(a,b,c){"use strict";function d(a,b){return S(new(S(function(){},{prototype:a})),b)}function e(a){return R(arguments,function(b){b!==a&&R(b,function(b,c){a.hasOwnProperty(c)||(a[c]=b)})}),a}function f(a,b){var c=[];for(var d in a.path){if(a.path[d]!==b.path[d])break;c.push(a.path[d])}return c}function g(a){if(Object.keys)return Object.keys(a);var b=[];return R(a,function(a,c){b.push(c)}),b}function h(a,b){if(Array.prototype.indexOf)return a.indexOf(b,Number(arguments[2])||0);var c=a.length>>>0,d=Number(arguments[2])||0;for(d=d<0?Math.ceil(d):Math.floor(d),d<0&&(d+=c);d=0||(k.push(e[m]),j[e[m]]=a[e[m]]);return S({},j,b)}function j(a,b,c){if(!c){c=[];for(var d in a)c.push(d)}for(var e=0;e "));if(s[c]=d,O(a))q.push(c,[function(){return b.get(a)}],j);else{var e=b.annotate(a);R(e,function(a){a!==c&&i.hasOwnProperty(a)&&n(i[a],a)}),q.push(c,a,e)}r.pop(),s[c]=f}}function o(a){return P(a)&&a.then&&a.$$promises}if(!P(i))throw new Error("'invocables' must be an object");var p=g(i||{}),q=[],r=[],s={};return R(i,n),i=r=s=null,function(d,f,g){function h(){--u||(v||e(t,f.$$values),r.$$values=t,r.$$promises=r.$$promises||!0,delete r.$$inheritedValues,n.resolve(t))}function i(a){r.$$failure=a,n.reject(a)}function j(c,e,f){function j(a){l.reject(a),i(a)}function k(){if(!M(r.$$failure))try{l.resolve(b.invoke(e,g,t)),l.promise.then(function(a){t[c]=a,h()},j)}catch(a){j(a)}}var l=a.defer(),m=0;R(f,function(a){s.hasOwnProperty(a)&&!d.hasOwnProperty(a)&&(m++,s[a].then(function(b){t[a]=b,--m||k()},j))}),m||k(),s[c]=l.promise}if(o(d)&&g===c&&(g=f,f=d,d=null),d){if(!P(d))throw new Error("'locals' must be an object")}else d=k;if(f){if(!o(f))throw new Error("'parent' must be a promise returned by $resolve.resolve()")}else f=l;var n=a.defer(),r=n.promise,s=r.$$promises={},t=S({},d),u=1+q.length/3,v=!1;if(M(f.$$failure))return i(f.$$failure),r;f.$$inheritedValues&&e(t,m(f.$$inheritedValues,p)),S(s,f.$$promises),f.$$values?(v=e(t,m(f.$$values,p)),r.$$inheritedValues=m(f.$$values,p),h()):(f.$$inheritedValues&&(r.$$inheritedValues=m(f.$$inheritedValues,p)),f.then(h,i));for(var w=0,x=q.length;w=0));)s=f(r.id,r.type,r.cfg,"path"),l+=g(r.segment,s.type.pattern.source,s.squash,s.isOptional),n.push(r.segment),m=j.lastIndex;t=a.substring(m);var u=t.indexOf("?");if(u>=0){var v=this.sourceSearch=t.substring(u);if(t=t.substring(0,u),this.sourcePath=a.substring(0,m+u),v.length>0)for(m=0;i=k.exec(v);)r=h(i,!0),s=f(r.id,r.type,r.cfg,"search"),m=j.lastIndex}else this.sourcePath=a,this.sourceSearch="";l+=g(t)+(b.strict===!1?"/?":"")+"$",n.push(t),this.regexp=new RegExp(l,b.caseInsensitive?"i":c),this.prefix=n[0],this.$$paramNames=q}function t(a){S(this,a)}function u(){function a(a){return null!=a?a.toString().replace(/(~|\/)/g,function(a){return{"~":"~~","/":"~2F"}[a]}):a}function e(a){return null!=a?a.toString().replace(/(~~|~2F)/g,function(a){return{"~~":"~","~2F":"/"}[a]}):a}function f(){return{strict:p,caseInsensitive:m}}function i(a){return N(a)||Q(a)&&N(a[a.length-1])}function j(){for(;w.length;){var a=w.shift();if(a.pattern)throw new Error("You cannot override a type's .pattern at runtime.");b.extend(r[a.name],l.invoke(a.def))}}function k(a){S(this,a||{})}V=this;var l,m=!1,p=!0,q=!1,r={},v=!0,w=[],x={string:{encode:a,decode:e,is:function(a){return null==a||!M(a)||"string"==typeof a},pattern:/[^\/]*/},int:{encode:a,decode:function(a){return parseInt(a,10)},is:function(a){return M(a)&&this.decode(a.toString())===a},pattern:/\d+/},bool:{encode:function(a){return a?1:0},decode:function(a){return 0!==parseInt(a,10)},is:function(a){return a===!0||a===!1},pattern:/0|1/},date:{encode:function(a){return this.is(a)?[a.getFullYear(),("0"+(a.getMonth()+1)).slice(-2),("0"+a.getDate()).slice(-2)].join("-"):c},decode:function(a){if(this.is(a))return a;var b=this.capture.exec(a);return b?new Date(b[1],b[2]-1,b[3]):c},is:function(a){return a instanceof Date&&!isNaN(a.valueOf())},equals:function(a,b){return this.is(a)&&this.is(b)&&a.toISOString()===b.toISOString()},pattern:/[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[1-2][0-9]|3[0-1])/,capture:/([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])/},json:{encode:b.toJson,decode:b.fromJson,is:b.isObject,equals:b.equals,pattern:/[^\/]*/},any:{encode:b.identity,decode:b.identity,equals:b.equals,pattern:/.*/}};u.$$getDefaultValue=function(a){if(!i(a.value))return a.value;if(!l)throw new Error("Injectable functions cannot be called at configuration time");return l.invoke(a.value)},this.caseInsensitive=function(a){return M(a)&&(m=a),m},this.strictMode=function(a){return M(a)&&(p=a),p},this.defaultSquashPolicy=function(a){if(!M(a))return q;if(a!==!0&&a!==!1&&!O(a))throw new Error("Invalid squash policy: "+a+". Valid policies: false, true, arbitrary-string");return q=a,a},this.compile=function(a,b){return new s(a,S(f(),b))},this.isMatcher=function(a){if(!P(a))return!1;var b=!0;return R(s.prototype,function(c,d){N(c)&&(b=b&&M(a[d])&&N(a[d]))}),b},this.type=function(a,b,c){if(!M(b))return r[a];if(r.hasOwnProperty(a))throw new Error("A type named '"+a+"' has already been defined.");return r[a]=new t(S({name:a},b)),c&&(w.push({name:a,def:c}),v||j()),this},R(x,function(a,b){r[b]=new t(S({name:b},a))}),r=d(r,{}),this.$get=["$injector",function(a){return l=a,v=!1,j(),R(x,function(a,b){r[b]||(r[b]=new t(a))}),this}],this.Param=function(a,d,e,f){function j(a){var b=P(a)?g(a):[],c=h(b,"value")===-1&&h(b,"type")===-1&&h(b,"squash")===-1&&h(b,"array")===-1;return c&&(a={value:a}),a.$$fn=i(a.value)?a.value:function(){return a.value},a}function k(c,d,e){if(c.type&&d)throw new Error("Param '"+a+"' has two type configurations.");return d?d:c.type?b.isString(c.type)?r[c.type]:c.type instanceof t?c.type:new t(c.type):"config"===e?r.any:r.string}function m(){var b={array:"search"===f&&"auto"},c=a.match(/\[\]$/)?{array:!0}:{};return S(b,c,e).array}function p(a,b){var c=a.squash;if(!b||c===!1)return!1;if(!M(c)||null==c)return q;if(c===!0||O(c))return c;throw new Error("Invalid squash policy: '"+c+"'. Valid policies: false, true, or arbitrary string")}function s(a,b,d,e){var f,g,i=[{from:"",to:d||b?c:""},{from:null,to:d||b?c:""}];return f=Q(a.replace)?a.replace:[],O(e)&&f.push({from:e,to:c}),g=o(f,function(a){return a.from}),n(i,function(a){return h(g,a.from)===-1}).concat(f)}function u(){if(!l)throw new Error("Injectable functions cannot be called at configuration time");var a=l.invoke(e.$$fn);if(null!==a&&a!==c&&!x.type.is(a))throw new Error("Default value ("+a+") for parameter '"+x.id+"' is not an instance of Type ("+x.type.name+")");return a}function v(a){function b(a){return function(b){return b.from===a}}function c(a){var c=o(n(x.replace,b(a)),function(a){return a.to});return c.length?c[0]:a}return a=c(a),M(a)?x.type.$normalize(a):u()}function w(){return"{Param:"+a+" "+d+" squash: '"+A+"' optional: "+z+"}"}var x=this;e=j(e),d=k(e,d,f);var y=m();d=y?d.$asArray(y,"search"===f):d,"string"!==d.name||y||"path"!==f||e.value!==c||(e.value="");var z=e.value!==c,A=p(e,z),B=s(e,y,z,A);S(this,{id:a,type:d,location:f,array:y,squash:A,replace:B,isOptional:z,value:v,dynamic:c,config:e,toString:w})},k.prototype={$$new:function(){return d(this,S(new k,{$$parent:this}))},$$keys:function(){for(var a=[],b=[],c=this,d=g(k.prototype);c;)b.push(c),c=c.$$parent;return b.reverse(),R(b,function(b){R(g(b),function(b){h(a,b)===-1&&h(d,b)===-1&&a.push(b)})}),a},$$values:function(a){var b={},c=this;return R(c.$$keys(),function(d){b[d]=c[d].value(a&&a[d])}),b},$$equals:function(a,b){var c=!0,d=this;return R(d.$$keys(),function(e){var f=a&&a[e],g=b&&b[e];d[e].type.equals(f,g)||(c=!1)}),c},$$validates:function(a){var d,e,f,g,h,i=this.$$keys();for(d=0;d=0)throw new Error("State must have a valid name");if(A.hasOwnProperty(c))throw new Error("State '"+c+"' is already defined");var e=c.indexOf(".")!==-1?c.substring(0,c.lastIndexOf(".")):O(b.parent)?b.parent:P(b.parent)&&O(b.parent.name)?b.parent.name:"";if(e&&!A[e])return n(e,b.self);for(var f in D)N(D[f])&&(b[f]=D[f](b,D.$delegates[f]));return A[c]=b,!b[C]&&b.url&&a.when(b.url,["$match","$stateParams",function(a,c){z.$current.navigable==b&&j(a,c)||z.transitionTo(b,a,{inherit:!0,location:!1})}]),q(c),b}function s(a){return a.indexOf("*")>-1}function t(a){for(var b=a.split("."),c=z.$current.name.split("."),d=0,e=b.length;d=A;d--)g=o[d],g.self.onExit&&h.invoke(g.self.onExit,g.self,g.locals.globals),g.locals=null;for(d=A;d2?k.enter(a,null,c).then(d):k.enter(a,null,c,d)},leave:function(a,c){b.version.minor>2?k.leave(a).then(c):k.leave(a,c)}};if(j){var e=j&&j(c,a);return{enter:function(a,b,c){e.enter(a,null,b),c()},leave:function(a,b){e.leave(a),b()}}}return d()}var i=g(),j=i("$animator"),k=i("$animate"),l={restrict:"ECA",terminal:!0,priority:400,transclude:"element",compile:function(c,g,i){return function(c,g,j){function k(){if(m&&(m.remove(),m=null),o&&(o.$destroy(),o=null),n){var a=n.data("$uiViewAnim");s.leave(n,function(){a.$$animLeave.resolve(),m=null}),m=n,n=null}}function l(h){var l,m=B(c,j,g,e),t=m&&a.$current&&a.$current.locals[m];if(h||t!==p){l=c.$new(),p=a.$current.locals[m],l.$emit("$viewContentLoading",m);var u=i(l,function(a){var e=f.defer(),h=f.defer(),i={$animEnter:e.promise,$animLeave:h.promise,$$animLeave:h};a.data("$uiViewAnim",i),s.enter(a,g,function(){e.resolve(),o&&o.$emit("$viewContentAnimationEnded"),(b.isDefined(r)&&!r||c.$eval(r))&&d(a)}),k()});n=u,o=l,o.$emit("$viewContentLoaded",m),o.$eval(q)}}var m,n,o,p,q=j.onload||"",r=j.autoscroll,s=h(j,c);g.inheritedData("$uiView");c.$on("$stateChangeSuccess",function(){l(!1)}),l(!0)}}};return l}function A(a,c,d,e){return{restrict:"ECA",priority:-400,compile:function(f){var g=f.html();return function(f,h,i){var j=d.$current,k=B(f,i,h,e),l=j&&j.locals[k];if(l){h.data("$uiView",{name:k,state:l.$$state}),h.html(l.$template?l.$template:g);var m=b.extend({},l);f[l.$$resolveAs]=m;var n=a(h.contents());if(l.$$controller){l.$scope=f,l.$element=h;var o=c(l.$$controller,l);l.$$controllerAs&&(f[l.$$controllerAs]=o,f[l.$$controllerAs][l.$$resolveAs]=m),N(o.$onInit)&&o.$onInit(),h.data("$ngControllerController",o),h.children().data("$ngControllerController",o)}n(f)}}}}}function B(a,b,c,d){var e=d(b.uiView||b.name||"")(a),f=c.inheritedData("$uiView");return e.indexOf("@")>=0?e:e+"@"+(f?f.state.name:"")}function C(a,b){var c,d=a.match(/^\s*({[^}]*})\s*$/);if(d&&(a=b+"("+d[1]+")"),c=a.replace(/\n/g," ").match(/^([^(]+?)\s*(\((.*)\))?$/),!c||4!==c.length)throw new Error("Invalid state ref '"+a+"'");return{state:c[1],paramExpr:c[3]||null}}function D(a){var b=a.parent().inheritedData("$uiView");if(b&&b.state&&b.state.name)return b.state}function E(a){var b="[object SVGAnimatedString]"===Object.prototype.toString.call(a.prop("href")),c="FORM"===a[0].nodeName;return{attr:c?"action":b?"xlink:href":"href",isAnchor:"A"===a.prop("tagName").toUpperCase(),clickable:!c}}function F(a,b,c,d,e){return function(f){var g=f.which||f.button,h=e();if(!(g>1||f.ctrlKey||f.metaKey||f.shiftKey||a.attr("target"))){var i=c(function(){b.go(h.state,h.params,h.options)});f.preventDefault();var j=d.isAnchor&&!h.href?1:0;f.preventDefault=function(){j--<=0&&c.cancel(i)}}}}function G(a,b){return{relative:D(a)||b.$current,inherit:!0}}function H(a,c){return{restrict:"A",require:["?^uiSrefActive","?^uiSrefActiveEq"],link:function(d,e,f,g){var h,i=C(f.uiSref,a.current.name),j={state:i.state,href:null,params:null},k=E(e),l=g[1]||g[0],m=null;j.options=S(G(e,a),f.uiSrefOpts?d.$eval(f.uiSrefOpts):{});var n=function(c){c&&(j.params=b.copy(c)),j.href=a.href(i.state,j.params,j.options),m&&m(),l&&(m=l.$$addStateInfo(i.state,j.params)),null!==j.href&&f.$set(k.attr,j.href)};i.paramExpr&&(d.$watch(i.paramExpr,function(a){a!==j.params&&n(a)},!0),j.params=b.copy(d.$eval(i.paramExpr))),n(),k.clickable&&(h=F(e,a,c,k,function(){return j}),e[e.on?"on":"bind"]("click",h),d.$on("$destroy",function(){e[e.off?"off":"unbind"]("click",h)}))}}}function I(a,b){return{restrict:"A",require:["?^uiSrefActive","?^uiSrefActiveEq"],link:function(c,d,e,f){function g(b){m.state=b[0],m.params=b[1],m.options=b[2],m.href=a.href(m.state,m.params,m.options),n&&n(),j&&(n=j.$$addStateInfo(m.state,m.params)),m.href&&e.$set(i.attr,m.href)}var h,i=E(d),j=f[1]||f[0],k=[e.uiState,e.uiStateParams||null,e.uiStateOpts||null],l="["+k.map(function(a){return a||"null"}).join(", ")+"]",m={state:null,params:null,options:null,href:null},n=null;c.$watch(l,g,!0),g(c.$eval(l)),i.clickable&&(h=F(d,a,b,i,function(){return m}),d[d.on?"on":"bind"]("click",h),c.$on("$destroy",function(){d[d.off?"off":"unbind"]("click",h)}))}}}function J(a,b,c){return{restrict:"A",controller:["$scope","$element","$attrs","$timeout",function(b,d,e,f){function g(b,c,e){var f=a.get(b,D(d)),g=h(b,c),i={state:f||{name:b},params:c,hash:g};return p.push(i),q[g]=e,function(){var a=p.indexOf(i);a!==-1&&p.splice(a,1)}}function h(a,c){if(!O(a))throw new Error("state should be a string");return P(c)?a+U(c):(c=b.$eval(c),P(c)?a+U(c):a)}function i(){for(var a=0;a0)){var c=g(a,b,o);return i(),c}},b.$on("$stateChangeSuccess",i),i()}]}}function K(a){var b=function(b,c){return a.is(b,c)};return b.$stateful=!0,b}function L(a){var b=function(b,c,d){return a.includes(b,c,d)};return b.$stateful=!0,b}var M=b.isDefined,N=b.isFunction,O=b.isString,P=b.isObject,Q=b.isArray,R=b.forEach,S=b.extend,T=b.copy,U=b.toJson;b.module("ui.router.util",["ng"]),b.module("ui.router.router",["ui.router.util"]),b.module("ui.router.state",["ui.router.router","ui.router.util"]),b.module("ui.router",["ui.router.state"]),b.module("ui.router.compat",["ui.router"]),q.$inject=["$q","$injector"],b.module("ui.router.util").service("$resolve",q),r.$inject=["$http","$templateCache","$injector"],b.module("ui.router.util").service("$templateFactory",r);var V;s.prototype.concat=function(a,b){var c={caseInsensitive:V.caseInsensitive(),strict:V.strictMode(),squash:V.defaultSquashPolicy()};return new s(this.sourcePath+a+this.sourceSearch,S(c,b),this)},s.prototype.toString=function(){return this.source},s.prototype.exec=function(a,b){function c(a){function b(a){return a.split("").reverse().join("")}function c(a){return a.replace(/\\-/g,"-")}var d=b(a).split(/-(?!\\)/),e=o(d,b);return o(e,c).reverse()}var d=this.regexp.exec(a);if(!d)return null;b=b||{};var e,f,g,h=this.parameters(),i=h.length,j=this.segments.length-1,k={};if(j!==d.length-1)throw new Error("Unbalanced capture group in route '"+this.source+"'");var l,m;for(e=0;e