VE Lua Documentation

function C:work()
  posA:set(self:getPosition(self.pinIn.posA.value))
  posB:set(self:getPosition(self.pinIn.posB.value))

  posA:set(self:getPosition(self.pinIn.posA.value))
  posB:set(self:getPosition(self.pinIn.posB.value))

        this._markerElementMap.set(marker, markerElement);

        for (let debuggableType of Object.values(WI.DebuggableType))
            this._supportedDomainsForDebuggableType.set(debuggableType, []);

        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);

function Pcd:setData(data, bytes)
  self.payload:set(data, bytes)
end

--     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))

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

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

    if veh then
      self.centerPos:set(veh:getSpawnWorldOOBB():getCenter())
    end

  self.offset:set(math.sin(aRad), math.cos(aRad), 0)

  self.camPos:set(self.centerPos)
  self.camPos:setAdd(self.offset * radius)

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

local function fitParaCubic2D(p0, p1, p2, p3)
  tmp0:set(p0.x, p0.y, 0)
  tmp1:set(p1.x, p1.y, 0)

  tmp0:set(p0.x, p0.y, 0)
  tmp1:set(p1.x, p1.y, 0)
  tmp2:set(p2.x, p2.y, 0)

  tmp1:set(p1.x, p1.y, 0)
  tmp2:set(p2.x, p2.y, 0)
  tmp3:set(p3.x, p3.y, 0)

  tmp2:set(p2.x, p2.y, 0)
  tmp3:set(p3.x, p3.y, 0)
  local p0_2d, p1_2d, p2_2d, p3_2d = tmp0 - tmp1, zeroVec, tmp2 - tmp1, tmp3 - tmp1

    local p1, p2 = rData[i - 1][idx1][idx2], rData[i][idx1][idx2]
    tmp0:set(p1.x, p1.y, 0.0)
    tmp1:set(p2.x, p2.y, 0.0)

    tmp0:set(p1.x, p1.y, 0.0)
    tmp1:set(p2.x, p2.y, 0.0)
    sum = sum + tmp1:distance(tmp0)

    -- Compute the geodesic length of this line segment.
    tmp0:set(p2.x, p2.y, 0.0)
    tmp1:set(p3.x, p3.y, 0.0)

    tmp0:set(p2.x, p2.y, 0.0)
    tmp1:set(p3.x, p3.y, 0.0)
    local segLength = tmp1:distance(tmp0)

      local k = laneKeys[key]
      tmp0:set(p1x, p1y, div1[k][9])
      tmp1:set(p2x, p2y, div2[k][9])

      tmp0:set(p1x, p1y, div1[k][9])
      tmp1:set(p2x, p2y, div2[k][9])
      tmp2:set(p3x, p3y, div3[k][9])

      tmp1:set(p2x, p2y, div2[k][9])
      tmp2:set(p3x, p3y, div3[k][9])
      tmp3:set(p4x, p4y, div4[k][9])

      tmp2:set(p3x, p3y, div3[k][9])
      tmp3:set(p4x, p4y, div4[k][9])
      widthCubics[k] = { cubic = fitExpCubic(tmp0, tmp1, tmp2, tmp3, segLength), type = profile[k].type }

    -- Fit explicit cubics through the lateral rotation (super-elevation) encoding.
    tmp0:set(p1x, p1y, div1[idx1][12])
    tmp1:set(p2x, p2y, div2[idx1][12])

    tmp0:set(p1x, p1y, div1[idx1][12])
    tmp1:set(p2x, p2y, div2[idx1][12])
    tmp2:set(p3x, p3y, div3[idx1][12])

    tmp1:set(p2x, p2y, div2[idx1][12])
    tmp2:set(p3x, p3y, div3[idx1][12])
    tmp3:set(p4x, p4y, div4[idx1][12])

    tmp2:set(p3x, p3y, div3[idx1][12])
    tmp3:set(p4x, p4y, div4[idx1][12])
    local superElevCubic = fitExpCubic(tmp0, tmp1, tmp2, tmp3, segLength)

              local sp = newPath.startPositions:create()
              sp:set(pn.pos, quatFromDir(pn.normal):normalized())
              sp.name = pn.name .. " Recovery Forward"

              local spr = newPath.startPositions:create()
              spr:set(pn.pos, quatFromDir(pn.normal*-1):normalized())
              spr.name = pn.name .. " Recovery Reverse"

    local dataString = sbuffer.new()
    dataString:set(data, dataSize)

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

  self.camNodeID = self.camNodeID or self.refNodes.ref or 0
  nodePos:set(data.veh:getNodePositionXYZ(self.camNodeID))

  if self.idUp and self.idBack then
    ref:set(data.veh:getNodePositionXYZ(self.idRef or self.camNodeID))
    up:set(data.veh:getNodePositionXYZ(self.idUp))

    ref:set(data.veh:getNodePositionXYZ(self.idRef or self.camNodeID))
    up:set(data.veh:getNodePositionXYZ(self.idUp))
    back:set(data.veh:getNodePositionXYZ(self.idBack))

    up:set(data.veh:getNodePositionXYZ(self.idUp))
    back:set(data.veh:getNodePositionXYZ(self.idBack))
    dir:setSub2(ref, back); dir:normalize()

  else
    ref:set(data.veh:getNodePositionXYZ(self.refNodes.ref))
    left:set(data.veh:getNodePositionXYZ(self.refNodes.left))

    ref:set(data.veh:getNodePositionXYZ(self.refNodes.ref))
    left:set(data.veh:getNodePositionXYZ(self.refNodes.left))
    back:set(data.veh:getNodePositionXYZ(self.refNodes.back))

    left:set(data.veh:getNodePositionXYZ(self.refNodes.left))
    back:set(data.veh:getNodePositionXYZ(self.refNodes.back))
    dir:setSub2(ref, back); dir:normalize()

    camLeft:setSub2(ref, left); camLeft:normalize()
    camUp:set(-(push3(dir):cross(push3(camLeft)))); camUp:normalize()
  end

    qdir = rotateEuler(math.rad(180),0,math.atan2(rotatedUp:dot(camLeft), rotatedUp:dot(camUp)),qdir)
    data.res.pos:set(data.veh:getSpawnWorldOOBBRearPoint())
  else

  lastFramePos:set(gameplay_drift_drift.getVehPos())
end

        if self.pinIn[p .. '_' ..i].value ~= nil then
          self.mgr.modules.button:set(id, p, self.pinIn[p .. '_' ..i].value)
        end

      checkAborted()
      previews.value.set(key, {
        bitmap: bmp,

        const others = [...existing.others]
        pendingRenders.value.set(key, {
          paintHash,

    const others = []
    pendingRenders.value.set(key, {
      paintHash,

    for i, object in ipairs(editor.selection.forestItem) do
      rotMtx:set(deltaEulerRotation, centerPoint)
      local objTrans = copyMat(originalTransforms[i])

  tr:setOneDimensionalScale(oneDimScale)
  tr:set(pos, rot, scl)
  tr:enableEditing()

  local te = extensions.editor_terrainEditor.getTerrainEditor()
  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, spansY[i]
      posWS:set(te:gridToWorldByPoint2I(tmpPoint2I, tb))
      local idx = (y - gMinY) * width + (x - gMinX) + 1 -- 2D -> 1D index used for the mask.

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

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

  for i = 1, #stateVals do
    tmp1:set(stateX[i], stateY[i], 0)
    tb:setMaterialIdxWs(tmp1, stateVals[i]) -- Restore the original material index (before painting).

  -- Update the grid after changes.
  tmp1:set(group.paintedDataBoxXMin, group.paintedDataBoxYMin, 0)
  tmp2:set(group.paintedDataBoxXMax, group.paintedDataBoxYMax, 0)

  tmp1:set(group.paintedDataBoxXMin, group.paintedDataBoxYMin, 0)
  tmp2:set(group.paintedDataBoxXMax, group.paintedDataBoxYMax, 0)
  tb:updateGridMaterials(tmp1, tmp2)

        this._childFrameCollection.add(frame);
        this._childFrameIdentifierMap.set(frame._id, frame);

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

          -- [Use: (c0, c2, c0_next) and (c2, c2_next, c0_next) where c0,c2 are the top surface points.]
          tmpPos:set(node.x, node.y, maxRayDist)
          local hitDist1 = intersectsRay_Triangle(tmpPos, globalDown, c0, c2, c0Next)

        this._contentViewMap.set(item, contentView);
        this._handleClickMap.set(item, handleClick);

        this._contentViewMap.set(item, contentView);
        this._handleClickMap.set(item, handleClick);
        contentView.element.addEventListener("click", handleClick);

  local d0, d1, d2, d3 = ribbon.depths[i1], ribbon.depths[i2], ribbon.depths[i3], ribbon.depths[i4]
  tmp0:set(c0)
  tmp1:set(c1)

  tmp0:set(c0)
  tmp1:set(c1)
  tmp2:set(c2)

  tmp1:set(c1)
  tmp2:set(c2)
  tmp3:set(c3)

  tmp2:set(c2)
  tmp3:set(c3)
  if isAmbient or isQuadAndVolume then

  if dSq2 < dSq1 then
    retP:set(tmp5)
    return retP, dSq2, u2, v2, true

  end
  retP:set(tmp4)
  return retP, dSq1, u1, v1, false

  if pClosest then
    emit.pos:set(pClosest.x, pClosest.y, pClosest.z)

        bestSqDist = dSq
        emit.pos:set(pClosest.x, pClosest.y, pClosest.z)
        emit.bestSeg = emit.bestSeg - 1

        bestSqDist = dSq
        emit.pos:set(pClosest.x, pClosest.y, pClosest.z)
        emit.bestSeg = emit.bestSeg + 1

        bestSqDist = dSq
        emit.pos:set(pClosest.x, pClosest.y, pClosest.z)
        emit.bestSeg = segSample

    tmpBlueP:set(pClosest.x, pClosest.y, pClosest.z)
    return tmpBlueP, segSample, u, v, isFirstTriangle

  local pClosest, bestSqDist, u, v, isFirstTriangle = closestPoint(emit.bestSeg, p, ribbon, tmpEmitP)
  emit.pos:set(pClosest.x, pClosest.y, pClosest.z)

      bestSqDist = dSq
      emit.pos:set(pClosest.x, pClosest.y, pClosest.z)
      emit.bestSeg = emit.bestSeg - 1

      bestSqDist = dSq
      emit.pos:set(pClosest.x, pClosest.y, pClosest.z)
      emit.bestSeg = emit.bestSeg + 1

      bestSqDist = dSq
      emit.pos:set(bluePoint.x, bluePoint.y, bluePoint.z)
      emit.bestSeg = blueSeg

      axis[emit.eventNameStr].texture = volCoeff
      axis[emit.eventNameStr].pos:set(p)
    end

      axis[emit.eventNameStr].texture = volCoeff
      axis[emit.eventNameStr].pos:set(emit.pos)
    end

  -- Fetch the latest SFX listener pose.
  lPosition:set(SFXSystem.getPositionXYZ())
  lForward:set(SFXSystem.getForwardXYZ())

  lPosition:set(SFXSystem.getPositionXYZ())
  lForward:set(SFXSystem.getForwardXYZ())
  lRight:set(SFXSystem.getRightXYZ())

  lForward:set(SFXSystem.getForwardXYZ())
  lRight:set(SFXSystem.getRightXYZ())

            }
            observations.set(target, new ResizeObservation(target));
            this.controller_.addObserver(this);

            var observer = new ResizeObserverSPI(callback, controller, this);
            observers.set(this, observer);
        }

                    typedRecords = [];
                    recordsByTypeMap.set(record.type, typedRecords);
                }

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

  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

    local c = util.posVS2Coeffs(posVS, veh)
    s.pos:set(c.x, c.y, c.z)
    return

                this._entries.set(key, value);
            }

    {
        this._entries.set(key, value);
        this.dispatchEventToListeners(WI.DOMStorageObject.Event.ItemAdded, {key, value});

    {
        this._entries.set(key, value);
        this.dispatchEventToListeners(WI.DOMStorageObject.Event.ItemUpdated, {key, oldValue, value});

      if shouldLog then log('D', 'graphic',"Sanitizing display mode - "..tostring(current)..": Failed. Patching to display mode 'Window'") end
      o.GraphicDisplayModes.set('Window')
    end

      if shouldLog then log('D', 'graphic',"Sanitizing display resolution - "..tostring(current)..": Failed. Patching to "..newMode) end
      o.GraphicDisplayResolutions.set(newMode)
    end,

      if shouldLog then log('D', 'graphic',"Sanitizing refresh rate - "..tostring(current)..": Failed. Patching to "..tostring(modes.keys[1]).." hertz") end
      o.GraphicDisplayRefreshRates.set(modes.keys[1])
    end

      if shouldLog then log('D', 'graphic',"Sanitizing display - "..tostring(current)..": Failed. Patching to display '"..tostring(modes.keys[1]).."'") end
      o.GraphicDisplayDriver.adapter = o.GraphicDisplayDriver.set(modes.keys[1])
    end

      for k,v in pairs(levelData) do
        o[k].set(v)
      end

        -- log('I','','                              Setting quality to Custom')
        o.GraphicOverallQuality.set(0) -- custom
        return

    if graphicsOptions.WindowPlacement and type(graphicsOptions.WindowPlacement.set) == 'function' then
      graphicsOptions.WindowPlacement.set(newState.WindowPlacement)
      -- Window placement needs to save immediately due to things like pressing Ctrl + L which

    if graphicsOptions.GraphicDisplayDriver and type(graphicsOptions.GraphicDisplayDriver.set) == 'function' then
      graphicsOptions.GraphicDisplayDriver.set(newState.GraphicDisplayDriver)
      graphicsOptions.GraphicDisplayResolutions.SelectHighestForDisplay(newState.GraphicDisplayDriver)

    if graphicsOptions.GraphicDisplayModes and type(graphicsOptions.GraphicDisplayModes.set) == 'function' then
      graphicsOptions.GraphicDisplayModes.set(newState.GraphicDisplayModes)
      shouldLogSanitizeMessage = true

    if graphicsOptions.GraphicDisplayResolutions and type(graphicsOptions.GraphicDisplayResolutions.set) == 'function' then
      graphicsOptions.GraphicDisplayResolutions.set(newState.GraphicDisplayResolutions)
      shouldLogSanitizeMessage = true

    if graphicsOptions.GraphicDisplayRefreshRates and type(graphicsOptions.GraphicDisplayRefreshRates.set) == 'function' then
      graphicsOptions.GraphicDisplayRefreshRates.set(newState.GraphicDisplayRefreshRates)
    end

  -- if videoMem > 1000 then
  --   graphicsOptions.GraphicMeshQuality.set("High")
  --   graphicsOptions.GraphicTextureQuality.set("High")

  --   graphicsOptions.GraphicMeshQuality.set("High")
  --   graphicsOptions.GraphicTextureQuality.set("High")
  --   graphicsOptions.GraphicLightingQuality.set("High")

  --   graphicsOptions.GraphicTextureQuality.set("High")
  --   graphicsOptions.GraphicLightingQuality.set("High")
  --   graphicsOptions.GraphicShaderQuality.set("High")

  --   graphicsOptions.GraphicLightingQuality.set("High")
  --   graphicsOptions.GraphicShaderQuality.set("High")
  --   TorqueScriptLua.call('PostFXManager::settingsApplyHighPreset')

  --   TorqueScriptLua.call('PostFXManager::settingsApplyHighPreset')
  --   graphicsOptions.GraphicPostfxQuality.set(3)
  -- elseif videoMem >= 500 then

  -- elseif videoMem >= 500 then
  --   graphicsOptions.GraphicMeshQuality.set("Normal")
  --   graphicsOptions.GraphicTextureQuality.set("Normal")

  --   graphicsOptions.GraphicMeshQuality.set("Normal")
  --   graphicsOptions.GraphicTextureQuality.set("Normal")
  --   graphicsOptions.GraphicLightingQuality.set("Normal")

  --   graphicsOptions.GraphicTextureQuality.set("Normal")
  --   graphicsOptions.GraphicLightingQuality.set("Normal")
  --   graphicsOptions.GraphicShaderQuality.set("Normal")

  --   graphicsOptions.GraphicLightingQuality.set("Normal")
  --   graphicsOptions.GraphicShaderQuality.set("Normal")
  --   TorqueScriptLua.call('PostFXManager::settingsApplyNormalPreset')

  --   TorqueScriptLua.call('PostFXManager::settingsApplyNormalPreset')
  --   graphicsOptions.GraphicPostfxQuality.set(2)
  -- elseif videoMem > 250 then

  -- elseif videoMem > 250 then
  --   graphicsOptions.GraphicMeshQuality.set("Low")
  --   graphicsOptions.GraphicTextureQuality.set("Low")

  --   graphicsOptions.GraphicMeshQuality.set("Low")
  --   graphicsOptions.GraphicTextureQuality.set("Low")
  --   graphicsOptions.GraphicLightingQuality.set("Low")

  --   graphicsOptions.GraphicTextureQuality.set("Low")
  --   graphicsOptions.GraphicLightingQuality.set("Low")
  --   graphicsOptions.GraphicShaderQuality.set("Low")

  --   graphicsOptions.GraphicLightingQuality.set("Low")
  --   graphicsOptions.GraphicShaderQuality.set("Low")
  --   TorqueScriptLua.call('PostFXManager::settingsApplyLowPreset')

  --   TorqueScriptLua.call('PostFXManager::settingsApplyLowPreset')
  --   graphicsOptions.GraphicPostfxQuality.set(1)
  -- else

  -- else
  --   graphicsOptions.GraphicMeshQuality.set("Lowest")
  --   graphicsOptions.GraphicTextureQuality.set("Lowest")

  --   graphicsOptions.GraphicMeshQuality.set("Lowest")
  --   graphicsOptions.GraphicTextureQuality.set("Lowest")
  --   graphicsOptions.GraphicLightingQuality.set("Lowest")

  --   graphicsOptions.GraphicTextureQuality.set("Lowest")
  --   graphicsOptions.GraphicLightingQuality.set("Lowest")
  --   graphicsOptions.GraphicShaderQuality.set("Lowest")

  --   graphicsOptions.GraphicLightingQuality.set("Lowest")
  --   graphicsOptions.GraphicShaderQuality.set("Lowest")
  --   TorqueScriptLua.call('PostFXManager::settingsApplyLowestPreset')

  --   TorqueScriptLua.call('PostFXManager::settingsApplyLowestPreset')
  --   graphicsOptions.GraphicPostfxQuality.set(0)
  -- end

  local pn = pathData.pathnodes:create()
  pn.pos:set(cpPos)
  pn.radius = cpRadius

        vecA:set(pn.pos)
        vecA.z = vecA.z + pn.radius + 0.25

        vecA.z = vecA.z + pn.radius + 0.25
        vecB:set(vecA)
        vecB.z = vecB.z + 1000

        if pn.normal then
          vecA:set(pn.pos)
          vecB:setScaled2(pn.normal, pn.radius)

			end
--            ui_visibility.set(false)
--            gameplay_markerInteraction.setMarkersVisibleTemporary(false)

--            gameplay_markerInteraction.setMarkersVisibleTemporary(true)
--            ui_visibility.set(true)
	end

local function set(desc, key, val)
	desc[key] = val

					forBuilding(adesc[cedit.mesh], function(w)
	--                    set(w, 'winspace', w.winspace + 0.02 * dir)
						w.winspace = w.winspace + 0.02 * dir

			local floor = adesc[cedit.mesh].afloor[cij[1]]
			set(floor, 'h', floor.h + dir*0.02) -- 0.2 * dir)
			for _,w in pairs(floor.awall) do

			for _,w in pairs(floor.awall) do
				set(w, 'v', vec3(0,0,floor.h))
				w.v = vec3(0,0,floor.h)

				forBuilding(adesc[cedit.mesh], function(w)
--                    set(w, 'winspace', w.winspace + 0.02 * dir)
					w.winleft = w.winleft + 0.02 * dir

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

  local offset = vec3(self.localOffset)
  offset:set(
    self.smX:get(self.localOffset.x, data.dt),

  data.res.rot = data.res.rot or quat()
  data.res.rot:set(quatFromDir((data.res.targetPos - data.res.pos):normalized()))
  return true

        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);

                if (!eventListenersForType)
                    eventListenerTypes.set(eventListener.type, eventListenersForType = []);
                eventListenersForType.push(eventListener);

                if (!eventListenersForTarget)
                    eventListenerTargets.set(target, eventListenersForTarget = []);
                eventListenersForTarget.push(eventListener);

    desiredGearRatio = gearbox.maxGearRatio
    smoother.cvtGearRatioSmoother:set(desiredGearRatio)
  end

    desiredGearRatio = gearbox.maxGearRatio
    smoother.cvtGearRatioSmoother:set(desiredGearRatio)
  end

  smoother.cvtGearRatioSmoother:set(gearbox.maxGearRatio)
  smoother.cvtTargetAVSmoother:set(cvtHandling.lowAV)

  smoother.cvtGearRatioSmoother:set(gearbox.maxGearRatio)
  smoother.cvtTargetAVSmoother:set(cvtHandling.lowAV)

function C:set(pos, rot, scl)
  if pos then

      local newSpot = parkingSpotList:create(self.name .. "." .. (i + 1))
      newSpot:set(pos, rot, self.scl)

local function getBBPoints(bbCenter, bbAxis0, bbAxis1, bbAxis2)
  p1:set(bbCenter) p1:setAdd(bbAxis0) p1:setSub(bbAxis1) p1:setSub(bbAxis2)
  p2:set(bbCenter) p2:setAdd(bbAxis0) p2:setSub(bbAxis1) p2:setAdd(bbAxis2)

  p1:set(bbCenter) p1:setAdd(bbAxis0) p1:setSub(bbAxis1) p1:setSub(bbAxis2)
  p2:set(bbCenter) p2:setAdd(bbAxis0) p2:setSub(bbAxis1) p2:setAdd(bbAxis2)
  p3:set(bbCenter) p3:setSub(bbAxis0) p3:setSub(bbAxis1) p3:setAdd(bbAxis2)

  p2:set(bbCenter) p2:setAdd(bbAxis0) p2:setSub(bbAxis1) p2:setAdd(bbAxis2)
  p3:set(bbCenter) p3:setSub(bbAxis0) p3:setSub(bbAxis1) p3:setAdd(bbAxis2)
  p4:set(bbCenter) p4:setSub(bbAxis0) p4:setSub(bbAxis1) p4:setSub(bbAxis2)

  p3:set(bbCenter) p3:setSub(bbAxis0) p3:setSub(bbAxis1) p3:setAdd(bbAxis2)
  p4:set(bbCenter) p4:setSub(bbAxis0) p4:setSub(bbAxis1) p4:setSub(bbAxis2)
  p5:set(bbCenter) p5:setAdd(bbAxis0) p5:setAdd(bbAxis1) p5:setSub(bbAxis2)

  p4:set(bbCenter) p4:setSub(bbAxis0) p4:setSub(bbAxis1) p4:setSub(bbAxis2)
  p5:set(bbCenter) p5:setAdd(bbAxis0) p5:setAdd(bbAxis1) p5:setSub(bbAxis2)
  p6:set(bbCenter) p6:setAdd(bbAxis0) p6:setAdd(bbAxis1) p6:setAdd(bbAxis2)

  p5:set(bbCenter) p5:setAdd(bbAxis0) p5:setAdd(bbAxis1) p5:setSub(bbAxis2)
  p6:set(bbCenter) p6:setAdd(bbAxis0) p6:setAdd(bbAxis1) p6:setAdd(bbAxis2)
  p7:set(bbCenter) p7:setSub(bbAxis0) p7:setAdd(bbAxis1) p7:setAdd(bbAxis2)

  p6:set(bbCenter) p6:setAdd(bbAxis0) p6:setAdd(bbAxis1) p6:setAdd(bbAxis2)
  p7:set(bbCenter) p7:setSub(bbAxis0) p7:setAdd(bbAxis1) p7:setAdd(bbAxis2)
  p8:set(bbCenter) p8:setSub(bbAxis0) p8:setAdd(bbAxis1) p8:setSub(bbAxis2)

  p7:set(bbCenter) p7:setSub(bbAxis0) p7:setAdd(bbAxis1) p7:setAdd(bbAxis2)
  p8:set(bbCenter) p8:setSub(bbAxis0) p8:setAdd(bbAxis1) p8:setSub(bbAxis2)
  bbPoints[0] = p1; bbPoints[1] = p2; bbPoints[2] = p3; bbPoints[3] = p4;

  velocity:set(veh:getVelocityXYZ())
  local speed = velocity:squaredLength()

  if speed <= square(drivingSpeed) then
    bbCenter:set(be:getObjectOOBBCenterXYZ(vehId))

    else
      vehicleDir:set(veh:getDirectionVectorXYZ())
      parkingSpotDir:set(yVector)

      vehicleDir:set(veh:getDirectionVectorXYZ())
      parkingSpotDir:set(yVector)
      parkingSpotDir:setRotate(self.rot)

        bbAxis0:set(be:getObjectOOBBHalfAxisXYZ(vehId, 0))
        bbAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))

        bbAxis0:set(be:getObjectOOBBHalfAxisXYZ(vehId, 0))
        bbAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))
        bbAxis2:set(be:getObjectOOBBHalfAxisXYZ(vehId, 2))

        bbAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))
        bbAxis2:set(be:getObjectOOBBHalfAxisXYZ(vehId, 2))
        local bbPoints = getBBPoints(bbCenter, bbAxis0, bbAxis1, bbAxis2)

    if veh:getActive() and (not playerId or playerId ~= vehId) then
      bbCenter:set(be:getObjectOOBBCenterXYZ(vehId))

        if map.objects[vehId] then -- complex check for tracked vehicles
          bbAxis0:set(be:getObjectOOBBHalfAxisXYZ(vehId, 0))
          bbAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))

          bbAxis0:set(be:getObjectOOBBHalfAxisXYZ(vehId, 0))
          bbAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))
          bbAxis2:set(be:getObjectOOBBHalfAxisXYZ(vehId, 2))

          bbAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))
          bbAxis2:set(be:getObjectOOBBHalfAxisXYZ(vehId, 2))
          local bbPoints = getBBPoints(bbCenter, bbAxis0, bbAxis1, bbAxis2)

            local nextId = bbPointIds[i + 1] or bbPointIds[1]
            tempPos1:set(bbPoints[pointId])
            tempPos2:set(bbPoints[nextId])

            tempPos1:set(bbPoints[pointId])
            tempPos2:set(bbPoints[nextId])
            if self:containsPoint(linePointFromXnorm(tempPos1, tempPos2, clamp(self.pos:xnormOnLine(tempPos1, tempPos2), 0, 1))) then

  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()

  trajectory[1].normalOrig:setCross(trajectory[1].biNormal, trajectory[1].edgeVec); trajectory[1].normalOrig:normalize()
  trajectory[1].normal:set(trajectory[1].normalOrig)
  local nVec1, nVec2 = vec3(), vec3()

    trajectory[i].normal:set(trajectory[i].normalOrig)

  trajectory[trajectoryCount].normalOrig:setCross(trajectory[trajectoryCount].biNormal, trajectory[trajectoryCount-1].edgeVec); trajectory[trajectoryCount].normalOrig:normalize()
  trajectory[trajectoryCount].normal:set(trajectory[trajectoryCount].normalOrig)

  -- init forces
  for i = 1, trajectoryCount do trajectory[i].force:set(0, 0, 0) end

          nodeIdsDrawn[node1id] = true
          tmpPos:set(0, 0, 2)
          tmpPos:setAdd(map.nodes[node1id].pos)

          nodeIdsDrawn[node2id] = true
          tmpPos:set(0, 0, 2)
          tmpPos:setAdd(map.nodes[node2id].pos)

    obj.objectCollisions = objectCollisions or emptyTable
    obj.pos:set(object:getPositionXYZ())
    obj.vel:set(object:getVelocityXYZ())

    obj.pos:set(object:getPositionXYZ())
    obj.vel:set(object:getVelocityXYZ())
    obj.dirVec:set(object:getDirectionVectorXYZ())

    obj.vel:set(object:getVelocityXYZ())
    obj.dirVec:set(object:getDirectionVectorXYZ())
    obj.dirVecUp:set(object:getDirectionVectorUpXYZ())

    obj.dirVec:set(object:getDirectionVectorXYZ())
    obj.dirVecUp:set(object:getDirectionVectorUpXYZ())
    obj.isParked = object.isParked and true

  obj.objectCollisions = objectCollisions or {}
  obj.pos:set(pos)
  obj.vel:set(vel)

  obj.pos:set(pos)
  obj.vel:set(vel)
  obj.dirVec:set(dirVec)

  obj.vel:set(vel)
  obj.dirVec:set(dirVec)
  obj.dirVecUp:set(dirVecUp)

  obj.dirVec:set(dirVec)
  obj.dirVecUp:set(dirVecUp)

    if dimRdr.extent.x ~= renderSize[1] or dimRdr.extent.y ~= renderSize[2] then
      dimRdr:set(0,0,renderSize[1],renderSize[2])
      dirtyRdr = true

  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

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

      -- remember where we drove off
      data.offTrackData.offPos:set(data.frontPos)
      data.inPrevAiPathIdx = data.aiPathIdx

    if not data.offTrackData.lastFrameIsOnRoad and data.isOnRoad then
      data.offTrackData.onPos:set(data.frontPos)

          maxCutDepth = cutDepth
          data.offTrackData.debugStuff.maxCutDepthPos:set(pos)
        end

        totalDistDrivenOffTrack = totalDistDrivenOffTrack + pos:distance(prevPos)
        prevPos:set(pos)
      end

      if veh then
        vehBBCenter:set(be:getObjectOOBBCenterXYZ(id))
        vehBBHalfExtents:set(be:getObjectOOBBHalfExtentsXYZ(id))

        vehBBCenter:set(be:getObjectOOBBCenterXYZ(id))
        vehBBHalfExtents:set(be:getObjectOOBBHalfExtentsXYZ(id))
        vehVel:set(veh:getVelocityXYZ())

        vehBBHalfExtents:set(be:getObjectOOBBHalfExtentsXYZ(id))
        vehVel:set(veh:getVelocityXYZ())
        vehDir:set(veh:getDirectionVectorXYZ())

        vehVel:set(veh:getVelocityXYZ())
        vehDir:set(veh:getDirectionVectorXYZ())
        local dir = sign2(vehDir:dot(vehVel)) -- negative if driving in reverse

        vehDir:setScaled(vehBBHalfExtents.y * dir)
        data.frontPos:set(vehBBCenter)
        data.frontPos:setAdd(vehDir)

    -- advance corners
  vehPos:set(vehicle:getPositionXYZ())
  vehDir:set(vehicle:getDirectionVectorXYZ())

  vehPos:set(vehicle:getPositionXYZ())
  vehDir:set(vehicle:getDirectionVectorXYZ())
  vehDirUp:set(vehicle:getDirectionVectorUpXYZ())

  vehDir:set(vehicle:getDirectionVectorXYZ())
  vehDirUp:set(vehicle:getDirectionVectorUpXYZ())
  vehRot:setFromDir(vehDir, vehDirUp)

  for i, corner in ipairs(state.wheelOffsets) do
    state.previousCorners[i]:set(state.currentCorners[i])
    state.currentCorners[i]:setRotate(vehRot, corner)

    local c1, c2, c3, c4 = nodes[i1], nodes[i2], nodes[i3], nodes[i4]
    pMouse_2D:set(pMouse.x, pMouse.y, 0.0)
    c1_2D:set(c1.x, c1.y, 0.0)

    pMouse_2D:set(pMouse.x, pMouse.y, 0.0)
    c1_2D:set(c1.x, c1.y, 0.0)
    c2_2D:set(c2.x, c2.y, 0.0)

    c1_2D:set(c1.x, c1.y, 0.0)
    c2_2D:set(c2.x, c2.y, 0.0)
    c3_2D:set(c3.x, c3.y, 0.0)

    c2_2D:set(c2.x, c2.y, 0.0)
    c3_2D:set(c3.x, c3.y, 0.0)
    c4_2D:set(c4.x, c4.y, 0.0)

    c3_2D:set(c3.x, c3.y, 0.0)
    c4_2D:set(c4.x, c4.y, 0.0)
    local isPointInQuad = geom.isPointInTriangle(pMouse_2D, c1_2D, c2_2D, c3_2D) or geom.isPointInTriangle(pMouse_2D, c2_2D, c3_2D, c4_2D)

  if pClosest then
    cursorPos:set(pClosest)

        bestSqDist = dSq
        cursorPos:set(pClosest)
        bestCursorSeg = bestCursorSeg - 1

        bestSqDist = dSq
        cursorPos:set(pClosest)
        bestCursorSeg = bestCursorSeg + 1

        bestSqDist = dSq
        cursorPos:set(pClosest)
        bestCursorSeg = segSample

  local mousePos = util.mouseOnMapPos() -- The current mouse position.
  mouseVel2D:set(mousePos.x - mouseLast.x, mousePos.y - mouseLast.y, 0.0) -- The 2D mouse velocity.
  local isMouseMoving = mouseVel2D:squaredLength() > isMouseMoveTolSq

          isNodeDrag, dragNodeIdx, dragStatePre = true, nodeIdx, deepCopyFn()
          dragStartMousePos:set(mousePos)
          dragStartNodePos:set(ribbons[rIdx].nodes[nodeIdx])

          dragStartMousePos:set(mousePos)
          dragStartNodePos:set(ribbons[rIdx].nodes[nodeIdx])
          return bestCursorSeg, isNodeDrag -- Leave early to prevent the case when selected ribbon has changed - the old selected ribbon must remain intact.

        local offset = mousePos - dragStartMousePos
        nodes[dragNodeIdx]:set(dragStartNodePos + offset)
      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)

      max = max+1
      updateData.bbCenter:set(be:getObjectOOBBCenterXYZ(id))
      updateData.bbHalfAxis0:set(be:getObjectOOBBHalfAxisXYZ(id, 0))

      updateData.bbCenter:set(be:getObjectOOBBCenterXYZ(id))
      updateData.bbHalfAxis0:set(be:getObjectOOBBHalfAxisXYZ(id, 0))
      updateData.bbHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(id, 1))

      updateData.bbHalfAxis0:set(be:getObjectOOBBHalfAxisXYZ(id, 0))
      updateData.bbHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(id, 1))
      updateData.bbHalfAxis2:set(be:getObjectOOBBHalfAxisXYZ(id, 2))

      updateData.bbHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(id, 1))
      updateData.bbHalfAxis2:set(be:getObjectOOBBHalfAxisXYZ(id, 2))
      local dist = OBBsquaredDistance(updateData.bbCenter, updateData.bbHalfAxis0, updateData.bbHalfAxis1, updateData.bbHalfAxis2, center)

      tmpRot.x, tmpRot.y, tmpRot.z, tmpRot.w = meshRot.x, meshRot.y, meshRot.z, meshRot.w
      actualBinormal:set(0, 1, 0) -- Start with Y-axis (binormal in mesh space).
      actualBinormal:setRotate(tmpRot, actualBinormal)

  state.lastPropBaseTranslationGlobal:set(propObj:getBaseTranslationGlobal())
  state.lastPropBaseRotationGlobalQuat:set(propObj:getBaseRotationGlobalQuat())

  state.lastPropBaseTranslationGlobal:set(propObj:getBaseTranslationGlobal())
  state.lastPropBaseRotationGlobalQuat:set(propObj:getBaseRotationGlobalQuat())

  if prop.baseTranslationGlobalRigidWithNodeTransforms then
    prop.baseTranslationGlobalRigidWithNodeTransforms:set(state.lastPropBaseTranslationGlobal)
  elseif prop.baseTranslationGlobalElasticWithNodeTransforms then

  elseif prop.baseTranslationGlobalElasticWithNodeTransforms then
    prop.baseTranslationGlobalElasticWithNodeTransforms:set(state.lastPropBaseTranslationGlobal)
  else

    end
    prop.baseTranslationGlobalWithNodeTransforms:set(state.lastPropBaseTranslationGlobal)
  end

  if prop.baseTranslationGlobalRigidWithNodeTransforms then
    prop.baseTranslationGlobalRigidWithNodeTransforms:set(prevBaseTranslationGlobal)
  elseif prop.baseTranslationGlobalElasticWithNodeTransforms then

  elseif prop.baseTranslationGlobalElasticWithNodeTransforms then
    prop.baseTranslationGlobalElasticWithNodeTransforms:set(prevBaseTranslationGlobal)
  else

  else
    prop.baseTranslationGlobalWithNodeTransforms:set(prevBaseTranslationGlobal)
  end

        state.lastPropBaseTranslationGlobal:set(propObj:getBaseTranslationGlobal())
        state.lastPropBaseRotationGlobalQuat:set(propObj:getBaseRotationGlobalQuat())

        state.lastPropBaseTranslationGlobal:set(propObj:getBaseTranslationGlobal())
        state.lastPropBaseRotationGlobalQuat:set(propObj:getBaseRotationGlobalQuat())
        state.lastPropBaseRotationGlobal = propObj:getBaseRotationGlobal()

  oldPosition:set(core_camera.getPosition())
  local cQ = core_camera.getQuat()

    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,

    if not self.hiddenAfterReset then
      self.mgr.modules.button:set(self.pinOut.buttonId.value, "active", false)
      self.hiddenAfterReset = true

  if self.hiddenAfterReset then
    self.mgr.modules.button:set(id, "active", true)
  end

  if self.pinIn.hideWhenDone.value and not self.hiddenAfterDone and button.used.value then
    self.mgr.modules.button:set(id, "active", false)
    self.hiddenAfterDone = true

        this._timelinesTreeOutline.insertChild(treeElement, insertionIndex);
        this._treeElementsByTypeMap.set(timeline.type, treeElement);

        overviewGraph.addEventListener(WI.TimelineOverviewGraph.Event.RecordSelected, this._handleOverviewGraphRecordSelected, this);
        this._overviewGraphsByTypeMap.set(timeline.type, overviewGraph);
        this._graphsContainerView.insertSubviewBefore(overviewGraph, this._graphsContainerView.subviews[insertionIndex]);

  -- calculate some stats about the impact / sanitize the data
  tempAveragePos:set(0, 0, 0)
  local totalDamage = 0

  end
  tempAveragePos:set(tempAveragePos / #crashData.currentImpactData.frameDamages)
  crashData.currentImpactData.averagePos = tempAveragePos

  for _, point in pairs(crashData.accelData) do
    tempVecPos:set(vehData.pos + point.offsetFromCenter * vehData.dirVec)
    tempVecCurrVel:set((point.lastFramePos and (tempVecPos - point.lastFramePos) or vec3()) / dtSim)

    tempVecPos:set(vehData.pos + point.offsetFromCenter * vehData.dirVec)
    tempVecCurrVel:set((point.lastFramePos and (tempVecPos - point.lastFramePos) or vec3()) / dtSim)
    tempVecCurrAccel:set((point.lastFrameVel and (tempVecCurrVel - point.lastFrameVel) or vec3()) / dtSim)

    tempVecCurrVel:set((point.lastFramePos and (tempVecPos - point.lastFramePos) or vec3()) / dtSim)
    tempVecCurrAccel:set((point.lastFrameVel and (tempVecCurrVel - point.lastFrameVel) or vec3()) / dtSim)

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

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

    point.vel:set(tempVecCurrVel)

  self.iconPositionSmoother = newTemporalSmoothingNonLinear(10,10)
  self.iconPositionSmoother:set(5)
end

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

    end
    tmpVec:set(0, 0, markerPosHeightOffset)
  end

      proxy.wp = nil
      proxy.nudgeForwardSmoother:set(0)
      proxy.nudgeForwardSmootherTarget = 0

      proxy.nudgeForwardSmootherTarget = 0
      proxy.nearFarScaleSmoother:set(0)
      proxy.nearFarScaleSmootherTarget = 0

      proxy.nearFarScaleSmootherTarget = 0
      proxy.alphaSmoother:set(0)
      proxy.alphaSmootherTarget = 0

              setSmootherTargets(id, distToVehicle)
              arrowProxies[id].nudgeForwardSmoother:set(arrowProxies[id].nudgeForwardSmootherTarget)
              arrowProxies[id].nearFarScaleSmoother:set(arrowProxies[id].nearFarScaleSmootherTarget)

              arrowProxies[id].nudgeForwardSmoother:set(arrowProxies[id].nudgeForwardSmootherTarget)
              arrowProxies[id].nearFarScaleSmoother:set(arrowProxies[id].nearFarScaleSmootherTarget)
              arrowProxies[id].alphaSmoother:set(0)

              arrowProxies[id].nearFarScaleSmoother:set(arrowProxies[id].nearFarScaleSmootherTarget)
              arrowProxies[id].alphaSmoother:set(0)
            else

    if arrow then
      actualPos:set(proxy.pos.x, proxy.pos.y, proxy.pos.z)
      fwd:setRotate(proxy.rot, yVec)

      local scaleVal = proxy.nearFarScaleSmoother:get(proxy.nearFarScaleSmootherTarget, dt) * alphaValue
      scale:set(scaleVal, scaleVal, scaleVal)
      arrow:setScale(scale)

      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)

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

  local bobTime = self.colorTimer * bobFrequency * math.pi * 2
  bobOffset:set(0, 0, math.sin(bobTime) * bobAmplitude)

  playerPosition:set(core_camera.getPosition())
  local distanceFromMarker = self.pos:distance(playerPosition)

    leftColumn:setPosition(self.leftConePos + columnOffset)
    scale:set(scalarThin, scalarThin, sideHeight)
    leftColumn:setScale(scale)

    rightColumn:setPosition(self.rightConePos + columnOffset)
    scale:set(scalarThin, scalarThin, sideHeight)
    rightColumn:setScale(scale)

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

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

        dirVec:normalize()
        nodes[1].dir:set(dirVec)
        nodes[1].up:set(map.surfaceNormal(pos, 1))

        nodes[1].dir:set(dirVec)
        nodes[1].up:set(map.surfaceNormal(pos, 1))
        break

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

  for i = 1, #path-1 do
    tmpVec:set(   map.getMap().nodes[path[i  ]].pos)
    tmpVec:setSub(map.getMap().nodes[path[i+1]].pos)

  if not isDragging and im.IsMouseClicked(0) then
    anchorPos:set(mousePos)
    isDragging = true

  spawnPos:set(((lane - 0.5) * laneWidth - radius) * push3(lateralDirVec) + spawnPos) -- spawn position
  p2p1DirVec:setScaled((lanes:byte(lane) == 43 and 1 or -1)) -- spawn direction

    mousePos:set(staticRayCast() or vecUp)

      data.stats.prevVel:set(mapVehData.vel)
      data.stats.prevPos:set(mapVehData.pos)

      data.stats.prevVel:set(mapVehData.vel)
      data.stats.prevPos:set(mapVehData.pos)

  -- 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)

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

      min = dist
      prevPos:set(self.pinIn.waypoints.value[i])
      nextPos:set(self.pinIn.waypoints.value[i + 1])

      prevPos:set(self.pinIn.waypoints.value[i])
      nextPos:set(self.pinIn.waypoints.value[i + 1])
      index = i

    }
    SCOPE_HANDLER_REGISTRY.set(scopeElement, scopeRegistry)
  }

    if (depth >= 0) {
      elementDepths.set(el, depth)
      return true

  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

    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

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

      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

 * @return     {Object}            An interface with methods to retrieve the `current()` UI scope (as a computed), and
 *                                 to `set()` the current scope
 */

function C:set(pos, rot)
  self.pos = vec3(pos)

            nodeMap = new Map;
            this._keyMap.set(key, nodeMap);
        }

            node = this._insertionOrderedEntries.push([key, value]);
            nodeMap.set(value, node);
        }

        renderView.resolution = Point2I(previewWindowSize.x, previewWindowSize.y)
        viewPortRect:set(0, 0, previewWindowSize.x, previewWindowSize.y)
        renderView.viewPort = viewPortRect

    {
        this._scriptIdMap.set(script.id, script);

                scripts = [];
                this._scriptContentIdentifierMap.set(script.contentIdentifier, scripts);
            }

  -- 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)

  simTimeAuthority.set(0.5)
  setActive(false)

  simTimeAuthority.set(1)
  if tp then

        core_audio.triggerBankHotloading()
        if o.AudioMasterVol then o.AudioMasterVol.set(o.AudioMasterVol.get() or 0) end
        if o.AudioInterfaceVol then o.AudioInterfaceVol.set(o.AudioInterfaceVol.get() or 0) end

        if o.AudioMasterVol then o.AudioMasterVol.set(o.AudioMasterVol.get() or 0) end
        if o.AudioInterfaceVol then o.AudioInterfaceVol.set(o.AudioInterfaceVol.get() or 0) end
        if o.AudioUiVol then o.AudioUiVol.set(o.AudioUiVol.get() or 0) end

        if o.AudioInterfaceVol then o.AudioInterfaceVol.set(o.AudioInterfaceVol.get() or 0) end
        if o.AudioUiVol then o.AudioUiVol.set(o.AudioUiVol.get() or 0) end
        if o.AudioAmbienceVol then o.AudioAmbienceVol.set(o.AudioAmbienceVol.get() or 0) end

        if o.AudioUiVol then o.AudioUiVol.set(o.AudioUiVol.get() or 0) end
        if o.AudioAmbienceVol then o.AudioAmbienceVol.set(o.AudioAmbienceVol.get() or 0) end
        if o.AudioMusicVol then o.AudioMusicVol.set(o.AudioMusicVol.get() or 0) end

        if o.AudioAmbienceVol then o.AudioAmbienceVol.set(o.AudioAmbienceVol.get() or 0) end
        if o.AudioMusicVol then o.AudioMusicVol.set(o.AudioMusicVol.get() or 0) end
      end

local function restoreDefaults()
  audioOptions.AudioMasterVol.set(1.0)
  audioOptions.AudioPowerVol.set(0.8)

  audioOptions.AudioMasterVol.set(1.0)
  audioOptions.AudioPowerVol.set(0.8)
  audioOptions.AudioForcedInductionVol.set(0.8)

  audioOptions.AudioPowerVol.set(0.8)
  audioOptions.AudioForcedInductionVol.set(0.8)
  audioOptions.AudioTransmissionVol.set(0.8)

  audioOptions.AudioForcedInductionVol.set(0.8)
  audioOptions.AudioTransmissionVol.set(0.8)
  audioOptions.AudioSuspensionVol.set(0.8)

  audioOptions.AudioTransmissionVol.set(0.8)
  audioOptions.AudioSuspensionVol.set(0.8)
  audioOptions.AudioSurfaceVol.set(0.8)

  audioOptions.AudioSuspensionVol.set(0.8)
  audioOptions.AudioSurfaceVol.set(0.8)
  audioOptions.AudioCollisionVol.set(0.8)

  audioOptions.AudioSurfaceVol.set(0.8)
  audioOptions.AudioCollisionVol.set(0.8)
  audioOptions.AudioAeroVol.set(0.8)

  audioOptions.AudioCollisionVol.set(0.8)
  audioOptions.AudioAeroVol.set(0.8)
  audioOptions.AudioEnvironmentVol.set(0.8)

  audioOptions.AudioAeroVol.set(0.8)
  audioOptions.AudioEnvironmentVol.set(0.8)
  audioOptions.AudioMusicVol.set(0.8)

  audioOptions.AudioEnvironmentVol.set(0.8)
  audioOptions.AudioMusicVol.set(0.8)
  audioOptions.AudioUiVol.set(0.8)

  audioOptions.AudioMusicVol.set(0.8)
  audioOptions.AudioUiVol.set(0.8)
  audioOptions.AudioOtherVol.set(0.8)

  audioOptions.AudioUiVol.set(0.8)
  audioOptions.AudioOtherVol.set(0.8)
  audioOptions.AudioLfeVol.set(0.5)

  audioOptions.AudioOtherVol.set(0.8)
  audioOptions.AudioLfeVol.set(0.5)
  audioOptions.AudioIntercomVol.set(0.8)

  audioOptions.AudioLfeVol.set(0.5)
  audioOptions.AudioIntercomVol.set(0.8)

  origin:set(veh:getPosition())
  target:setFromTable(self.pinIn.target.value)

        origin:set(veh:getPosition())
        target:setFromTable(self.pinIn.target.value)

    if isFirstEval then
      tmp1:set(i2.x, i2.y, 0)
      tmp2:set(i3.x, i3.y, 0)

      tmp1:set(i2.x, i2.y, 0)
      tmp2:set(i3.x, i3.y, 0)
      tmp3:set(i4.x, i4.y, 0)

      tmp2:set(i3.x, i3.y, 0)
      tmp3:set(i4.x, i4.y, 0)
      cen = util.circle2DFrom3Points(tmp1, tmp2, tmp3)

      local radius1, radius2 = nil, nil
      tmp1:set(i1.x, i1.y, 0)
      tmp2:set(i2.x, i2.y, 0)

      tmp1:set(i1.x, i1.y, 0)
      tmp2:set(i2.x, i2.y, 0)
      tmp3:set(i3.x, i3.y, 0)

      tmp2:set(i2.x, i2.y, 0)
      tmp3:set(i3.x, i3.y, 0)
      local cen1 = util.circle2DFrom3Points(tmp1, tmp2, tmp3)

      if cen1 then radius1 = cen1:distance(tmp1) end
      tmp1:set(i2.x, i2.y, 0)
      tmp2:set(i3.x, i3.y, 0)

      tmp1:set(i2.x, i2.y, 0)
      tmp2:set(i3.x, i3.y, 0)
      tmp3:set(i4.x, i4.y, 0)

      tmp2:set(i3.x, i3.y, 0)
      tmp3:set(i4.x, i4.y, 0)
      local cen2 = util.circle2DFrom3Points(tmp1, tmp2, tmp3)

  local pDisc, rDisc, oDisc, wDisc, hLDisc, hRDisc = {}, {}, {}, {}, {}, {}
  pStart_2D:set(p1.x, p1.y, 0.0)
  pMid_2D:set(p2.x, p2.y, 0.0)

  pStart_2D:set(p1.x, p1.y, 0.0)
  pMid_2D:set(p2.x, p2.y, 0.0)
  pEnd_2D:set(p3.x, p3.y, 0.0)

  pMid_2D:set(p2.x, p2.y, 0.0)
  pEnd_2D:set(p3.x, p3.y, 0.0)
  local v1 = pStart_2D - cen

    -- Compute the incircle.
    tmp1:set(pI.x, pI.y, 0.0)
    tmp2:set(pIm.x, pIm.y, 0.0)

    tmp1:set(pI.x, pI.y, 0.0)
    tmp2:set(pIm.x, pIm.y, 0.0)
    tmp3:set(pIp.x, pIp.y, 0.0)

    tmp2:set(pIm.x, pIm.y, 0.0)
    tmp3:set(pIp.x, pIp.y, 0.0)
    local iCen_2D, iRad = computeIncircle2D(tmp1, tmp2, tmp3)

    local tgt_3D = pIp - pIm
    tgt_2D:set(tgt_3D.x, tgt_3D.y, 0.0)
    tgt_2D:normalize()

    local pStart_3D = vec3(pDisc[lastIdx].x, pDisc[lastIdx].y, 0)
    pStart_2D:set(pStart_3D.x, pStart_3D.y, 0.0)
    local i1, i2, i3, i4 = pPrev, pStart_2D, vec3(u1_2D.x, u1_2D.y, 0), vec3(u2_2D.x, u2_2D.y, 0)

    local div1, div2 = map[i2], map[i3]
    tmp1:set(pDisc[div1].x, pDisc[div1].y, 0)
    tmp2:set(pDisc[div2].x, pDisc[div2].y, 0)

    tmp1:set(pDisc[div1].x, pDisc[div1].y, 0)
    tmp2:set(pDisc[div2].x, pDisc[div2].y, 0)
    local dAll = tmp1:distance(tmp2)

    for _ = 1, size do
      tmp3:set(pDisc[ctr].x, pDisc[ctr].y, 0)
      local d1 = tmp3:distance(tmp1)

      local p = road.nodes[i].p
      tmp1:set(p.x, p.y, 0)
      p.z = core_terrain.getTerrainHeight(tmp1)

        local p1, p2, p3 = nodes[i - 1].p, nodes[i].p, nodes[i + 1].p
        tmp1:set(p1.x, p1.y, 0)
        tmp2:set(p2.x, p2.y, 0)

        tmp1:set(p1.x, p1.y, 0)
        tmp2:set(p2.x, p2.y, 0)
        tmp3:set(p3.x, p3.y, 0)

        tmp2:set(p2.x, p2.y, 0)
        tmp3:set(p3.x, p3.y, 0)
        local cen = util.circle2DFrom3Points(tmp1, tmp2, tmp3)

    nml:normalize()
    tmpLat:set(nml.y * tgt.z - nml.z * tgt.y, nml.z * tgt.x - nml.x * tgt.z, nml.x * tgt.y - nml.y * tgt.x)
    tmpLat:normalize()

      rdk[5] = nml                                                                                  -- [5] The road section unit normal vector (not quad local).
      rdk[6]:set(tmpLat.x, tmpLat.y, tmpLat.z)                                                      -- [6] The road section unit lateral vectors (not quad local).
      rdk[7] = (p1 + p2) * 0.5                                                                      -- [7] The lane midpoint (on top face).

      rdk[5] = nml                                                                                  -- [5] The road section unit normal vector (not quad local).
      rdk[6]:set(tmpLat.x, tmpLat.y, tmpLat.z)                                                      -- [6] The road section unit lateral vectors (not quad local).
      rdk[7] = (p1 + p2) * 0.5                                                                      -- [7] The lane midpoint (on top face).

        local l1, l2, l3, l4 = rDL[1], rDL[2], rDL[3], rDL[4]
        tmp1:set(l1.x, l1.y, 0)
        tmp2:set(l2.x, l2.y, 0)

        tmp1:set(l1.x, l1.y, 0)
        tmp2:set(l2.x, l2.y, 0)
        local gL = core_terrain.getTerrainHeight(tmp1)                                              -- Get the terrain height value under the left and right points.

        local gR = core_terrain.getTerrainHeight(tmp2)
        tmp1:set(0, 0, l4.z - gL)                                                                   -- The left and right vertical offset vectors, required to conform the road.
        tmp2:set(0, 0, l3.z - gR)

        tmp1:set(0, 0, l4.z - gL)                                                                   -- The left and right vertical offset vectors, required to conform the road.
        tmp2:set(0, 0, l3.z - gR)
        rDL[1], rDL[2], rDL[3], rDL[4] = l1 - tmp1, l2 - tmp2, l3 - tmp2, l4 - tmp1

    -- Exit early if too far from camera
    vehPos:set(be:getObjectPositionXYZ(data.subjectID))
    camPos:set(core_camera.getPositionXYZ())

    vehPos:set(be:getObjectPositionXYZ(data.subjectID))
    camPos:set(core_camera.getPositionXYZ())
    if vehPos:distance(camPos) > camDistanceLimit then return end

    vehVelocity:set(be:getObjectVelocityXYZ(data.subjectID))
    local vehSpeed = vehVelocity:length()

  edge2:setSub2(node3, node1)
  edge1Norm:set(edge1)
  edge1Norm:normalize()

  edge1Norm:normalize()
  edge2Norm:set(edge2)
  edge2Norm:normalize()

  -- Compute the local triangle Frenet frame (triangle space).
  forwardTS:set(state.triangleSpaceForward)
  upTS:set(state.triangleSpaceUp)

  forwardTS:set(state.triangleSpaceForward)
  upTS:set(state.triangleSpaceUp)
  rightTS:setCross(edge1Norm, normal)

  edge2:setSub2(node3, node1)
  edge1Norm:set(edge1)
  edge1Norm:normalize()

  edge1Norm:normalize()
  edge2Norm:set(edge2)
  edge2Norm:normalize()

  a3:setScaled2(obj:getNodeForceVector(state.node3Idx), 1.0 / m3)
  v1:set(obj:getNodeVelocityVector(state.node1Idx)) -- Velocity vectors at each node.
  v2:set(obj:getNodeVelocityVector(state.node2Idx))

  v1:set(obj:getNodeVelocityVector(state.node1Idx)) -- Velocity vectors at each node.
  v2:set(obj:getNodeVelocityVector(state.node2Idx))
  v3:set(obj:getNodeVelocityVector(state.node3Idx))

  v2:set(obj:getNodeVelocityVector(state.node2Idx))
  v3:set(obj:getNodeVelocityVector(state.node3Idx))

  -- Compute the local triangle Frenet frame (triangle space).
  forwardTS:set(state.triangleSpaceForward) -- The 'forward' vector in triangle space.
  upTS:set(state.triangleSpaceUp) -- The 'up' vector in triangle space.

  forwardTS:set(state.triangleSpaceForward) -- The 'forward' vector in triangle space.
  upTS:set(state.triangleSpaceUp) -- The 'up' vector in triangle space.
  rightTS:setCross(edge1Norm, normal) -- The 'right' vector in triangle space.

  -- Transform the total acceleration vector to world space.
  accel:set(totalAccel:dot(forwardWS), totalAccel:dot(upWS), totalAccel:dot(rightWS))

  -- Set final smoothed readings.
  state.smoothedAccelReading:set(accel2X, accel2Y, accel2Z)
  state.smoothedGyroReading:set(gyro2X, gyro2Y, gyro2Z)

  state.smoothedAccelReading:set(accel2X, accel2Y, accel2Z)
  state.smoothedGyroReading:set(gyro2X, gyro2Y, gyro2Z)

    if drawRimBeamForces then
      tmpVectorSum:set(0, 0, 0)
      for _, rBeam in ipairs(data.rimBeamsNode1) do

      smoothZ = data.rimBeamsNode1SmootherZ:get(tmpVectorSum.z, dt)
      data.rimBeamsNode1VectorSum:set(smoothX, smoothY, smoothZ)

      tmpVectorSum:set(0, 0, 0)
      for _, rBeam in ipairs(data.rimBeamsNode2) do

      smoothZ = data.rimBeamsNode2SmootherZ:get(tmpVectorSum.z, dt)
      data.rimBeamsNode2VectorSum:set(smoothX, smoothY, smoothZ)
    end

    if drawSidewallBeamForces then
      tmpVectorSum:set(0, 0, 0)
      for _, sBeamData in ipairs(data.sidewallBeamsNode1) do

      smoothZ = data.sidewallBeamsNode1SmootherZ:get(tmpVectorSum.z, dt)
      data.sidewallBeamsNode1VectorSum:set(smoothX, smoothY, smoothZ)

      tmpVectorSum:set(0, 0, 0)
      for _, sBeamData in ipairs(data.sidewallBeamsNode2) do

      smoothZ = data.sidewallBeamsNode2SmootherZ:get(tmpVectorSum.z, dt)
      data.sidewallBeamsNode2VectorSum:set(smoothX, smoothY, smoothZ)
    end

    if drawSuspensionBeamForces then
      tmpVectorSum:set(0, 0, 0)
      for _, sBeam in ipairs(data.suspensionBeamsNode1) do

      smoothZ = data.suspensionBeamsNode1SmootherZ:get(tmpVectorSum.z, dt)
      data.suspensionBeamsNode1VectorSum:set(smoothX, smoothY, smoothZ)

      tmpVectorSum:set(0, 0, 0)
      for _, sBeam in ipairs(data.suspensionBeamsNode2) do

      smoothZ = data.suspensionBeamsNode2SmootherZ:get(tmpVectorSum.z, dt)
      data.suspensionBeamsNode2VectorSum:set(smoothX, smoothY, smoothZ)

    if drawTreadNodeForces then
      tmpVectorSum:set(0, 0, 0)
      for _, tNode in ipairs(data.treadNodes) do

      smoothZ = data.treadNodesSmootherZ:get(tmpVectorSum.z, dt)
      data.treadNodesVectorSum:set(smoothX, smoothY, smoothZ)
    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

      if self.pinIn[p].value ~= nil then
        self.mgr.modules.button:set(id, p, self.pinIn[p].value)
      end

      local pos = obj:getNodePosition(i)
      tempVec:set(pos)
      tempVec:setAdd(bigOffset)

        local node = v.data.nodes[i]
        tempVec2:set(obj:getNodePositionRelativeXYZ(node.cid))
        tempVec2:setAdd(initRefNodePos)

    initRenderNodeTexts(partsSelected, showWheels)
    tempVec:set(obj:getPositionXYZ())
    for groupID, entries in pairs(groupIDToEntries) do

      end
      beamPositions[i]:set(tempVec)
      tempVec:setSub(vehPos)

  elseif modeID == 12 then
    tempVec:set(0,0,0)
    local j = 0

  elseif modeID == 13 then
    tempVec:set(0,0,0)
    local j = 0

      const url = new URL(u, location.href);
      url.searchParams.set(tag, Date.now().toString());
      return url.toString();

  -- 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()

            if (previousTabBarItemSizeAndPosition)
                beforeTabSizesAndPositions.set(tabBarItem, {left: previousTabBarItemSizeAndPosition.left + previousTabBarItemSizeAndPosition.width, width: 0});
            else

            else
                beforeTabSizesAndPositions.set(tabBarItem, {left: 0, width: 0});

            var boundingRect = tabBarItem.element.getBoundingClientRect();
            tabBarItemSizesAndPositions.set(tabBarItem, {left: boundingRect.left - barRect.left, width: boundingRect.width});
        }

    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

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

    const key = `[${className}] ${funcName}`
    this.perfStartTimes.set(key, performance.now())
  }

      }
      this.perfMetrics.set(key, metrics)
    }

        this._resourceRecordMap.set(record.resource, record);

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

-- 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))

            for (let property of result)
                properties.set(property.name, property);

local function updateCameraPose()
  gView:set(0.0, -meshRad * auditionPlanarDistFac, auditionHeight + meshRad * auditionElevationFac)
  local gRot = quatFromDir(auditionVec - gView)

  local x, y, s, c = gView.x, gView.y, sin(ang), cos(ang)
  auditionCamPos:set(x * c - y * s, x * s + y * c, gView.z)
  tmp1:set(auditionVec.x - auditionCamPos.x, auditionVec.y - auditionCamPos.y, auditionVec.z - auditionCamPos.z)

  auditionCamPos:set(x * c - y * s, x * s + y * c, gView.z)
  tmp1:set(auditionVec.x - auditionCamPos.x, auditionVec.y - auditionCamPos.y, auditionVec.z - auditionCamPos.z)
  local gRot = quatFromDir(tmp1)

      camPos:set(sobj:getPosition())
      local vel = ((camPosPrev or camPos) - camPos) / dtSim

      local vel = ((camPosPrev or camPos) - camPos) / dtSim
      camPosPrev:set(camPos)

    panningLocal = panningSpeedFactor * panningLocal
    self.camVel:set(panningLocal:toBase(sideVector, -forwardVector, upVector)) -- speed coords to world coords
  end

  local carPos, carVel = self.carPos, self.carVel -- just for convenience
  carPos:set(data.pos)
  carVel:set(data.vel)

  carPos:set(data.pos)
  carVel:set(data.vel)
  local nx, ny, nz = getNxyz(self.refNodes, data.veh)

  if core_camera.objectTeleported(carPos, self.lastCarPos, self.lastCarVel, data.dt) then self:carTeleported() end -- car *appears* to have teleported since the last time this camera was used
  self.lastCarPos:set(carPos)
  self.lastCarVel:set(carVel)

  self.lastCarPos:set(carPos)
  self.lastCarVel:set(carVel)

  self.camPos = self.camPos + self.camVel * data.dt
  self.lastCamPos:set(self.camPos)

  -- fill output table, and pass it through all remaining filters
  data.res.pos:set(self.camPos)
  self.predictor:update(data)

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

      $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)

  end
  ps:set(data.pos, nil, psVehScales["Car"])
  transformUtil:enableEditing(0)

function C:setTransform()
  transformUtil:set(self.current.pos, self.current.rot, self.current.scl)
end

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

    if self.customData and self.customData.useJsonVersion and (self.camT < markers[1].time) then
      data.res.pos:set(markers[1].pos)
      data.res.rot:set(markers[1].rot)

      data.res.pos:set(markers[1].pos)
      data.res.rot:set(markers[1].rot)
      if path.manualFov then

    if markers[n2].cut then
      data.res.pos:set(markers[n3].pos)
      data.res.rot:set(markers[n3].rot)

      data.res.pos:set(markers[n3].pos)
      data.res.rot:set(markers[n3].rot)
      data.res.fov = markers[n3].fov or 60

  -- application
  data.res.pos:set(pos)
  data.res.rot:set(rot)

  data.res.pos:set(pos)
  data.res.rot:set(rot)
  if path.manualFov then

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

-- general ui visibility
local function set(visible)
  visible = visible and true or false

local function toggle()
  set(not get())
end

        // camera border width is 9 px on each side
        offset.set(minX + 9, minY + 9)
        size.set(maxX - minX - 18, maxY - minY - 18)

        offset.set(minX + 9, minY + 9)
        size.set(maxX - minX - 18, maxY - minY - 18)
      }

  meshRot.x, meshRot.y, meshRot.z, meshRot.w = rot.x, rot.y, rot.z, rot.w
  meshXAxis:set(1, 0, 0)
  meshXAxis:setRotate(meshRot, meshXAxis)

  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

    local n1, n2, n3, n4 = i1.normal, i2.normal, i3.normal, i4.normal
    tmp1:set(p1.x, p1.y, i1.width)
    tmp2:set(p2.x, p2.y, i2.width)

    tmp1:set(p1.x, p1.y, i1.width)
    tmp2:set(p2.x, p2.y, i2.width)
    tmp3:set(p3.x, p3.y, i3.width)

    tmp2:set(p2.x, p2.y, i2.width)
    tmp3:set(p3.x, p3.y, i3.width)
    tmp4:set(p4.x, p4.y, i4.width)

    tmp3:set(p3.x, p3.y, i3.width)
    tmp4:set(p4.x, p4.y, i4.width)
    for q = startIdx, 1, 0.1 do

  self.xOffset:set(veh:getDirectionVector():cross(veh:getDirectionVectorUp()) * (self.pinIn.widthOffset.value or 0))
  self.yOffset:set(veh:getDirectionVector() * (self.pinIn.lengthOffset.value or 0))

  self.xOffset:set(veh:getDirectionVector():cross(veh:getDirectionVectorUp()) * (self.pinIn.widthOffset.value or 0))
  self.yOffset:set(veh:getDirectionVector() * (self.pinIn.lengthOffset.value or 0))
  self.zOffset:set(veh:getDirectionVectorUp() * (self.pinIn.heightOffset.value or 0.5))

  self.yOffset:set(veh:getDirectionVector() * (self.pinIn.lengthOffset.value or 0))
  self.zOffset:set(veh:getDirectionVectorUp() * (self.pinIn.heightOffset.value or 0.5))

  self.points.FL.pos:set(oobb:getPoint(0) - self.xOffset + self.yOffset + self.zOffset)
  self.points.FR.pos:set(oobb:getPoint(3) + self.xOffset + self.yOffset + self.zOffset)

  self.points.FL.pos:set(oobb:getPoint(0) - self.xOffset + self.yOffset + self.zOffset)
  self.points.FR.pos:set(oobb:getPoint(3) + self.xOffset + self.yOffset + self.zOffset)
  self.points.BR.pos:set(oobb:getPoint(7) + self.xOffset - self.yOffset + self.zOffset)

  self.points.FR.pos:set(oobb:getPoint(3) + self.xOffset + self.yOffset + self.zOffset)
  self.points.BR.pos:set(oobb:getPoint(7) + self.xOffset - self.yOffset + self.zOffset)
  self.points.BL.pos:set(oobb:getPoint(4) - self.xOffset - self.yOffset + self.zOffset)

  self.points.BR.pos:set(oobb:getPoint(7) + self.xOffset - self.yOffset + self.zOffset)
  self.points.BL.pos:set(oobb:getPoint(4) - self.xOffset - self.yOffset + self.zOffset)

  self.points.F.pos:set(linePointFromXnorm(self.points.FL.pos, self.points.FR.pos, 0.5))
  self.points.R.pos:set(linePointFromXnorm(self.points.FR.pos, self.points.BR.pos, 0.5))

  self.points.F.pos:set(linePointFromXnorm(self.points.FL.pos, self.points.FR.pos, 0.5))
  self.points.R.pos:set(linePointFromXnorm(self.points.FR.pos, self.points.BR.pos, 0.5))
  self.points.B.pos:set(linePointFromXnorm(self.points.BR.pos, self.points.BL.pos, 0.5))

  self.points.R.pos:set(linePointFromXnorm(self.points.FR.pos, self.points.BR.pos, 0.5))
  self.points.B.pos:set(linePointFromXnorm(self.points.BR.pos, self.points.BL.pos, 0.5))
  self.points.L.pos:set(linePointFromXnorm(self.points.BL.pos, self.points.FL.pos, 0.5))

  self.points.B.pos:set(linePointFromXnorm(self.points.BR.pos, self.points.BL.pos, 0.5))
  self.points.L.pos:set(linePointFromXnorm(self.points.BL.pos, self.points.FL.pos, 0.5))

  self.center:set(linePointFromXnorm(self.points.F.pos, self.points.B.pos, 0.5))

                id = this._failureObjectIdentifier++;
                this._failureObjects.set(object, id);
            }

  local loc = data.list:create()
  loc:set(data.pos, 3)
  if data.loc then

  oobbCenter:set(be:getObjectOOBBCenterXYZ(vehId))
  local x, y, z = be:getObjectOOBBHalfExtentsXYZ(vehId);

  tmp1:set(pL.x, pL.y, pL.z + zExtra)
  util.vertRaycast(tmp1)

  tmp1:set(pR.x, pR.y, pR.z + zExtra)
  util.vertRaycast(tmp1)

  tmp1:set(qL.x, qL.y, qL.z + zExtra)
  util.vertRaycast(tmp1)

  tmp1:set(qR.x, qR.y, qR.z + zExtra)
  util.vertRaycast(tmp1)

  -- Use the actual minimap center coordinates, not the buffer offsets
  centerLocal:set(width/2, height/2, 0)

  -- Apply the same transformation as worldToMapXYZ but for direction vectors
  directionLocal:set(worldYDirection)
  directionLocal:setScaled(1/scale)  -- Scale like in worldToMapXYZ

  local targetDistance = math.max(width, height) * 2  -- Use a large enough distance to ensure we hit the boundary
  intersectionLocal:set(centerLocal.x + directionLocal.x * targetDistance, centerLocal.y + directionLocal.y * targetDistance, 0)

  -- Left vertical line of "N"
  leftTop:set(centerX - letterSize * 0.3, centerY + letterSize * 0.4, 0)
  leftBottom:set(centerX - letterSize * 0.3, centerY - letterSize * 0.4, 0)

  leftTop:set(centerX - letterSize * 0.3, centerY + letterSize * 0.4, 0)
  leftBottom:set(centerX - letterSize * 0.3, centerY - letterSize * 0.4, 0)

  -- Right vertical line of "N"
  rightTop:set(centerX + letterSize * 0.3, centerY + letterSize * 0.4, 0)
  rightBottom:set(centerX + letterSize * 0.3, centerY - letterSize * 0.4, 0)

  rightTop:set(centerX + letterSize * 0.3, centerY + letterSize * 0.4, 0)
  rightBottom:set(centerX + letterSize * 0.3, centerY - letterSize * 0.4, 0)

  -- Diagonal line of "N"
  diagonalTop:set(centerX + letterSize * 0.3, centerY + letterSize * 0.4, 0)
  diagonalBottom:set(centerX - letterSize * 0.3, centerY - letterSize * 0.4, 0)

  diagonalTop:set(centerX + letterSize * 0.3, centerY + letterSize * 0.4, 0)
  diagonalBottom:set(centerX - letterSize * 0.3, centerY - letterSize * 0.4, 0)
  local lineWidth = 1

  -- camera setup
  camPos:set(core_camera.getPositionXYZ())
  cameraLook:set(core_camera.getForwardXYZ())

  camPos:set(core_camera.getPositionXYZ())
  cameraLook:set(core_camera.getForwardXYZ())
  --cameraLook:setRotate(core_camera.getQuat())

  end
  camRotInverse:set(camRot)
  camRotInverse:inverse()

    local lookaheadValue = debugSettingsData.lookaheadValue[debugSettings.lookaheadValue].value
    lookWithoutZ:set(cameraLook.x, cameraLook.y, 0)
    lookWithoutZ:normalize()

  if pos then
    self.posX:set(pos.x)
    self.posY:set(pos.y)

    self.posX:set(pos.x)
    self.posY:set(pos.y)
    self.posZ:set(pos.z)

    self.posY:set(pos.y)
    self.posZ:set(pos.z)
  end

        emptyContentPlaceholderElement = message instanceof Node ? message : WI.createMessageTextView(message);
        this._emptyContentPlaceholderElements.set(treeOutline, emptyContentPlaceholderElement);

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

      scopeDepthCache = new Map()
      this.depthCache.set(scopeElement, scopeDepthCache)
    }

      const depth = this._getElementDepth(element, scopeElement)
      scopeDepthCache.set(element, depth)
    }

      }
      this.scopeRegistries.set(scopeElement, scopeRegistry)
    }

    this.cleanupTimers.set(scopeElement, timerId)
  }

            let sizeElement = appendLegendRow.call(this, this._usageLegendElement, type, WI.MemoryTimelineView.displayNameForCategory(type));
            this._usageLegendSizeElementMap.set(type, sizeElement);
        }

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

            });
            this._resourceDataGridNodeMap.set(sourceCodeTimeline, dataGridNode);
        }

    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

  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

    if map.objects[id] then
      vehPos:set(map.objects[id].pos)
    else

      if obj then
        vehPos:set(obj:getPositionXYZ())
      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

    local p1 = divPoints[2]
    posOut:set(p0)
    tmpForward:setSub2(p1, p0)

    tmpForward:normalize()
    forwardOut:set(tmpForward)
    upOut:set(normals[1])

    forwardOut:set(tmpForward)
    upOut:set(normals[1])
    return true

    local pCur = divPoints[numDivPoints]
    posOut:set(pCur)
    tmpForward:setSub2(pCur, pPrev)

    tmpForward:normalize()
    forwardOut:set(tmpForward)
    upOut:set(normals[numDivPoints])

    forwardOut:set(tmpForward)
    upOut:set(normals[numDivPoints])
    return true

  tmpForward:normalize()
  forwardOut:set(tmpForward)

  tmpVec2:normalize()
  upOut:set(tmpVec2)

    forwardRot:setRotationFromTo(vec3(0, 1, 0), tmpForward)
    tmpVec1:set(0, 0, 1)
    tmpVec1:setRotate(forwardRot, tmpVec1)

      -- Determine inner side for this join from the turn direction in XY.
      tmpVec1:set(fPrev.x, fPrev.y, 0)
      tmpVec2:set(tmpForward.x, tmpForward.y, 0)

      tmpVec1:set(fPrev.x, fPrev.y, 0)
      tmpVec2:set(tmpForward.x, tmpForward.y, 0)
      local crossZ = tmpVec1.x * tmpVec2.y - tmpVec1.y * tmpVec2.x

    rectForwardArray[placementIdx] = rectForwardArray[placementIdx] or vec3()
    rectForwardArray[placementIdx]:set(tmpForward)
    rectRightArray[placementIdx] = rectRightArray[placementIdx] or vec3()

    rectRightArray[placementIdx] = rectRightArray[placementIdx] or vec3()
    rectRightArray[placementIdx]:set(tmpRight)
    rectUpArray[placementIdx] = rectUpArray[placementIdx] or vec3()

    rectUpArray[placementIdx] = rectUpArray[placementIdx] or vec3()
    rectUpArray[placementIdx]:set(tmpUp)
    prevForward = prevForward or vec3()

    prevForward = prevForward or vec3()
    prevForward:set(tmpForward)
    prevUp = prevUp or vec3()

    prevUp = prevUp or vec3()
    prevUp:set(tmpUp)

    rotationArray[placementIdx]:set(finalRot)
    meshPathArray[placementIdx] = rectMeshPath

      -- Compute turn angle in XY.
      tmpVec1:set(fPrev.x, fPrev.y, 0)
      tmpVec2:set(fNext.x, fNext.y, 0)

      tmpVec1:set(fPrev.x, fPrev.y, 0)
      tmpVec2:set(fNext.x, fNext.y, 0)
      local dot = tmpVec1.x * tmpVec2.x + tmpVec1.y * tmpVec2.y

          -- Build orthonormal frame: X = baseDir (outer edge), Y = outward, Z = X × Y.
          tmpForward:set(baseVec)
          tmpForward:normalize() -- baseDir

            -- Fallback: use rect right as outward direction.
            tmpVec1:set(rPrev)
          end

          -- In mesh space, the base edge is at +pizzaHalfHeight along local Y; after scaling, that distance is pizzaHalfHeight * scaleY.
          tmpVec1:set(0, 1, 0)                 -- local +Y (tip -> base)
          tmpVec1:setRotate(finalRot, tmpVec1) -- to world space

          rotationArray[placementIdx]:set(finalRot)
          meshPathArray[placementIdx] = pizzaMeshPath

    if (elt != bar) { bar.style.pointerEvents = "none" }
    else { delay.set(1000, maybeDisable) }
  }

  }
  delay.set(1000, maybeDisable)
};

  if (cm.doc.mode.startState && cm.doc.frontier < cm.display.viewTo)
    { cm.state.highlight.set(time, bind(highlightWorker, cm)) }
}

    if (isModifierKey(name)) { return "handled" }
    stopSeq.set(50, function () {
      if (cm.state.keySeq == seq) {

      input.pollSelection()
      input.polling.set(input.cm.options.pollInterval, poll)
    }

  }
  this.polling.set(this.cm.options.pollInterval, poll)
};

  if (this.pollingFast) { return }
  this.polling.set(this.cm.options.pollInterval, function () {
    this$1.poll()

    var changed = input.poll()
    if (!changed && !missed) {missed = true; input.polling.set(60, p)}
    else {input.pollingFast = false; input.slowPoll()}

  }
  input.polling.set(20, p)
};

                    level++;
                levelMap.set(treeElement, level);
            }

    if self.camLastBulletSpeed ~= cam.Speed then
      simTimeAuthority.set(1/cam.Speed)
      self.camLastBulletSpeed = cam.Speed

  elseif self.camLastBulletSpeed then
      simTimeAuthority.set(1)
      self.camLastBulletSpeed = nil

  if self.camLastBulletSpeed then
    simTimeAuthority.set(1)
    self.camLastBulletSpeed = nil

    if not ffbDuringPrevFrame then
      FFBsmooth:set(0)
      curForceLimitSmoother:set(0)

      FFBsmooth:set(0)
      curForceLimitSmoother:set(0)
    end

  if dtReal > 1/10 or dtReal < 0.0001 then -- disable ffb when at less than 10fps, and after pauses. this avoids sudden spikes from accumulated time (e.g. after loading screens, etc)
    FFBsmooth:set(0)
    curForceLimitSmoother:set(0)

    FFBsmooth:set(0)
    curForceLimitSmoother:set(0)
  end

    local verticalAcceleration = sensors.gz2
    totalAcceleration:set(lateralAcceleration, longitudinalAcceleration, verticalAcceleration)

    local jerkForceZ = abs(totalAcceleration.z - prevTotalAccel.z) / timeSinceLastVibrationUpdate
    prevTotalAccel:set(totalAcceleration)
    if jerkForceX < jerkMinX then jerkForceX = 0 end

    smoothVelocity:set(obj:getSmoothRefVelocityXYZ())

      M.wheelFFBForceCoefCurrent = 0 -- free up the wheel while AI is driving
      FFBsmooth:set(0)
      curForceLimitSmoother:set(0)

      FFBsmooth:set(0)
      curForceLimitSmoother:set(0)
    end

    FFBHydrosExist = true
    FFBsmooth:set(0)
    curForceLimitSmoother:set(0)

    FFBsmooth:set(0)
    curForceLimitSmoother:set(0)
    log("D", "hydros.init", "Response to FFB config request: "..dumps(newFFBConfig))

  FFBsmooth:set(0)
  curForceLimitSmoother:set(0)

  FFBsmooth:set(0)
  curForceLimitSmoother:set(0)

local function onUpdate(dtReal, dtSim, dtRaw)
  pos:set(gameplay_drift_drift.getVehPos() or vec3(0,0,0))

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

    observers.set(this, observer);
};

    elemBlurs.set(el, { blurUpdateWrapper, processBlurVal, observe, unobserve })

          var copied = new ArrayBuffer(source.byteLength);
          new Uint8Array(copied).set(new Uint8Array(source));
          return copied;

 * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
 * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
 * segments:

 *   // change the attribute
 *   attrs.$set('ngModel', 'new value');
 *

          }
          dst.$set(key, value, true, srcAttr[key]);
        }

                    } else {
                      attr.$set(name, newValue);
                    }

    scope.$watch(attr[normalized], function ngBooleanAttrWatchAction(value) {
      attr.$set(attrName, !!value);
    });

          if (match) {
            attr.$set("ngPattern", new RegExp(match[1], match[2]));
            return;

        scope.$watch(attr[ngAttr], function ngAttrAliasWatchAction(value) {
          attr.$set(ngAttr, value);
        });

            if (attrName === 'href') {
              attr.$set(name, null);
            }

          attr.$set(name, value);

        return function ngValueConstantLink(scope, elm, attr) {
          attr.$set('value', scope.$eval(attr.ngValue));
        };

          scope.$watch(attr.ngValue, function valueWatchAction(value) {
            attr.$set('value', value);
          });

  compile: function(element, attr) {
    attr.$set('ngCloak', undefined);
    element.removeClass('ng-cloak');

        unset(ctrl.$error, validationErrorKey, controller);
        set(ctrl.$$success, validationErrorKey, controller);
      } else {

      } else {
        set(ctrl.$error, validationErrorKey, controller);
        unset(ctrl.$$success, validationErrorKey, controller);

    }
    set(ctrl[name], value, controller);
  }

      optionScope.$watch(interpolateTextFn, function interpolateWatchAction(newVal, oldVal) {
        optionAttrs.$set('value', newVal);
        if (oldVal !== newVal) {

        if (!interpolateTextFn) {
          attr.$set('value', element.text());
        }

  end
  tmp1:set(xMin, yMin, 0)
  tmp2:set(xMax, yMax, 0)

  tmp1:set(xMin, yMin, 0)
  tmp2:set(xMax, yMax, 0)
  tb:updateGrid(tmp1, tmp2)

  end
  tmp1:set(xMin, yMin, 0)
  tmp2:set(xMax, yMax, 0)

  tmp1:set(xMin, yMin, 0)
  tmp2:set(xMax, yMax, 0)
  tb:updateGrid(tmp1, tmp2)

  -- Update the terrain block.
  tmp1:set(bXMin, bYMin, 0)
  tmp2:set(bXMax, bYMax, 0)

  tmp1:set(bXMin, bYMin, 0)
  tmp2:set(bXMax, bYMax, 0)
  tb:updateGrid(tmp1, tmp2)

  -- Get the grid bounds of the union of sources.
  tmp1:set(floor(max(tXMin, box.xMin)), floor(max(tYMin, box.yMin)), 0)
  tmp2:set(ceil(min(tXMax, box.xMax)), ceil(min(tYMax, box.yMax)), 0)

  tmp1:set(floor(max(tXMin, box.xMin)), floor(max(tYMin, box.yMin)), 0)
  tmp2:set(ceil(min(tXMax, box.xMax)), ceil(min(tYMax, box.yMax)), 0)
  te:worldToGridByPoint2I(tmp1, gMin, tb)

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

      local p1, p2 = nodes[i - 1].p, nodes[i].p
      tmp1:set(p1.x, p1.y, 0.0)                                                                     -- Project the point to the XY-plane (ie 3D -> 2D).
      tmp2:set(p2.x, p2.y, 0.0)

      tmp1:set(p1.x, p1.y, 0.0)                                                                     -- Project the point to the XY-plane (ie 3D -> 2D).
      tmp2:set(p2.x, p2.y, 0.0)
      local dSq = mousePos:squaredDistanceToLineSegment(tmp1, tmp2)

local function updateCameraPose()
  gView:set(0.0, 30.0, auditionHeight + 15.0)
  local gRot = quatFromDir(auditionVec - gView)

  local x, y, s, c = gView.x, gView.y, sin(ang), cos(ang)
  auditionCamPos:set(x * c - y * s, x * s + y * c, gView.z)
  local gRot = quatFromDir(auditionVec - auditionCamPos)

        local p = catmullRom(pp1, pp2, pp3, pp4, 0.5)
        tmp0:set(pp1.x, pp1.y, widths[max(1, i - 2)])
        tmp1:set(pp1.x, pp1.y, widths[i - 1])

        tmp0:set(pp1.x, pp1.y, widths[max(1, i - 2)])
        tmp1:set(pp1.x, pp1.y, widths[i - 1])
        tmp2:set(pp1.x, pp1.y, widths[i])

        tmp1:set(pp1.x, pp1.y, widths[i - 1])
        tmp2:set(pp1.x, pp1.y, widths[i])
        tmp3:set(pp1.x, pp1.y, widths[min(#nodes, i + 1)])

        tmp2:set(pp1.x, pp1.y, widths[i])
        tmp3:set(pp1.x, pp1.y, widths[min(#nodes, i + 1)])
        local w = catmullRom(tmp0, tmp1, tmp2, tmp3, 0.5).z

    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

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

  fwd:set((b - a):normalized())
  for i = 0, self.pinIn.amount.value or defaultAmount do

    data.texture = self.pinIn.decalPath.value or defaultDecalPath
    data.scale:set(unpack(self.pinIn.decalScale.value or defaultDecalScale))

  local tYMin, tYMax = centerY - yHalf, centerY + yHalf
  tmp1:set(tXMin, tYMin, 0)
  tmp2:set(tXMax, tYMax, 0)

  tmp1:set(tXMin, tYMin, 0)
  tmp2:set(tXMax, tYMax, 0)
  te:worldToGridByPoint2I(tmp1, gMin, tb)

    ballAV = 0
    ballAVSmoother:set(0)
  else

    -- 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

        this._insertOtherExecutionContextPathComponent(executionContextPathComponent);
        this._frameToPathComponent.set(frame, executionContextPathComponent);
        return executionContextPathComponent;

        this._targetToPathComponent.set(target, executionContextPathComponent);
        this._insertOtherExecutionContextPathComponent(executionContextPathComponent);

      camPos:set(core_camera.getPositionXYZ())
      cameraForward:set(core_camera.getForwardXYZ())

      camPos:set(core_camera.getPositionXYZ())
      cameraForward:set(core_camera.getForwardXYZ())

      lastCameraForward = lastCameraForward or vec3()
      lastCamPos:set(camPos)
      lastCameraForward:set(cameraForward)

      lastCamPos:set(camPos)
      lastCameraForward:set(cameraForward)

        if veh then
          vehVelocity:set(veh:getVelocityXYZ())
          globalParams:setParameterValue("g_VehicleSpeedPlayerMS", vehVelocity:length())

  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))

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

        for (let type in WI.ScopeChainNode.Type)
            sectionCountByType.set(WI.ScopeChainNode.Type[type], 0);

            let count = sectionCountByType.get(scope.type);
            sectionCountByType.set(scope.type, ++count);

          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) {

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

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

  local x, y = p1.x, p1.y
  p1:set(x * c - y * s, x * s + y * c, 0.0)
  local p2 = vec3(0, boxYHalf + bevel - 0.2 + innerShift, 0)

  local x, y = p2.x, p2.y
  p2:set(x * c - y * s, x * s + y * c, 0.0)

      local x, y = p.x, p.y
      n.p:set(x * c - y * s + cen.x, x * s + y * c + cen.y, zOld)
    end

    if (!elementLabels.has(element)) {
      elementLabels.set(element, {})
    }

    wCenter:set(0,0,0)
    local wCount = veh:getWheelCount() - 1

        local axisNodes = veh:getWheelAxisNodes(i)
        wPos:set(veh:getNodePosition(axisNodes[1]))
        wCenter:setAdd(wPos)

  local resetMetadata = true
  startEndPosTable.pos:set(pos)
  -- gcprobe()

        let pathComponent = new WI.HierarchicalPathComponent(displayName, iconClassName, collection);
        this._pathComponentsMap.set(collection, pathComponent);

                for (let domEvent of domEvents)
                    entry.domEventElements.set(domEvent, eventElement);
            }

            this._detailViewMap.set(object, this._detailView);
        }

            nodeEntry = this._entryForDOMNode(resource.initiatorNode, Object.keys(resourceEntry));
            this._domNodeEntries.set(resource.initiatorNode, nodeEntry);

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())

  local midX, midY = (xMin + xMax) * 0.5, (yMin + yMax) * 0.5
  tmp1:set(midX, midY, 0.0)
  tmp2:set(xMax, yMax, 0.0)

  tmp1:set(midX, midY, 0.0)
  tmp2:set(xMax, yMax, 0.0)

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)

    end
    lastPos:set(pos)

local function set(val)
  setTargetSpeed(val)

  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)

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

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

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

        let recordingTreeElement = new WI.GeneralTreeElement(WI.TimelineTabContentView.StopwatchIconStyleClass, recording.displayName, null, recording);
        this._recordingTreeElementMap.set(recording, recordingTreeElement);
        this._recordingsTreeOutline.appendChild(recordingTreeElement);

  guiData.realtimeCreep = 0
  creepSmoother:set(0)

  creepSmoother:set(0)
  clearRt()

  creepSmoother:set(0)
  clearRt()

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

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

          this.uiAppsCache.set(normalizedSource, {
            name,

      const uiApp = uiApps[i]
      this.coordinator.listenerUIApps.set(retroId, uiApp)
    }

    for (const app of stats.uiApps) {
      combinedApps.set(app.name, {
        name: app.name,

      if (!combinedApps.has(uiApp.name)) {
        combinedApps.set(uiApp.name, {
          name: uiApp.name,

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

    enable = !!enable;
    bngApi.engineLua(`extensions.ui_visibility.set(${enable})`, () => {
      function next() {

    // //$scope.$emit callback system not working, so moved the UI hide before cursor hide in TS
    // bngApi.engineLua("extensions.ui_visibility.set(false)")
    // //Waiting to make sure hide has executed

    //       bngApi.engineLua('screenshot.doSteamScreenshot()', () => {
    //         bngApi.engineLua("extensions.ui_visibility.set(true)")
    //         vm.showControls = true

    // Make UI visible
    bngApi.engineLua("ui_visibility.set(true)")

  // turn a space-separated list into an array
  function set(str) {
    var obj = {}, words = str.split(" ");

    name: "sql",
    keywords: set(sqlKeywords + "begin"),
    builtin: set("bool boolean bit blob enum long longblob longtext medium mediumblob mediumint mediumtext time timestamp tinyblob tinyint tinytext text bigint int int1 int2 int3 int4 int8 integer float float4 float8 double char varbinary varchar varcharacter precision real date datetime year unsigned signed decimal numeric"),

    keywords: set(sqlKeywords + "begin"),
    builtin: set("bool boolean bit blob enum long longblob longtext medium mediumblob mediumint mediumtext time timestamp tinyblob tinyint tinytext text bigint int int1 int2 int3 int4 int8 integer float float4 float8 double char varbinary varchar varcharacter precision real date datetime year unsigned signed decimal numeric"),
    atoms: set("false true null unknown"),

    builtin: set("bool boolean bit blob enum long longblob longtext medium mediumblob mediumint mediumtext time timestamp tinyblob tinyint tinytext text bigint int int1 int2 int3 int4 int8 integer float float4 float8 double char varbinary varchar varcharacter precision real date datetime year unsigned signed decimal numeric"),
    atoms: set("false true null unknown"),
    operatorChars: /^[*+\-%<>!=]/,

    operatorChars: /^[*+\-%<>!=]/,
    dateSQL: set("date time timestamp"),
    support: set("ODBCdotTable doubleQuote binaryNumber hexNumber")

    dateSQL: set("date time timestamp"),
    support: set("ODBCdotTable doubleQuote binaryNumber hexNumber")
  });

    name: "sql",
    client: set("charset clear connect edit ego exit go help nopager notee nowarning pager print prompt quit rehash source status system tee"),
    keywords: set(sqlKeywords + "begin trigger proc view index for add constraint key primary foreign collate clustered nonclustered declare exec"),

    client: set("charset clear connect edit ego exit go help nopager notee nowarning pager print prompt quit rehash source status system tee"),
    keywords: set(sqlKeywords + "begin trigger proc view index for add constraint key primary foreign collate clustered nonclustered declare exec"),
    builtin: set("bigint numeric bit smallint decimal smallmoney int tinyint money float real char varchar text nchar nvarchar ntext binary varbinary image cursor timestamp hierarchyid uniqueidentifier sql_variant xml table "),

    keywords: set(sqlKeywords + "begin trigger proc view index for add constraint key primary foreign collate clustered nonclustered declare exec"),
    builtin: set("bigint numeric bit smallint decimal smallmoney int tinyint money float real char varchar text nchar nvarchar ntext binary varbinary image cursor timestamp hierarchyid uniqueidentifier sql_variant xml table "),
    atoms: set("false true null unknown"),

    builtin: set("bigint numeric bit smallint decimal smallmoney int tinyint money float real char varchar text nchar nvarchar ntext binary varbinary image cursor timestamp hierarchyid uniqueidentifier sql_variant xml table "),
    atoms: set("false true null unknown"),
    operatorChars: /^[*+\-%<>!=]/,

    operatorChars: /^[*+\-%<>!=]/,
    dateSQL: set("date datetimeoffset datetime2 smalldatetime datetime time"),
    hooks: {

    name: "sql",
    client: set("charset clear connect edit ego exit go help nopager notee nowarning pager print prompt quit rehash source status system tee"),
    keywords: set(sqlKeywords + "accessible action add after algorithm all analyze asensitive at authors auto_increment autocommit avg avg_row_length before binary binlog both btree cache call cascade cascaded case catalog_name chain change changed character check checkpoint checksum class_origin client_statistics close coalesce code collate collation collations column columns comment commit committed completion concurrent condition connection consistent constraint contains continue contributors convert cross current current_date current_time current_timestamp current_user cursor data database databases day_hour day_microsecond day_minute day_second deallocate dec declare default delay_key_write delayed delimiter des_key_file describe deterministic dev_pop dev_samp deviance diagnostics directory disable discard distinctrow div dual dumpfile each elseif enable enclosed end ends engine engines enum errors escape escaped even event events every execute exists exit explain extended fast fetch field fields first flush for force foreign found_rows full fulltext function general get global grant grants group group_concat handler hash help high_priority hosts hour_microsecond hour_minute hour_second if ignore ignore_server_ids import index index_statistics infile inner innodb inout insensitive insert_method install interval invoker isolation iterate key keys kill language last leading leave left level limit linear lines list load local localtime localtimestamp lock logs low_priority master master_heartbeat_period master_ssl_verify_server_cert masters match max max_rows maxvalue message_text middleint migrate min min_rows minute_microsecond minute_second mod mode modifies modify mutex mysql_errno natural next no no_write_to_binlog offline offset one online open optimize option optionally out outer outfile pack_keys parser partition partitions password phase plugin plugins prepare preserve prev primary privileges procedure processlist profile profiles purge query quick range read read_write reads real rebuild recover references regexp relaylog release remove rename reorganize repair repeatable replace require resignal restrict resume return returns revoke right rlike rollback rollup row row_format rtree savepoint schedule schema schema_name schemas second_microsecond security sensitive separator serializable server session share show signal slave slow smallint snapshot soname spatial specific sql sql_big_result sql_buffer_result sql_cache sql_calc_found_rows sql_no_cache sql_small_result sqlexception sqlstate sqlwarning ssl start starting starts status std stddev stddev_pop stddev_samp storage straight_join subclass_origin sum suspend table_name table_statistics tables tablespace temporary terminated to trailing transaction trigger triggers truncate uncommitted undo uninstall unique unlock upgrade usage use use_frm user user_resources user_statistics using utc_date utc_time utc_timestamp value variables varying view views warnings when while with work write xa xor year_month zerofill begin do then else loop repeat"),

    client: set("charset clear connect edit ego exit go help nopager notee nowarning pager print prompt quit rehash source status system tee"),
    keywords: set(sqlKeywords + "accessible action add after algorithm all analyze asensitive at authors auto_increment autocommit avg avg_row_length before binary binlog both btree cache call cascade cascaded case catalog_name chain change changed character check checkpoint checksum class_origin client_statistics close coalesce code collate collation collations column columns comment commit committed completion concurrent condition connection consistent constraint contains continue contributors convert cross current current_date current_time current_timestamp current_user cursor data database databases day_hour day_microsecond day_minute day_second deallocate dec declare default delay_key_write delayed delimiter des_key_file describe deterministic dev_pop dev_samp deviance diagnostics directory disable discard distinctrow div dual dumpfile each elseif enable enclosed end ends engine engines enum errors escape escaped even event events every execute exists exit explain extended fast fetch field fields first flush for force foreign found_rows full fulltext function general get global grant grants group group_concat handler hash help high_priority hosts hour_microsecond hour_minute hour_second if ignore ignore_server_ids import index index_statistics infile inner innodb inout insensitive insert_method install interval invoker isolation iterate key keys kill language last leading leave left level limit linear lines list load local localtime localtimestamp lock logs low_priority master master_heartbeat_period master_ssl_verify_server_cert masters match max max_rows maxvalue message_text middleint migrate min min_rows minute_microsecond minute_second mod mode modifies modify mutex mysql_errno natural next no no_write_to_binlog offline offset one online open optimize option optionally out outer outfile pack_keys parser partition partitions password phase plugin plugins prepare preserve prev primary privileges procedure processlist profile profiles purge query quick range read read_write reads real rebuild recover references regexp relaylog release remove rename reorganize repair repeatable replace require resignal restrict resume return returns revoke right rlike rollback rollup row row_format rtree savepoint schedule schema schema_name schemas second_microsecond security sensitive separator serializable server session share show signal slave slow smallint snapshot soname spatial specific sql sql_big_result sql_buffer_result sql_cache sql_calc_found_rows sql_no_cache sql_small_result sqlexception sqlstate sqlwarning ssl start starting starts status std stddev stddev_pop stddev_samp storage straight_join subclass_origin sum suspend table_name table_statistics tables tablespace temporary terminated to trailing transaction trigger triggers truncate uncommitted undo uninstall unique unlock upgrade usage use use_frm user user_resources user_statistics using utc_date utc_time utc_timestamp value variables varying view views warnings when while with work write xa xor year_month zerofill begin do then else loop repeat"),
    builtin: set("bool boolean bit blob decimal double float long longblob longtext medium mediumblob mediumint mediumtext time timestamp tinyblob tinyint tinytext text bigint int int1 int2 int3 int4 int8 integer float float4 float8 double char varbinary varchar varcharacter precision date datetime year unsigned signed numeric"),

    keywords: set(sqlKeywords + "accessible action add after algorithm all analyze asensitive at authors auto_increment autocommit avg avg_row_length before binary binlog both btree cache call cascade cascaded case catalog_name chain change changed character check checkpoint checksum class_origin client_statistics close coalesce code collate collation collations column columns comment commit committed completion concurrent condition connection consistent constraint contains continue contributors convert cross current current_date current_time current_timestamp current_user cursor data database databases day_hour day_microsecond day_minute day_second deallocate dec declare default delay_key_write delayed delimiter des_key_file describe deterministic dev_pop dev_samp deviance diagnostics directory disable discard distinctrow div dual dumpfile each elseif enable enclosed end ends engine engines enum errors escape escaped even event events every execute exists exit explain extended fast fetch field fields first flush for force foreign found_rows full fulltext function general get global grant grants group group_concat handler hash help high_priority hosts hour_microsecond hour_minute hour_second if ignore ignore_server_ids import index index_statistics infile inner innodb inout insensitive insert_method install interval invoker isolation iterate key keys kill language last leading leave left level limit linear lines list load local localtime localtimestamp lock logs low_priority master master_heartbeat_period master_ssl_verify_server_cert masters match max max_rows maxvalue message_text middleint migrate min min_rows minute_microsecond minute_second mod mode modifies modify mutex mysql_errno natural next no no_write_to_binlog offline offset one online open optimize option optionally out outer outfile pack_keys parser partition partitions password phase plugin plugins prepare preserve prev primary privileges procedure processlist profile profiles purge query quick range read read_write reads real rebuild recover references regexp relaylog release remove rename reorganize repair repeatable replace require resignal restrict resume return returns revoke right rlike rollback rollup row row_format rtree savepoint schedule schema schema_name schemas second_microsecond security sensitive separator serializable server session share show signal slave slow smallint snapshot soname spatial specific sql sql_big_result sql_buffer_result sql_cache sql_calc_found_rows sql_no_cache sql_small_result sqlexception sqlstate sqlwarning ssl start starting starts status std stddev stddev_pop stddev_samp storage straight_join subclass_origin sum suspend table_name table_statistics tables tablespace temporary terminated to trailing transaction trigger triggers truncate uncommitted undo uninstall unique unlock upgrade usage use use_frm user user_resources user_statistics using utc_date utc_time utc_timestamp value variables varying view views warnings when while with work write xa xor year_month zerofill begin do then else loop repeat"),
    builtin: set("bool boolean bit blob decimal double float long longblob longtext medium mediumblob mediumint mediumtext time timestamp tinyblob tinyint tinytext text bigint int int1 int2 int3 int4 int8 integer float float4 float8 double char varbinary varchar varcharacter precision date datetime year unsigned signed numeric"),
    atoms: set("false true null unknown"),

    builtin: set("bool boolean bit blob decimal double float long longblob longtext medium mediumblob mediumint mediumtext time timestamp tinyblob tinyint tinytext text bigint int int1 int2 int3 int4 int8 integer float float4 float8 double char varbinary varchar varcharacter precision date datetime year unsigned signed numeric"),
    atoms: set("false true null unknown"),
    operatorChars: /^[*+\-%<>!=&|^]/,

    operatorChars: /^[*+\-%<>!=&|^]/,
    dateSQL: set("date time timestamp"),
    support: set("ODBCdotTable decimallessFloat zerolessFloat binaryNumber hexNumber doubleQuote nCharCast charsetCast commentHash commentSpaceRequired"),

    dateSQL: set("date time timestamp"),
    support: set("ODBCdotTable decimallessFloat zerolessFloat binaryNumber hexNumber doubleQuote nCharCast charsetCast commentHash commentSpaceRequired"),
    hooks: {

    name: "sql",
    client: set("charset clear connect edit ego exit go help nopager notee nowarning pager print prompt quit rehash source status system tee"),
    keywords: set(sqlKeywords + "accessible action add after algorithm all always analyze asensitive at authors auto_increment autocommit avg avg_row_length before binary binlog both btree cache call cascade cascaded case catalog_name chain change changed character check checkpoint checksum class_origin client_statistics close coalesce code collate collation collations column columns comment commit committed completion concurrent condition connection consistent constraint contains continue contributors convert cross current current_date current_time current_timestamp current_user cursor data database databases day_hour day_microsecond day_minute day_second deallocate dec declare default delay_key_write delayed delimiter des_key_file describe deterministic dev_pop dev_samp deviance diagnostics directory disable discard distinctrow div dual dumpfile each elseif enable enclosed end ends engine engines enum errors escape escaped even event events every execute exists exit explain extended fast fetch field fields first flush for force foreign found_rows full fulltext function general generated get global grant grants group groupby_concat handler hard hash help high_priority hosts hour_microsecond hour_minute hour_second if ignore ignore_server_ids import index index_statistics infile inner innodb inout insensitive insert_method install interval invoker isolation iterate key keys kill language last leading leave left level limit linear lines list load local localtime localtimestamp lock logs low_priority master master_heartbeat_period master_ssl_verify_server_cert masters match max max_rows maxvalue message_text middleint migrate min min_rows minute_microsecond minute_second mod mode modifies modify mutex mysql_errno natural next no no_write_to_binlog offline offset one online open optimize option optionally out outer outfile pack_keys parser partition partitions password persistent phase plugin plugins prepare preserve prev primary privileges procedure processlist profile profiles purge query quick range read read_write reads real rebuild recover references regexp relaylog release remove rename reorganize repair repeatable replace require resignal restrict resume return returns revoke right rlike rollback rollup row row_format rtree savepoint schedule schema schema_name schemas second_microsecond security sensitive separator serializable server session share show shutdown signal slave slow smallint snapshot soft soname spatial specific sql sql_big_result sql_buffer_result sql_cache sql_calc_found_rows sql_no_cache sql_small_result sqlexception sqlstate sqlwarning ssl start starting starts status std stddev stddev_pop stddev_samp storage straight_join subclass_origin sum suspend table_name table_statistics tables tablespace temporary terminated to trailing transaction trigger triggers truncate uncommitted undo uninstall unique unlock upgrade usage use use_frm user user_resources user_statistics using utc_date utc_time utc_timestamp value variables varying view views virtual warnings when while with work write xa xor year_month zerofill begin do then else loop repeat"),

    client: set("charset clear connect edit ego exit go help nopager notee nowarning pager print prompt quit rehash source status system tee"),
    keywords: set(sqlKeywords + "accessible action add after algorithm all always analyze asensitive at authors auto_increment autocommit avg avg_row_length before binary binlog both btree cache call cascade cascaded case catalog_name chain change changed character check checkpoint checksum class_origin client_statistics close coalesce code collate collation collations column columns comment commit committed completion concurrent condition connection consistent constraint contains continue contributors convert cross current current_date current_time current_timestamp current_user cursor data database databases day_hour day_microsecond day_minute day_second deallocate dec declare default delay_key_write delayed delimiter des_key_file describe deterministic dev_pop dev_samp deviance diagnostics directory disable discard distinctrow div dual dumpfile each elseif enable enclosed end ends engine engines enum errors escape escaped even event events every execute exists exit explain extended fast fetch field fields first flush for force foreign found_rows full fulltext function general generated get global grant grants group groupby_concat handler hard hash help high_priority hosts hour_microsecond hour_minute hour_second if ignore ignore_server_ids import index index_statistics infile inner innodb inout insensitive insert_method install interval invoker isolation iterate key keys kill language last leading leave left level limit linear lines list load local localtime localtimestamp lock logs low_priority master master_heartbeat_period master_ssl_verify_server_cert masters match max max_rows maxvalue message_text middleint migrate min min_rows minute_microsecond minute_second mod mode modifies modify mutex mysql_errno natural next no no_write_to_binlog offline offset one online open optimize option optionally out outer outfile pack_keys parser partition partitions password persistent phase plugin plugins prepare preserve prev primary privileges procedure processlist profile profiles purge query quick range read read_write reads real rebuild recover references regexp relaylog release remove rename reorganize repair repeatable replace require resignal restrict resume return returns revoke right rlike rollback rollup row row_format rtree savepoint schedule schema schema_name schemas second_microsecond security sensitive separator serializable server session share show shutdown signal slave slow smallint snapshot soft soname spatial specific sql sql_big_result sql_buffer_result sql_cache sql_calc_found_rows sql_no_cache sql_small_result sqlexception sqlstate sqlwarning ssl start starting starts status std stddev stddev_pop stddev_samp storage straight_join subclass_origin sum suspend table_name table_statistics tables tablespace temporary terminated to trailing transaction trigger triggers truncate uncommitted undo uninstall unique unlock upgrade usage use use_frm user user_resources user_statistics using utc_date utc_time utc_timestamp value variables varying view views virtual warnings when while with work write xa xor year_month zerofill begin do then else loop repeat"),
    builtin: set("bool boolean bit blob decimal double float long longblob longtext medium mediumblob mediumint mediumtext time timestamp tinyblob tinyint tinytext text bigint int int1 int2 int3 int4 int8 integer float float4 float8 double char varbinary varchar varcharacter precision date datetime year unsigned signed numeric"),

    keywords: set(sqlKeywords + "accessible action add after algorithm all always analyze asensitive at authors auto_increment autocommit avg avg_row_length before binary binlog both btree cache call cascade cascaded case catalog_name chain change changed character check checkpoint checksum class_origin client_statistics close coalesce code collate collation collations column columns comment commit committed completion concurrent condition connection consistent constraint contains continue contributors convert cross current current_date current_time current_timestamp current_user cursor data database databases day_hour day_microsecond day_minute day_second deallocate dec declare default delay_key_write delayed delimiter des_key_file describe deterministic dev_pop dev_samp deviance diagnostics directory disable discard distinctrow div dual dumpfile each elseif enable enclosed end ends engine engines enum errors escape escaped even event events every execute exists exit explain extended fast fetch field fields first flush for force foreign found_rows full fulltext function general generated get global grant grants group groupby_concat handler hard hash help high_priority hosts hour_microsecond hour_minute hour_second if ignore ignore_server_ids import index index_statistics infile inner innodb inout insensitive insert_method install interval invoker isolation iterate key keys kill language last leading leave left level limit linear lines list load local localtime localtimestamp lock logs low_priority master master_heartbeat_period master_ssl_verify_server_cert masters match max max_rows maxvalue message_text middleint migrate min min_rows minute_microsecond minute_second mod mode modifies modify mutex mysql_errno natural next no no_write_to_binlog offline offset one online open optimize option optionally out outer outfile pack_keys parser partition partitions password persistent phase plugin plugins prepare preserve prev primary privileges procedure processlist profile profiles purge query quick range read read_write reads real rebuild recover references regexp relaylog release remove rename reorganize repair repeatable replace require resignal restrict resume return returns revoke right rlike rollback rollup row row_format rtree savepoint schedule schema schema_name schemas second_microsecond security sensitive separator serializable server session share show shutdown signal slave slow smallint snapshot soft soname spatial specific sql sql_big_result sql_buffer_result sql_cache sql_calc_found_rows sql_no_cache sql_small_result sqlexception sqlstate sqlwarning ssl start starting starts status std stddev stddev_pop stddev_samp storage straight_join subclass_origin sum suspend table_name table_statistics tables tablespace temporary terminated to trailing transaction trigger triggers truncate uncommitted undo uninstall unique unlock upgrade usage use use_frm user user_resources user_statistics using utc_date utc_time utc_timestamp value variables varying view views virtual warnings when while with work write xa xor year_month zerofill begin do then else loop repeat"),
    builtin: set("bool boolean bit blob decimal double float long longblob longtext medium mediumblob mediumint mediumtext time timestamp tinyblob tinyint tinytext text bigint int int1 int2 int3 int4 int8 integer float float4 float8 double char varbinary varchar varcharacter precision date datetime year unsigned signed numeric"),
    atoms: set("false true null unknown"),

    builtin: set("bool boolean bit blob decimal double float long longblob longtext medium mediumblob mediumint mediumtext time timestamp tinyblob tinyint tinytext text bigint int int1 int2 int3 int4 int8 integer float float4 float8 double char varbinary varchar varcharacter precision date datetime year unsigned signed numeric"),
    atoms: set("false true null unknown"),
    operatorChars: /^[*+\-%<>!=&|^]/,

    operatorChars: /^[*+\-%<>!=&|^]/,
    dateSQL: set("date time timestamp"),
    support: set("ODBCdotTable decimallessFloat zerolessFloat binaryNumber hexNumber doubleQuote nCharCast charsetCast commentHash commentSpaceRequired"),

    dateSQL: set("date time timestamp"),
    support: set("ODBCdotTable decimallessFloat zerolessFloat binaryNumber hexNumber doubleQuote nCharCast charsetCast commentHash commentSpaceRequired"),
    hooks: {

    client: { },
    keywords: set("add all allow alter and any apply as asc authorize batch begin by clustering columnfamily compact consistency count create custom delete desc distinct drop each_quorum exists filtering from grant if in index insert into key keyspace keyspaces level limit local_one local_quorum modify nan norecursive nosuperuser not of on one order password permission permissions primary quorum rename revoke schema select set storage superuser table three to token truncate ttl two type unlogged update use user users using values where with writetime"),
    builtin: set("ascii bigint blob boolean counter decimal double float frozen inet int list map static text timestamp timeuuid tuple uuid varchar varint"),

    keywords: set("add all allow alter and any apply as asc authorize batch begin by clustering columnfamily compact consistency count create custom delete desc distinct drop each_quorum exists filtering from grant if in index insert into key keyspace keyspaces level limit local_one local_quorum modify nan norecursive nosuperuser not of on one order password permission permissions primary quorum rename revoke schema select set storage superuser table three to token truncate ttl two type unlogged update use user users using values where with writetime"),
    builtin: set("ascii bigint blob boolean counter decimal double float frozen inet int list map static text timestamp timeuuid tuple uuid varchar varint"),
    atoms: set("false true infinity NaN"),

    builtin: set("ascii bigint blob boolean counter decimal double float frozen inet int list map static text timestamp timeuuid tuple uuid varchar varint"),
    atoms: set("false true infinity NaN"),
    operatorChars: /^[<>=]/,

    dateSQL: { },
    support: set("commentSlashSlash decimallessFloat"),
    hooks: { }

    name:       "sql",
    client:     set("appinfo arraysize autocommit autoprint autorecovery autotrace blockterminator break btitle cmdsep colsep compatibility compute concat copycommit copytypecheck define describe echo editfile embedded escape exec execute feedback flagger flush heading headsep instance linesize lno loboffset logsource long longchunksize markup native newpage numformat numwidth pagesize pause pno recsep recsepchar release repfooter repheader serveroutput shiftinout show showmode size spool sqlblanklines sqlcase sqlcode sqlcontinue sqlnumber sqlpluscompatibility sqlprefix sqlprompt sqlterminator suffix tab term termout time timing trimout trimspool ttitle underline verify version wrap"),
    keywords:   set("abort accept access add all alter and any array arraylen as asc assert assign at attributes audit authorization avg base_table begin between binary_integer body boolean by case cast char char_base check close cluster clusters colauth column comment commit compress connect connected constant constraint crash create current currval cursor data_base database date dba deallocate debugoff debugon decimal declare default definition delay delete desc digits dispose distinct do drop else elseif elsif enable end entry escape exception exception_init exchange exclusive exists exit external fast fetch file for force form from function generic goto grant group having identified if immediate in increment index indexes indicator initial initrans insert interface intersect into is key level library like limited local lock log logging long loop master maxextents maxtrans member minextents minus mislabel mode modify multiset new next no noaudit nocompress nologging noparallel not nowait number_base object of off offline on online only open option or order out package parallel partition pctfree pctincrease pctused pls_integer positive positiven pragma primary prior private privileges procedure public raise range raw read rebuild record ref references refresh release rename replace resource restrict return returning returns reverse revoke rollback row rowid rowlabel rownum rows run savepoint schema segment select separate session set share snapshot some space split sql start statement storage subtype successful synonym tabauth table tables tablespace task terminate then to trigger truncate type union unique unlimited unrecoverable unusable update use using validate value values variable view views when whenever where while with work"),

    client:     set("appinfo arraysize autocommit autoprint autorecovery autotrace blockterminator break btitle cmdsep colsep compatibility compute concat copycommit copytypecheck define describe echo editfile embedded escape exec execute feedback flagger flush heading headsep instance linesize lno loboffset logsource long longchunksize markup native newpage numformat numwidth pagesize pause pno recsep recsepchar release repfooter repheader serveroutput shiftinout show showmode size spool sqlblanklines sqlcase sqlcode sqlcontinue sqlnumber sqlpluscompatibility sqlprefix sqlprompt sqlterminator suffix tab term termout time timing trimout trimspool ttitle underline verify version wrap"),
    keywords:   set("abort accept access add all alter and any array arraylen as asc assert assign at attributes audit authorization avg base_table begin between binary_integer body boolean by case cast char char_base check close cluster clusters colauth column comment commit compress connect connected constant constraint crash create current currval cursor data_base database date dba deallocate debugoff debugon decimal declare default definition delay delete desc digits dispose distinct do drop else elseif elsif enable end entry escape exception exception_init exchange exclusive exists exit external fast fetch file for force form from function generic goto grant group having identified if immediate in increment index indexes indicator initial initrans insert interface intersect into is key level library like limited local lock log logging long loop master maxextents maxtrans member minextents minus mislabel mode modify multiset new next no noaudit nocompress nologging noparallel not nowait number_base object of off offline on online only open option or order out package parallel partition pctfree pctincrease pctused pls_integer positive positiven pragma primary prior private privileges procedure public raise range raw read rebuild record ref references refresh release rename replace resource restrict return returning returns reverse revoke rollback row rowid rowlabel rownum rows run savepoint schema segment select separate session set share snapshot some space split sql start statement storage subtype successful synonym tabauth table tables tablespace task terminate then to trigger truncate type union unique unlimited unrecoverable unusable update use using validate value values variable view views when whenever where while with work"),
    builtin:    set("abs acos add_months ascii asin atan atan2 average bfile bfilename bigserial bit blob ceil character chartorowid chr clob concat convert cos cosh count dec decode deref dual dump dup_val_on_index empty error exp false float floor found glb greatest hextoraw initcap instr instrb int integer isopen last_day least length lengthb ln lower lpad ltrim lub make_ref max min mlslabel mod months_between natural naturaln nchar nclob new_time next_day nextval nls_charset_decl_len nls_charset_id nls_charset_name nls_initcap nls_lower nls_sort nls_upper nlssort no_data_found notfound null number numeric nvarchar2 nvl others power rawtohex real reftohex round rowcount rowidtochar rowtype rpad rtrim serial sign signtype sin sinh smallint soundex sqlcode sqlerrm sqrt stddev string substr substrb sum sysdate tan tanh to_char text to_date to_label to_multi_byte to_number to_single_byte translate true trunc uid unlogged upper user userenv varchar varchar2 variance varying vsize xml"),

    keywords:   set("abort accept access add all alter and any array arraylen as asc assert assign at attributes audit authorization avg base_table begin between binary_integer body boolean by case cast char char_base check close cluster clusters colauth column comment commit compress connect connected constant constraint crash create current currval cursor data_base database date dba deallocate debugoff debugon decimal declare default definition delay delete desc digits dispose distinct do drop else elseif elsif enable end entry escape exception exception_init exchange exclusive exists exit external fast fetch file for force form from function generic goto grant group having identified if immediate in increment index indexes indicator initial initrans insert interface intersect into is key level library like limited local lock log logging long loop master maxextents maxtrans member minextents minus mislabel mode modify multiset new next no noaudit nocompress nologging noparallel not nowait number_base object of off offline on online only open option or order out package parallel partition pctfree pctincrease pctused pls_integer positive positiven pragma primary prior private privileges procedure public raise range raw read rebuild record ref references refresh release rename replace resource restrict return returning returns reverse revoke rollback row rowid rowlabel rownum rows run savepoint schema segment select separate session set share snapshot some space split sql start statement storage subtype successful synonym tabauth table tables tablespace task terminate then to trigger truncate type union unique unlimited unrecoverable unusable update use using validate value values variable view views when whenever where while with work"),
    builtin:    set("abs acos add_months ascii asin atan atan2 average bfile bfilename bigserial bit blob ceil character chartorowid chr clob concat convert cos cosh count dec decode deref dual dump dup_val_on_index empty error exp false float floor found glb greatest hextoraw initcap instr instrb int integer isopen last_day least length lengthb ln lower lpad ltrim lub make_ref max min mlslabel mod months_between natural naturaln nchar nclob new_time next_day nextval nls_charset_decl_len nls_charset_id nls_charset_name nls_initcap nls_lower nls_sort nls_upper nlssort no_data_found notfound null number numeric nvarchar2 nvl others power rawtohex real reftohex round rowcount rowidtochar rowtype rpad rtrim serial sign signtype sin sinh smallint soundex sqlcode sqlerrm sqrt stddev string substr substrb sum sysdate tan tanh to_char text to_date to_label to_multi_byte to_number to_single_byte translate true trunc uid unlogged upper user userenv varchar varchar2 variance varying vsize xml"),
    operatorChars: /^[*+\-%<>!=~]/,

    operatorChars: /^[*+\-%<>!=~]/,
    dateSQL:    set("date time timestamp"),
    support:    set("doubleQuote nCharCast zerolessFloat binaryNumber hexNumber")

    dateSQL:    set("date time timestamp"),
    support:    set("doubleQuote nCharCast zerolessFloat binaryNumber hexNumber")
  });

    name: "sql",
    keywords: set("select alter $elem$ $key$ $value$ add after all analyze and archive as asc before between binary both bucket buckets by cascade case cast change cluster clustered clusterstatus collection column columns comment compute concatenate continue create cross cursor data database databases dbproperties deferred delete delimited desc describe directory disable distinct distribute drop else enable end escaped exclusive exists explain export extended external false fetch fields fileformat first format formatted from full function functions grant group having hold_ddltime idxproperties if import in index indexes inpath inputdriver inputformat insert intersect into is items join keys lateral left like limit lines load local location lock locks mapjoin materialized minus msck no_drop nocompress not of offline on option or order out outer outputdriver outputformat overwrite partition partitioned partitions percent plus preserve procedure purge range rcfile read readonly reads rebuild recordreader recordwriter recover reduce regexp rename repair replace restrict revoke right rlike row schema schemas semi sequencefile serde serdeproperties set shared show show_database sort sorted ssl statistics stored streamtable table tables tablesample tblproperties temporary terminated textfile then tmp to touch transform trigger true unarchive undo union uniquejoin unlock update use using utc utc_tmestamp view when where while with"),
    builtin: set("bool boolean long timestamp tinyint smallint bigint int float double date datetime unsigned string array struct map uniontype"),

    keywords: set("select alter $elem$ $key$ $value$ add after all analyze and archive as asc before between binary both bucket buckets by cascade case cast change cluster clustered clusterstatus collection column columns comment compute concatenate continue create cross cursor data database databases dbproperties deferred delete delimited desc describe directory disable distinct distribute drop else enable end escaped exclusive exists explain export extended external false fetch fields fileformat first format formatted from full function functions grant group having hold_ddltime idxproperties if import in index indexes inpath inputdriver inputformat insert intersect into is items join keys lateral left like limit lines load local location lock locks mapjoin materialized minus msck no_drop nocompress not of offline on option or order out outer outputdriver outputformat overwrite partition partitioned partitions percent plus preserve procedure purge range rcfile read readonly reads rebuild recordreader recordwriter recover reduce regexp rename repair replace restrict revoke right rlike row schema schemas semi sequencefile serde serdeproperties set shared show show_database sort sorted ssl statistics stored streamtable table tables tablesample tblproperties temporary terminated textfile then tmp to touch transform trigger true unarchive undo union uniquejoin unlock update use using utc utc_tmestamp view when where while with"),
    builtin: set("bool boolean long timestamp tinyint smallint bigint int float double date datetime unsigned string array struct map uniontype"),
    atoms: set("false true null unknown"),

    builtin: set("bool boolean long timestamp tinyint smallint bigint int float double date datetime unsigned string array struct map uniontype"),
    atoms: set("false true null unknown"),
    operatorChars: /^[*+\-%<>!=]/,

    operatorChars: /^[*+\-%<>!=]/,
    dateSQL: set("date timestamp"),
    support: set("ODBCdotTable doubleQuote binaryNumber hexNumber")

    dateSQL: set("date timestamp"),
    support: set("ODBCdotTable doubleQuote binaryNumber hexNumber")
  });

    name: "sql",
    client: set("source"),
    // http://www.postgresql.org/docs/9.5/static/sql-keywords-appendix.html

    // http://www.postgresql.org/docs/9.5/static/sql-keywords-appendix.html
    keywords: set(sqlKeywords + "a abort abs absent absolute access according action ada add admin after aggregate all allocate also always analyse analyze any are array array_agg array_max_cardinality asensitive assertion assignment asymmetric at atomic attribute attributes authorization avg backward base64 before begin begin_frame begin_partition bernoulli binary bit_length blob blocked bom both breadth c cache call called cardinality cascade cascaded case cast catalog catalog_name ceil ceiling chain characteristics characters character_length character_set_catalog character_set_name character_set_schema char_length check checkpoint class class_origin clob close cluster coalesce cobol collate collation collation_catalog collation_name collation_schema collect column columns column_name command_function command_function_code comment comments commit committed concurrently condition condition_number configuration conflict connect connection connection_name constraint constraints constraint_catalog constraint_name constraint_schema constructor contains content continue control conversion convert copy corr corresponding cost covar_pop covar_samp cross csv cube cume_dist current current_catalog current_date current_default_transform_group current_path current_role current_row current_schema current_time current_timestamp current_transform_group_for_type current_user cursor cursor_name cycle data database datalink datetime_interval_code datetime_interval_precision day db deallocate dec declare default defaults deferrable deferred defined definer degree delimiter delimiters dense_rank depth deref derived describe descriptor deterministic diagnostics dictionary disable discard disconnect dispatch dlnewcopy dlpreviouscopy dlurlcomplete dlurlcompleteonly dlurlcompletewrite dlurlpath dlurlpathonly dlurlpathwrite dlurlscheme dlurlserver dlvalue do document domain dynamic dynamic_function dynamic_function_code each element else empty enable encoding encrypted end end-exec end_frame end_partition enforced enum equals escape event every except exception exclude excluding exclusive exec execute exists exp explain expression extension external extract false family fetch file filter final first first_value flag float floor following for force foreign fortran forward found frame_row free freeze fs full function functions fusion g general generated get global go goto grant granted greatest grouping groups handler header hex hierarchy hold hour id identity if ignore ilike immediate immediately immutable implementation implicit import including increment indent index indexes indicator inherit inherits initially inline inner inout input insensitive instance instantiable instead integrity intersect intersection invoker isnull isolation k key key_member key_type label lag language large last last_value lateral lead leading leakproof least left length level library like_regex link listen ln load local localtime localtimestamp location locator lock locked logged lower m map mapping match matched materialized max maxvalue max_cardinality member merge message_length message_octet_length message_text method min minute minvalue mod mode modifies module month more move multiset mumps name names namespace national natural nchar nclob nesting new next nfc nfd nfkc nfkd nil no none normalize normalized nothing notify notnull nowait nth_value ntile null nullable nullif nulls number object occurrences_regex octets octet_length of off offset oids old only open operator option options ordering ordinality others out outer output over overlaps overlay overriding owned owner p pad parameter parameter_mode parameter_name parameter_ordinal_position parameter_specific_catalog parameter_specific_name parameter_specific_schema parser partial partition pascal passing passthrough password percent percentile_cont percentile_disc percent_rank period permission placing plans pli policy portion position position_regex power precedes preceding prepare prepared preserve primary prior privileges procedural procedure program public quote range rank read reads reassign recheck recovery recursive ref references referencing refresh regr_avgx regr_avgy regr_count regr_intercept regr_r2 regr_slope regr_sxx regr_sxy regr_syy reindex relative release rename repeatable replace replica requiring reset respect restart restore restrict result return returned_cardinality returned_length returned_octet_length returned_sqlstate returning returns revoke right role rollback rollup routine routine_catalog routine_name routine_schema row rows row_count row_number rule savepoint scale schema schema_name scope scope_catalog scope_name scope_schema scroll search second section security selective self sensitive sequence sequences serializable server server_name session session_user setof sets share show similar simple size skip snapshot some source space specific specifictype specific_name sql sqlcode sqlerror sqlexception sqlstate sqlwarning sqrt stable standalone start state statement static statistics stddev_pop stddev_samp stdin stdout storage strict strip structure style subclass_origin submultiset substring substring_regex succeeds sum symmetric sysid system system_time system_user t tables tablesample tablespace table_name temp template temporary then ties timezone_hour timezone_minute to token top_level_count trailing transaction transactions_committed transactions_rolled_back transaction_active transform transforms translate translate_regex translation treat trigger trigger_catalog trigger_name trigger_schema trim trim_array true truncate trusted type types uescape unbounded uncommitted under unencrypted unique unknown unlink unlisten unlogged unnamed unnest until untyped upper uri usage user user_defined_type_catalog user_defined_type_code user_defined_type_name user_defined_type_schema using vacuum valid validate validator value value_of varbinary variadic var_pop var_samp verbose version versioning view views volatile when whenever whitespace width_bucket window within work wrapper write xmlagg xmlattributes xmlbinary xmlcast xmlcomment xmlconcat xmldeclaration xmldocument xmlelement xmlexists xmlforest xmliterate xmlnamespaces xmlparse xmlpi xmlquery xmlroot xmlschema xmlserialize xmltable xmltext xmlvalidate year yes loop repeat"),
    // http://www.postgresql.org/docs/9.5/static/datatype.html

    // http://www.postgresql.org/docs/9.5/static/datatype.html
    builtin: set("bigint int8 bigserial serial8 bit varying varbit boolean bool box bytea character char varchar cidr circle date double precision float8 inet integer int int4 interval json jsonb line lseg macaddr money numeric decimal path pg_lsn point polygon real float4 smallint int2 smallserial serial2 serial serial4 text time without zone with timetz timestamp timestamptz tsquery tsvector txid_snapshot uuid xml"),
    atoms: set("false true null unknown"),

    builtin: set("bigint int8 bigserial serial8 bit varying varbit boolean bool box bytea character char varchar cidr circle date double precision float8 inet integer int int4 interval json jsonb line lseg macaddr money numeric decimal path pg_lsn point polygon real float4 smallint int2 smallserial serial2 serial serial4 text time without zone with timetz timestamp timestamptz tsquery tsvector txid_snapshot uuid xml"),
    atoms: set("false true null unknown"),
    operatorChars: /^[*+\-%<>!=&|^\/#@?~]/,

    operatorChars: /^[*+\-%<>!=&|^\/#@?~]/,
    dateSQL: set("date time timestamp"),
    support: set("ODBCdotTable decimallessFloat zerolessFloat binaryNumber hexNumber nCharCast charsetCast")

    dateSQL: set("date time timestamp"),
    support: set("ODBCdotTable decimallessFloat zerolessFloat binaryNumber hexNumber nCharCast charsetCast")
  });

    name: "sql",
    keywords: set("ancestor and asc by contains desc descendant distinct from group has in is limit offset on order select superset where"),
    atoms: set("false true"),

    keywords: set("ancestor and asc by contains desc descendant distinct from group has in is limit offset on order select superset where"),
    atoms: set("false true"),
    builtin: set("blob datetime first key __key__ string integer double boolean null"),

    atoms: set("false true"),
    builtin: set("blob datetime first key __key__ string integer double boolean null"),
    operatorChars: /^[*+\-%<>!=]/

    bbHalfExtents:set(be:getObjectOOBBHalfExtentsXYZ(vehId))
    bottomRear:setAdd(vec3(0,-bbHalfExtents.y,0))

    bottomRear:setAdd(vec3(0,0,-bbHalfExtents.z))
    bbCenter:set(be:getObjectOOBBCenterXYZ(vehId))

    defaultCamPos:set(
    math.sin(math.rad(self.defaultRotation.x)) * math.cos(math.rad(self.defaultRotation.y))

  self.skipFovModifier = self.skipFovModifier or false
  self.smoothedPitchOffset:set(0)
  self.dynamicPitchQuat:setFromEuler(0, 0, 0)

  if self.target then
    ref:set(self.targetCenter)
    left:set(self.targetLeft)

    ref:set(self.targetCenter)
    left:set(self.targetLeft)
    back:set(self.targetBack)

    left:set(self.targetLeft)
    back:set(self.targetBack)
  else

    if self.refNodes then
      ref:set(data.veh:getNodePositionXYZ(self.refNodes.ref))
      left:set(data.veh:getNodePositionXYZ(self.refNodes.left))

      ref:set(data.veh:getNodePositionXYZ(self.refNodes.ref))
      left:set(data.veh:getNodePositionXYZ(self.refNodes.left))
      back:set(data.veh:getNodePositionXYZ(self.refNodes.back))

      left:set(data.veh:getNodePositionXYZ(self.refNodes.left))
      back:set(data.veh:getNodePositionXYZ(self.refNodes.back))
    end

  if data.teleported then
    self.smoothedPitchOffset:set(0)
    self.dynamicPitchQuat:setFromEuler(0, 0, 0)

  -- calculate the camera offset: rotate with the vehicle
  nx:set(push3(left) - ref)
  ny:set(push3(back) - ref)

  nx:set(push3(left) - ref)
  ny:set(push3(back) - ref)
  nz:set(push3(nx):cross(ny))

  ny:set(push3(back) - ref)
  nz:set(push3(nx):cross(ny))
  ny:set(push3(nx):cross(-push3(nz)))

  nz:set(push3(nx):cross(ny))
  ny:set(push3(nx):cross(-push3(nz)))
  nx:normalize()

    if not self.camOffset2 then self.camOffset2 = vec3() end
    self.camOffset2:set(push3(nx) * self.camBase.x + push3(ny) * self.camBase.y + push3(nz) * self.camBase.z)
    targetPos:set(push3(data.pos) + ref + self.camOffset2)

    self.camOffset2:set(push3(nx) * self.camBase.x + push3(ny) * self.camBase.y + push3(nz) * self.camBase.z)
    targetPos:set(push3(data.pos) + ref + self.camOffset2)
  end

  local pitchDif = 0.1*(MoveManager.pitchDown - MoveManager.pitchUp)
  dir:set(vecY)

    if self.lockCamera == true then
      camdir:set(push3(self.camLastTargetPos) - self.camLastPos2)
      if sign((push3(targetPos) - self.camLastTargetPos):dot(camdir)) < 0 then

        self.camLastRot.x = self.camLastRot.x + math.pi
        self.camLastPos2:set(push3(targetPos) + camdir)
        self.camLastPosPerp:set(push3(vecZ):cross(camdir):normalized() * (self.relaxation * -0.8) + targetPos)

        self.camLastPos2:set(push3(targetPos) + camdir)
        self.camLastPosPerp:set(push3(vecZ):cross(camdir):normalized() * (self.relaxation * -0.8) + targetPos)
      end

      else
        self.camRot:set(self.defaultRotation)
        self.camLastRot:set(math.rad(self.camRot.x), math.rad(self.camRot.y) * 1.5, 0)

        self.camRot:set(self.defaultRotation)
        self.camLastRot:set(math.rad(self.camRot.x), math.rad(self.camRot.y) * 1.5, 0)
      end

  if self.cameraResetted ~= 1 then
    lastCamPointVec:set(push3(targetPos) - self.camLastPos2)
    lastCamLastPerp:set(push3(self.camLastPosPerp) - targetPos)

    lastCamPointVec:set(push3(targetPos) - self.camLastPos2)
    lastCamLastPerp:set(push3(self.camLastPosPerp) - targetPos)
    if lastCamPointVec:length() < self.relaxation and lastCamLastPerp:length() > self.relaxation * 0.8 then

    if lastCamPointVec:length() < self.relaxation and lastCamLastPerp:length() > self.relaxation * 0.8 then
      moveDir:set(push3(targetPos) - self.camLastTargetPos); moveDir:normalize()
      if math.abs(push3(lastCamPointVec):normalized():dot(moveDir)) > math.abs(push3(lastCamLastPerp):normalized():dot(moveDir)) then

      if math.abs(push3(lastCamPointVec):normalized():dot(moveDir)) > math.abs(push3(lastCamLastPerp):normalized():dot(moveDir)) then
        self.camLastPos2:set(push3(lastCamPointVec):cross(lastCamLastPerp):cross(lastCamLastPerp):normalized() + targetPos)
        lastCamPointVec:set(push3(targetPos) - self.camLastPos2)

        self.camLastPos2:set(push3(lastCamPointVec):cross(lastCamLastPerp):cross(lastCamLastPerp):normalized() + targetPos)
        lastCamPointVec:set(push3(targetPos) - self.camLastPos2)
      end

    end
    dir:set(lastCamPointVec)
    dir:normalize()

    -- flatten the rotation plane when camera moves perpendicularly
    dirxy:set(dir.x, dir.y, 0)
    local dirxylen = dirxy:length()

    local coef = math.sqrt(math.max(0, 1 - dirxylen))
    dir:set(push3(dir) * math.max(0, 1 - coef) + push3(dirxy) * (coef / (dirxylen + 1e-30)))
    dir:normalize()

  lastCamPointVec:set(push3(self.camLastPos2) - targetPos)
  self.camLastPos2:set(push3(lastCamPointVec) * (self.relaxation / (lastCamPointVec:length() + 1e-30)) + targetPos)

  lastCamPointVec:set(push3(self.camLastPos2) - targetPos)
  self.camLastPos2:set(push3(lastCamPointVec) * (self.relaxation / (lastCamPointVec:length() + 1e-30)) + targetPos)

  rot:set(math.rad(self.camRot.x), math.rad(self.camRot.y), math.rad(self.camRot.z))

  if self.rearNodeID then
    rear:set(data.veh:getNodePositionXYZ(self.rearNodeID))
    rear:setAdd(data.pos)

    local vehId = data.veh:getID()
    bbCenter:set(be:getObjectOOBBCenterXYZ(vehId))
    bbHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))

    bbCenter:set(be:getObjectOOBBCenterXYZ(vehId))
    bbHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))
    rear:set(bbCenter)

    bbHalfAxis1:set(be:getObjectOOBBHalfAxisXYZ(vehId, 1))
    rear:set(bbCenter)
    rear:setAdd(bbHalfAxis1)

  calculatedCamPos:set(
    math.sin(rotB.x) * math.cos(rotB.y)

  camPos:set(push3(calculatedCamPos) + targetPos + self.orbitOffset)
  updir:setCross(vecZ, dir)

  updir:setCross(vecZ, dir)
  self.camLastPosPerp:set(push3(updir) * (self.relaxation * -0.8 / (updir:length() + 1e-30)) + targetPos)

  self.camLastTargetPos2:set(self.camLastTargetPos)
  self.camLastTargetPos:set(targetPos)

  self.camLastTargetPos2:set(self.camLastTargetPos)
  self.camLastTargetPos:set(targetPos)
  self.camVel:set((push3(camPos) - self.camLastPos) / data.dt)

  self.camLastTargetPos:set(targetPos)
  self.camVel:set((push3(camPos) - self.camLastPos) / data.dt)
  self.camLastPos:set(camPos)

  self.camVel:set((push3(camPos) - self.camLastPos) / data.dt)
  self.camLastPos:set(camPos)
  self.camLastRot:set(rot)

  self.camLastPos:set(camPos)
  self.camLastRot:set(rot)
  self.camLastDist = dist

  resultPos:set(0, 0, lengthValue)
  resultPos:setScaled(self.maxDynamicOffset)

  resultRot:setMul2(self.dynamicPitchQuat, resultRot)
  data.res.pos:set(resultPos)
  data.res.rot:set(resultRot)

  data.res.pos:set(resultPos)
  data.res.rot:set(resultRot)
  data.res.fov = fov

  data.res.fov = fov
  data.res.targetPos:set(targetPos)
  self.collision:update(data)

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

        if (!this._recentlyModifiedAttributes.has(attribute))
            this._recentlyModifiedAttributes.set(attribute, new Set);
        this._recentlyModifiedAttributes.get(attribute).add(node);

    {
        this._recentlyInsertedNodes.set(event.data.node, {parent: event.data.parent});
        if (this._treeOutline._visible)

    {
        this._recentlyDeletedNodes.set(event.data.node, {parent: event.data.parent});
        if (this._treeOutline._visible)

local function init(jbeamData)
  avgConsumptionSmoother:set(avgConsumptionDefaultValue)
end

        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)

        // Associate the resource with the requestIdentifier so it can be found in future loading events.
        this._resourceRequestIdentifierMap.set(requestIdentifier, resource);
    }

    {
        this._webSocketIdentifierToURL.set(requestId, url);
    }

        this._resourceRequestIdentifierMap.set(requestId, resource);
    }

            if (resource) {
                this._resourceRequestIdentifierMap.set(requestIdentifier, resource);
                resource.revertMarkAsFinished();

            // Associate the resource with the requestIdentifier so it can be found in future loading events.
            this._resourceRequestIdentifierMap.set(requestIdentifier, resource);
        }

            let localResource = WI.LocalResource.fromHAREntry(entry, mainResourceSentWalltime);
            this._localResourcesMap.set(localResource.url, localResource);
            localResources.push(localResource);

            frame = new WI.Frame(frameIdentifier, frameOptions.name, frameOptions.securityOrigin, resourceOptions.loaderIdentifier, resource);
            this._frameIdentifierMap.set(frame.id, frame);

        this._frameIdentifierMap.set(frame.id, frame);

            resources = [];
            this._orphanedResources.set(targetId, resources);
        }

        this._sourceMapURLMap.set(sourceMapURL, sourceMap);

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

    local pos = editor.getAxisGizmoTransform():getColumn(3)
    s.pos:set(pos.x, pos.y, pos.z)
    return

      if (!depsMap) {
          targetMap.set(target, (depsMap = new Map()));
      }

      if (!dep) {
          depsMap.set(key, (dep = new Set()));
      }

  function createSetter(shallow = false) {
      return function set(target, key, value, receiver) {
          let oldValue = target[key];

              : hasOwn(target, key);
          const result = Reflect.set(target, key, value, receiver);
          // don't trigger if target is something up in the prototype chain of original

      get: readonlyGet,
      set(target, key) {
          {

      const oldValue = get.call(target, key);
      target.set(key, value);
      if (!hadKey) {

      const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
      proxyMap.set(target, proxy);
      return proxy;

          else {
              return Reflect.set(target, key, value, receiver);
          }

      if (!seen.has(fn)) {
          seen.set(fn, 1);
      }

          else {
              seen.set(fn, count + 1);
          }

      }
      map.set(id, {
          component: isClassComponent(component) ? component.__vccOpts : component,

          leavingVNodesCache = Object.create(null);
          leavingVNodes.set(vnode.type, leavingVNodesCache);
      }

              if (pendingCacheKey != null) {
                  cache.set(pendingCacheKey, getInnerChild(instance.subTree));
              }

                      }
                      keyToNewIndexMap.set(nextChild.key, i);
                  }

      },
      set({ _: instance }, key, value) {
          const { data, setupState, ctx } = instance;

                      setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state, instance));
                      positionMap.set(child, child.el.getBoundingClientRect());
                  }

  function recordPosition(c) {
      newPositionMap.set(c, c.el.getBoundingClientRect());
  }

              },
              set() {
                  warn(`The \`isCustomElement\` config option is only respected when using the runtime compiler.` +

                  if (generatedPropsType === 0 /* NOT_CONSTANT */) {
                      constantCache.set(node, 0 /* NOT_CONSTANT */);
                      return 0 /* NOT_CONSTANT */;

                      if (childType === 0 /* NOT_CONSTANT */) {
                          constantCache.set(node, 0 /* NOT_CONSTANT */);
                          return 0 /* NOT_CONSTANT */;

                              if (expType === 0 /* NOT_CONSTANT */) {
                                  constantCache.set(node, 0 /* NOT_CONSTANT */);
                                  return 0 /* NOT_CONSTANT */;

                  }
                  constantCache.set(node, returnType);
                  return returnType;

              else {
                  constantCache.set(node, 0 /* NOT_CONSTANT */);
                  return 0 /* NOT_CONSTANT */;

              const count = context.helpers.get(name) || 0;
              context.helpers.set(name, count + 1);
              return name;

                  else {
                      context.helpers.set(name, currentCount);
                  }

                      if (isSymbol(needRuntime)) {
                          directiveImportMap.set(prop, needRuntime);
                      }

          else {
              knownProps.set(name, prop);
              deduped.push(prop);

  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)

    }
    data.set(
      data.id,

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

            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);
    }

            resourcesCollectionForType = new WI.ResourceCollection(type);
            this._resourcesTypeMap.set(type, resourcesCollectionForType);
        }

    {
        this._resourceURLMap.set(resource.url, resource);

        this._resourceURLMap.set(resource.url, resource);
        this._resourceURLMap.delete(oldURL);

        local sp = data.self.path.startPositions:create(nil, data.spid or nil)
        sp:set(data.mouseInfo._downPos,
        quatFromDir(data.mouseInfo._upPos - data.mouseInfo._downPos):normalized(), vec3(0,0,1))

  local rotationValues = self.pinIn.rotation.value or zerosTable4
  tr:set(rotationValues[1], rotationValues[2], rotationValues[3], rotationValues[4])
  local yVec = tr * vecY

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

                let pseudoElementRules = parseRuleMatchArrayPayload(matches, this._node, false, pseudoId);
                this._pseudoElements.set(pseudoId, {matchedRules: pseudoElementRules});
            }

        if (mapKey)
            this._rulesMap.set(mapKey, rule);

  else
    dirVecUp:set(0, 0, 1)
  end

  local beam = vEditor.vdata.beams[beamID]
  tempVec:set(vEditor.vehicle:getNodeAbsPosition(beam.id1))
  tempVec:setSub(vEditor.vehicle:getNodeAbsPosition(beam.id2))

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

A100:"#82b1ff",A200:"#448aff",A400:"#2979ff",A700:"#2962ff",contrastDefaultColor:"light",contrastDarkColors:"100 200 300 400 A100",contrastStrongLightColors:"500 600 700 A200 A400 A700"},"light-blue":{50:"#e1f5fe",100:"#b3e5fc",200:"#81d4fa",300:"#4fc3f7",400:"#29b6f6",500:"#03a9f4",600:"#039be5",700:"#0288d1",800:"#0277bd",900:"#01579b",A100:"#80d8ff",A200:"#40c4ff",A400:"#00b0ff",A700:"#0091ea",contrastDefaultColor:"dark",contrastLightColors:"500 600 700 800 900 A700",contrastStrongLightColors:"500 600 700 800 A700"},cyan:{50:"#e0f7fa",100:"#b2ebf2",200:"#80deea",300:"#4dd0e1",400:"#26c6da",500:"#00bcd4",600:"#00acc1",700:"#0097a7",800:"#00838f",900:"#006064",A100:"#84ffff",A200:"#18ffff",A400:"#00e5ff",A700:"#00b8d4",contrastDefaultColor:"dark",contrastLightColors:"500 600 700 800 900",contrastStrongLightColors:"500 600 700 800"},teal:{50:"#e0f2f1",100:"#b2dfdb",200:"#80cbc4",300:"#4db6ac",400:"#26a69a",500:"#009688",600:"#00897b",700:"#00796b",800:"#00695c",900:"#004d40",A100:"#a7ffeb",A200:"#64ffda",A400:"#1de9b6",A700:"#00bfa5",contrastDefaultColor:"dark",contrastLightColors:"500 600 700 800 900",contrastStrongLightColors:"500 600 700"},green:{50:"#e8f5e9",100:"#c8e6c9",200:"#a5d6a7",300:"#81c784",400:"#66bb6a",500:"#4caf50",600:"#43a047",700:"#388e3c",800:"#2e7d32",900:"#1b5e20",A100:"#b9f6ca",A200:"#69f0ae",A400:"#00e676",A700:"#00c853",contrastDefaultColor:"dark",contrastLightColors:"500 600 700 800 900",contrastStrongLightColors:"500 600 700"},"light-green":{50:"#f1f8e9",100:"#dcedc8",200:"#c5e1a5",300:"#aed581",400:"#9ccc65",500:"#8bc34a",600:"#7cb342",700:"#689f38",800:"#558b2f",900:"#33691e",A100:"#ccff90",A200:"#b2ff59",A400:"#76ff03",A700:"#64dd17",contrastDefaultColor:"dark",contrastLightColors:"800 900",contrastStrongLightColors:"800 900"},lime:{50:"#f9fbe7",100:"#f0f4c3",200:"#e6ee9c",300:"#dce775",400:"#d4e157",500:"#cddc39",600:"#c0ca33",700:"#afb42b",800:"#9e9d24",900:"#827717",A100:"#f4ff81",A200:"#eeff41",A400:"#c6ff00",A700:"#aeea00",contrastDefaultColor:"dark",contrastLightColors:"900",contrastStrongLightColors:"900"},yellow:{50:"#fffde7",100:"#fff9c4",200:"#fff59d",300:"#fff176",400:"#ffee58",500:"#ffeb3b",600:"#fdd835",700:"#fbc02d",800:"#f9a825",900:"#f57f17",A100:"#ffff8d",A200:"#ffff00",A400:"#ffea00",A700:"#ffd600",contrastDefaultColor:"dark"},amber:{50:"#fff8e1",100:"#ffecb3",200:"#ffe082",300:"#ffd54f",400:"#ffca28",500:"#ffc107",600:"#ffb300",700:"#ffa000",800:"#ff8f00",900:"#ff6f00",A100:"#ffe57f",A200:"#ffd740",A400:"#ffc400",A700:"#ffab00",contrastDefaultColor:"dark"},orange:{50:"#fff3e0",100:"#ffe0b2",200:"#ffcc80",300:"#ffb74d",400:"#ffa726",500:"#ff9800",600:"#fb8c00",700:"#f57c00",800:"#ef6c00",900:"#e65100",A100:"#ffd180",A200:"#ffab40",A400:"#ff9100",A700:"#ff6d00",contrastDefaultColor:"dark",contrastLightColors:"800 900",contrastStrongLightColors:"800 900"},"deep-orange":{50:"#fbe9e7",100:"#ffccbc",200:"#ffab91",300:"#ff8a65",400:"#ff7043",500:"#ff5722",600:"#f4511e",700:"#e64a19",800:"#d84315",900:"#bf360c",A100:"#ff9e80",A200:"#ff6e40",A400:"#ff3d00",A700:"#dd2c00",contrastDefaultColor:"light",contrastDarkColors:"50 100 200 300 400 A100 A200",contrastStrongLightColors:"500 600 700 800 900 A400 A700"},brown:{50:"#efebe9",100:"#d7ccc8",200:"#bcaaa4",300:"#a1887f",400:"#8d6e63",500:"#795548",600:"#6d4c41",700:"#5d4037",800:"#4e342e",900:"#3e2723",A100:"#d7ccc8",A200:"#bcaaa4",A400:"#8d6e63",A700:"#5d4037",contrastDefaultColor:"light",contrastDarkColors:"50 100 200",contrastStrongLightColors:"300 400"},grey:{50:"#fafafa",100:"#f5f5f5",200:"#eeeeee",300:"#e0e0e0",400:"#bdbdbd",500:"#9e9e9e",600:"#757575",700:"#616161",800:"#424242",900:"#212121",1000:"#000000",A100:"#ffffff",A200:"#eeeeee",A400:"#bdbdbd",A700:"#616161",contrastDefaultColor:"dark",contrastLightColors:"600 700 800 900"},"blue-grey":{50:"#eceff1",100:"#cfd8dc",200:"#b0bec5",300:"#90a4ae",400:"#78909c",500:"#607d8b",600:"#546e7a",700:"#455a64",800:"#37474f",900:"#263238",A100:"#cfd8dc",A200:"#b0bec5",A400:"#78909c",A700:"#455a64",contrastDefaultColor:"light",contrastDarkColors:"50 100 200 300",contrastStrongLightColors:"400 500"}})}(),function(){function e(e){function o(e,t){return t=t||{},m[e]=a(e,t),g}function r(e,n){return a(e,t.extend({},m[e]||{},n))}function a(e,t){var n=C.filter(function(e){return!t[e]});if(n.length)throw new Error("Missing colors %1 in palette %2!".replace("%1",n.join(", ")).replace("%2",e));return t}function d(e,n){if(s[e])return s[e];n=n||"default";var o="string"==typeof n?s[n]:n,r=new c(e);return o&&t.forEach(o.colors,function(e,n){r.colors[n]={name:e.name,hues:t.extend({},e.hues)}}),s[e]=r,r}function c(e){function n(e){if(e=0===arguments.length?!0:!!e,e!==o.isDark){o.isDark=e,o.foregroundPalette=o.isDark?f:p,o.foregroundShadow=o.isDark?h:b;var n=o.isDark?T:A,r=o.isDark?A:T;return t.forEach(n,function(e,t){var n=o.colors[t],i=r[t];if(n)for(var a in n.hues)n.hues[a]===i[a]&&(n.hues[a]=e[a])}),o}}var o=this;o.name=e,o.colors={},o.dark=n,n(!1),M.forEach(function(e){var n=(o.isDark?T:A)[e];o[e+"Palette"]=function(r,i){var a=o.colors[e]={name:r,hues:t.extend({},n,i)};return Object.keys(a.hues).forEach(function(e){if(!n[e])throw new Error("Invalid hue name '%1' in theme %2's %3 color %4. Available hue names: %4".replace("%1",e).replace("%2",o.name).replace("%3",r).replace("%4",Object.keys(n).join(", ")))}),Object.keys(a.hues).map(function(e){return a.hues[e]}).forEach(function(t){if(-1==C.indexOf(t))throw new Error("Invalid hue value '%1' in theme %2's %3 color %4. Available hue values: %5".replace("%1",t).replace("%2",o.name).replace("%3",e).replace("%4",r).replace("%5",C.join(", ")))}),o},o[e+"Color"]=function(){var t=Array.prototype.slice.call(arguments);return console.warn("$mdThemingProviderTheme."+e+"Color() has been deprecated. Use $mdThemingProviderTheme."+e+"Palette() instead."),o[e+"Palette"].apply(o,t)}})}function u(e,o){function r(e){return e===n||""===e?!0:i.THEMES[e]!==n}function i(t,o){o===n&&(o=t,t=n),t===n&&(t=e),i.inherit(o,o)}return i.inherit=function(n,i){function a(e){r(e)||o.warn("Attempted to use unregistered theme '"+e+"'. Register it with $mdThemingProvider.theme().");var t=n.data("$mdThemeName");t&&n.removeClass("md-"+t+"-theme"),n.addClass("md-"+e+"-theme"),n.data("$mdThemeName",e),d&&n.data("$mdThemeController",d)}var d=i.controller("mdTheme"),c=n.attr("md-theme-watch");if((v||t.isDefined(c))&&"false"!=c){var l=e.$watch(function(){return d&&d.$mdTheme||E},a);n.on("$destroy",l)}else{var m=d&&d.$mdTheme||E;a(m)}},i.THEMES=t.extend({},s),i.defaultTheme=function(){return E},i.registered=r,i}m={},s={};var g,E="default",v=!1;return t.extend(m,e),u.$inject=["$rootScope","$log"],g={definePalette:o,extendPalette:r,theme:d,setDefaultTheme:function(e){E=e},alwaysWatchTheme:function(e){v=e},$get:u,_LIGHT_DEFAULT_HUES:A,_DARK_DEFAULT_HUES:T,_PALETTES:m,_THEMES:s,_parseRules:i,_rgba:l}}function o(e,t,n){return{priority:100,link:{pre:function(o,r,i){var a={$setTheme:function(t){e.registered(t)||n.warn("attempted to use unregistered theme '"+t+"'"),a.$mdTheme=t}};r.data("$mdThemeController",a),a.$setTheme(t(i.mdTheme)(o)),i.$observe("mdTheme",a.$setTheme)}}}}function r(e){return e}function i(e,n,o){d(e,n),o=o.replace(/THEME_NAME/g,e.name);var r=[],i=e.colors[n],a=new RegExp(".md-"+e.name+"-theme","g"),c=new RegExp("('|\")?{{\\s*("+n+")-(color|contrast)-?(\\d\\.?\\d*)?\\s*}}(\"|')?","g"),s=/'?"?\{\{\s*([a-zA-Z]+)-(A?\d+|hue\-[0-3]|shadow)-?(\d\.?\d*)?\s*\}\}'?"?/g,u=m[i.name];return o=o.replace(s,function(t,n,o,r){return"foreground"===n?"shadow"==o?e.foregroundShadow:e.foregroundPalette[o]||e.foregroundPalette[1]:(0===o.indexOf("hue")&&(o=e.colors[n].hues[o]),l((m[e.colors[n].name][o]||"").value,r))}),t.forEach(i.hues,function(t,n){var i=o.replace(c,function(e,n,o,r,i){return l(u[t]["color"===r?"value":"contrast"],i)});"default"!==n&&(i=i.replace(a,".md-"+e.name+"-theme.md-"+n)),"default"==e.name&&(i=i.replace(/\.md-default-theme/g,"")),r.push(i)}),r}function a(e){function n(e){var n=e.contrastDefaultColor,o=e.contrastLightColors||[],r=e.contrastStrongLightColors||[],i=e.contrastDarkColors||[];"string"==typeof o&&(o=o.split(" ")),"string"==typeof r&&(r=r.split(" ")),"string"==typeof i&&(i=i.split(" ")),delete e.contrastDefaultColor,delete e.contrastLightColors,delete e.contrastStrongLightColors,delete e.contrastDarkColors,t.forEach(e,function(a,d){function l(){return"light"===n?i.indexOf(d)>-1?g:r.indexOf(d)>-1?v:E:o.indexOf(d)>-1?r.indexOf(d)>-1?v:E:g}if(!t.isObject(a)){var m=c(a);if(!m)throw new Error("Color %1, in palette %2's hue %3, is invalid. Hex or rgb(a) color expected.".replace("%1",a).replace("%2",e.name).replace("%3",d));e[d]={value:m,contrast:l()}}})}var o=document.getElementsByTagName("head")[0],r=o?o.firstElementChild:null,a=e.has("$MD_THEME_CSS")?e.get("$MD_THEME_CSS"):"";if(r&&0!==a.length){t.forEach(m,n);var d={},l=a.split(/\}(?!(\}|'|"|;))/).filter(function(e){return e&&e.length}).map(function(e){return e.trim()+"}"}),p=new RegExp("md-("+M.join("|")+")","g");M.forEach(function(e){d[e]=""}),l.forEach(function(e){for(var t,n=(e.match(p),0);t=M[n];n++)if(e.indexOf(".md-"+t)>-1)return d[t]+=e;for(n=0;t=M[n];n++)if(e.indexOf(t)>-1)return d[t]+=e;return d[$]+=e}),t.forEach(s,function(e){u[e.name]||(M.forEach(function(t){for(var n=i(e,t,d[t]);n.length;){var a=document.createElement("style");a.setAttribute("type","text/css"),a.appendChild(document.createTextNode(n.shift())),o.insertBefore(a,r)}}),e.colors.primary.name==e.colors.accent.name&&console.warn("$mdThemingProvider: Using the same palette for primary and accent. This violates the material design spec."),u[e.name]=!0)})}}function d(e,t){if(!m[(e.colors[t]||{}).name])throw new Error("You supplied an invalid color palette for theme %1's %2 palette. Available palettes: %3".replace("%1",e.name).replace("%2",t).replace("%3",Object.keys(m).join(", ")))}function c(e){if(t.isArray(e)&&3==e.length)return e;if(/^rgb/.test(e))return e.replace(/(^\s*rgba?\(|\)\s*$)/g,"").split(",").map(function(e,t){return 3==t?parseFloat(e,10):parseInt(e,10)});if("#"==e.charAt(0)&&(e=e.substring(1)),/^([a-fA-F0-9]{3}){1,2}$/g.test(e)){var n=e.length/3,o=e.substr(0,n),r=e.substr(n,n),i=e.substr(2*n);return 1===n&&(o+=o,r+=r,i+=i),[parseInt(o,16),parseInt(r,16),parseInt(i,16)]}}function l(e,n){return e?(4==e.length&&(e=t.copy(e),n?e.pop():n=e.pop()),n&&("number"==typeof n||"string"==typeof n&&n.length)?"rgba("+e.join(",")+","+n+")":"rgb("+e.join(",")+")"):"rgb('0,0,0')"}t.module("material.core.theming",["material.core.theming.palette"]).directive("mdTheme",o).directive("mdThemable",r).provider("$mdTheming",e).run(a);var m,s,u={},p={name:"dark",1:"rgba(0,0,0,0.87)",2:"rgba(0,0,0,0.54)",3:"rgba(0,0,0,0.26)",4:"rgba(0,0,0,0.12)"},f={name:"light",1:"rgba(255,255,255,1.0)",2:"rgba(255,255,255,0.7)",3:"rgba(255,255,255,0.3)",4:"rgba(255,255,255,0.12)"},h="1px 1px 0px rgba(0,0,0,0.4), -1px -1px 0px rgba(0,0,0,0.4)",b="",g=c("rgba(0,0,0,0.87)"),E=c("rgba(255,255,255,0.87"),v=c("rgb(255,255,255)"),M=["primary","accent","warn","background"],$="primary",A={accent:{"default":"A200","hue-1":"A100","hue-2":"A400","hue-3":"A700"},background:{"default":"A100","hue-1":"300","hue-2":"800","hue-3":"900"}},T={background:{"default":"800","hue-1":"300","hue-2":"600","hue-3":"900"}};M.forEach(function(e){var t={"default":"500","hue-1":"300","hue-2":"800","hue-3":"A100"};A[e]||(A[e]=t),T[e]||(T[e]=t)});var C=["50","100","200","300","400","500","600","700","800","900","A100","A200","A400","A700"];e.$inject=["$mdColorPalette"],o.$inject=["$mdTheming","$interpolate","$log"],r.$inject=["$mdTheming"],a.$inject=["$injector"]}(),function(){t.module("material.components.autocomplete",["material.core","material.components.icon"])}(),function(){function e(){return{restrict:"E"}}function n(e){function n(e,n,i,a,d,c,l){function m(o,r,l){r=i.extractElementByName(r,"md-bottom-sheet"),p=i.createBackdrop(o,"md-bottom-sheet-backdrop md-opaque"),p.on("click",function(){i.nextTick(d.cancel,!0)}),a.inherit(p,l.parent),e.enter(p,l.parent,null);var m=new u(r,l.parent);return l.bottomSheet=m,l.targetEvent&&t.element(l.targetEvent.target).blur(),a.inherit(m.element,l.parent),l.disableParentScroll&&(l.lastOverflow=l.parent.css("overflow"),l.parent.css("overflow","hidden")),e.enter(m.element,l.parent).then(function(){var e=t.element(r[0].querySelector("button")||r[0].querySelector("a")||r[0].querySelector("[ng-click]"));e.focus(),l.escapeToClose&&(l.rootElementKeyupCallback=function(e){e.keyCode===n.KEY_CODE.ESCAPE&&i.nextTick(d.cancel,!0)},c.on("keyup",l.rootElementKeyupCallback))})}function s(n,o,r){var i=r.bottomSheet;return e.leave(p),e.leave(i.element).then(function(){r.disableParentScroll&&(r.parent.css("overflow",r.lastOverflow),delete r.lastOverflow),i.cleanup(),r.targetEvent&&t.element(r.targetEvent.target).focus()})}function u(e,t){function a(t){e.css(n.CSS.TRANSITION_DURATION,"0ms")}function c(t){var o=t.pointer.distanceY;5>o&&(o=Math.max(-r,o/2)),e.css(n.CSS.TRANSFORM,"translate3d(0,"+(r+o)+"px,0)")}function m(t){if(t.pointer.distanceY>0&&(t.pointer.distanceY>20||Math.abs(t.pointer.velocityY)>o)){var r=e.prop("offsetHeight")-t.pointer.distanceY,a=Math.min(r/t.pointer.velocityY*.75,500);e.css(n.CSS.TRANSITION_DURATION,a+"ms"),i.nextTick(d.cancel,!0)}else e.css(n.CSS.TRANSITION_DURATION,""),e.css(n.CSS.TRANSFORM,"")}var s=l.register(t,"drag",{horizontal:!1});return t.on("$md.dragstart",a).on("$md.drag",c).on("$md.dragend",m),{element:e,cleanup:function(){s(),t.off("$md.dragstart",a).off("$md.drag",c).off("$md.dragend",m)}}}var p;return{themable:!0,targetEvent:null,onShow:m,onRemove:s,escapeToClose:!0,disableParentScroll:!0}}var o=.5,r=80;return n.$inject=["$animate","$mdConstant","$mdUtil","$mdTheming","$mdBottomSheet","$rootElement","$mdGesture"],e("$mdBottomSheet").setDefaults({methods:["disableParentScroll","escapeToClose","targetEvent"],options:n})}t.module("material.components.bottomSheet",["material.core","material.components.backdrop"]).directive("mdBottomSheet",e).provider("$mdBottomSheet",n),n.$inject=["$$interimElementProvider"]}(),function(){t.module("material.components.backdrop",["material.core"]).directive("mdBackdrop",["$mdTheming","$animate","$rootElement","$window","$log","$$rAF","$document",function(e,t,n,o,r,i,a){function d(d,l,m){var s=o.getComputedStyle(a[0].body);if("fixed"==s.position){var u=parseInt(s.height,10)+Math.abs(parseInt(s.top,10));l.css({height:u+"px"})}t.pin&&t.pin(l,n),i(function(){var t=l.parent()[0];if(t){var n=o.getComputedStyle(t);"static"==n.position&&r.warn(c)}e.inherit(l,l.parent())})}var c=" may not work properly in a scrolled, static-positioned parent container.";return{restrict:"E",link:d}}])}(),function(){function e(e){return{restrict:"E",link:function(t,n,o){e(n)}}}t.module("material.components.card",["material.core"]).directive("mdCard",e),e.$inject=["$mdTheming"]}(),function(){function e(e,n,o,r,i,a,d){function c(n,c){return c.type="checkbox",c.tabindex=c.tabindex||"0",n.attr("role",c.type),function(n,c,m,s){function u(e,t,o){m[e]&&n.$watch(m[e],function(e){o[e]&&c.attr(t,o[e])})}function p(e){var t=e.which||e.keyCode;(t===r.KEY_CODE.SPACE||t===r.KEY_CODE.ENTER)&&(e.preventDefault(),c.hasClass("md-focused")||c.addClass("md-focused"),f(e))}function f(e){c[0].hasAttribute("disabled")||n.$apply(function(){var t=m.ngChecked?m.checked:!s.$viewValue;s.$setViewValue(t,e&&e.type),s.$render()})}function h(){s.$viewValue?c.addClass(l):c.removeClass(l)}s=s||a.fakeNgModel(),i(c),m.ngChecked&&n.$watch(n.$eval.bind(n,m.ngChecked),s.$setViewValue.bind(s)),u("ngDisabled","tabindex",{"true":"-1","false":m.tabindex}),o.expectWithText(c,"aria-label"),e.link.pre(n,{on:t.noop,0:{}},m,[s]),n.mouseActive=!1,c.on("click",f).on("keypress",p).on("mousedown",function(){n.mouseActive=!0,d(function(){n.mouseActive=!1},100)}).on("focus",function(){n.mouseActive===!1&&c.addClass("md-focused")}).on("blur",function(){c.removeClass("md-focused")}),s.$render=h}}e=e[0];var l="md-checked";return{restrict:"E",transclude:!0,require:"?ngModel",priority:210,template:'
',compile:c}}t.module("material.components.checkbox",["material.core"]).directive("mdCheckbox",e),e.$inject=["inputDirective","$mdInkRipple","$mdAria","$mdConstant","$mdTheming","$mdUtil","$timeout"]}(),function(){function e(e){function t(e,t){this.$scope=e,this.$element=t}return{restrict:"E",controller:["$scope","$element",t],link:function(t,o,r){o[0];e(o),t.$broadcast("$mdContentLoaded",o),n(o[0])}}}function n(e){t.element(e).on("$md.pressdown",function(t){"t"===t.pointer.type&&(t.$materialScrollFixed||(t.$materialScrollFixed=!0,0===e.scrollTop?e.scrollTop=1:e.scrollHeight===e.scrollTop+e.offsetHeight&&(e.scrollTop-=1)))})}t.module("material.components.content",["material.core"]).directive("mdContent",e),e.$inject=["$mdTheming"]}(),function(){function e(e,n,o,r){function i(e){return t.isDefined(e.href)||t.isDefined(e.ngHref)||t.isDefined(e.ngLink)||t.isDefined(e.uiSref)}function a(e,t){return i(t)?'':''}function d(a,d,c){var l=d[0];n(d),e.attach(a,d);var m=l.textContent.trim();m||o.expect(d,"aria-label"),i(c)&&t.isDefined(c.ngDisabled)&&a.$watch(c.ngDisabled,function(e){d.attr("tabindex",e?-1:0)}),d.on("click",function(e){c.disabled===!0&&(e.preventDefault(),e.stopImmediatePropagation())}),a.mouseActive=!1,d.on("mousedown",function(){a.mouseActive=!0,r(function(){a.mouseActive=!1},100)}).on("focus",function(){a.mouseActive===!1&&d.addClass("md-focused")}).on("blur",function(){d.removeClass("md-focused")})}return{restrict:"EA",replace:!0,transclude:!0,template:a,link:d}}t.module("material.components.button",["material.core"]).directive("mdButton",e),e.$inject=["$mdButtonInkRipple","$mdTheming","$mdAria","$timeout"]}(),function(){function e(e){return{restrict:"E",link:e}}t.module("material.components.divider",["material.core"]).directive("mdDivider",e),e.$inject=["$mdTheming"]}(),function(){t.module("material.components.chips",["material.core","material.components.autocomplete"])}(),function(){function e(e,n){return{restrict:"E",link:function(o,r,i){n(r),e(function(){function e(){r.toggleClass("md-content-overflow",o.scrollHeight>o.clientHeight)}var n,o=r[0].querySelector("md-dialog-content");o&&(n=o.getElementsByTagName("img"),e(),t.element(n).on("load",e))})}}}function n(e){function n(e,t){return{template:['',' ','   
{{ dialog.title }}
',"   
{{ dialog.content }}
"," ",' 
','   ',"     {{ dialog.cancel }}","   ",'   ',"     {{ dialog.ok }}","   "," 
",""].join("").replace(/\s\s+/g,""),controller:function(){this.hide=function(){e.hide(!0)},this.abort=function(){e.cancel()}},controllerAs:"dialog",bindToController:!0,theme:t.defaultTheme()}}function o(e,n,o,r,i,a,d,c){function l(e,n,r){function i(){function e(){var e=n[0].querySelector(".dialog-close");if(!e){var o=n[0].querySelectorAll(".md-actions button");e=o[o.length-1]}return t.element(e)}if(r.focusOnOpen){var o="alert"===r.$type?n.find("md-dialog-content"):e();o.focus()}}return n=o.extractElementByName(n,"md-dialog"),t.element(a[0].body).addClass("md-dialog-is-showing"),s(n,r),f(n.find("md-dialog"),r),p(e,n,r),g(n,r).then(function(){u(n,r),h(n,r),i()})}function m(e,n,o){return o.deactivateListeners(),o.unlockScreenReader(),o.hideBackdrop(),E(n,o)["finally"](function(){t.element(a[0].body).removeClass("md-dialog-is-showing"),n.remove(),o.origin.focus()})}function s(e,n){var r={element:null,bounds:null,focus:t.noop};n.origin=t.extend({},r,n.origin||{});var i=t.element((n.targetEvent||{}).target);i&&i.length&&(n.origin.element=i,n.origin.bounds=i[0].getBoundingClientRect(),n.origin.focus=function(){i.focus()}),n.parent=t.element(n.parent||c),n.disableParentScroll&&(n.restoreScroll=o.disableScrollAround(e,n.parent))}function u(t,n){var i=[],a=function(){var t="alert"==n.$type?e.hide:e.cancel;o.nextTick(t,!0)};if(n.escapeToClose){var d=n.parent,c=function(e){e.keyCode===r.KEY_CODE.ESCAPE&&(e.stopPropagation(),e.preventDefault(),a())};t.on("keyup",c),d.on("keyup",c),i.push(function(){t.off("keyup",c),d.off("keyup",c)})}if(n.clickOutsideToClose){var d=t,l=function(e){e.target===d[0]&&(e.stopPropagation(),e.preventDefault(),a())};d.on("click",l),i.push(function(){d.off("click",l)})}n.deactivateListeners=function(){i.forEach(function(e){e()}),n.deactivateListeners=null}}function p(e,t,n){n.hasBackdrop&&(n.backdrop=o.createBackdrop(e,"md-dialog-backdrop md-opaque"),i.enter(n.backdrop,n.parent)),n.hideBackdrop=function(){n.backdrop&&i.leave(n.backdrop),n.disableParentScroll&&n.restoreScroll(),n.hideBackdrop=null}}function f(e,t){var r="alert"===t.$type?"alertdialog":"dialog",i=e.find("md-dialog-content"),a=e.attr("id")||"dialog_"+o.nextUid();e.attr({role:r,tabIndex:"-1"}),0===i.length&&(i=e),i.attr("id",a),e.attr("aria-describedby",a),t.ariaLabel?n.expect(e,"aria-label",t.ariaLabel):n.expectAsync(e,"aria-label",function(){var e=i.text().split(/\s+/);return e.length>3&&(e=e.slice(0,3).concat("...")),e.join(" ")})}function h(e,t){function n(e){for(;e.parentNode;){if(e===document.body)return;for(var t=e.parentNode.children,r=0;r'+e+"