GE Lua Documentation

  local headers = "frame,"
  for _, p in pairs(csvHeaders) do
    headers = headers .. escapeCSV(p) .. ","

  f:write(headers .. "\r\n")
  for k, v in pairs(telemetryData) do
    local s = k .. ","

    local s = k .. ","
    for _, p in pairs(csvHeaders) do
      s = s .. escapeCSV(v[p]) .. ","

  local control = controlModes[M.controlModeIndex].electrics
  for _, v in pairs(control) do
    local config = configurations[v]

  inputs = {}
  for _, v in pairs(config) do
    configurations[v.electric] = v

        generator = function(entries)
          for k, v in pairs(controlModes) do
            local entry = {

function C:_executionStarted()
  for _, p in pairs(self.pinOut) do
    p.value = false

  local strLinks = {}
  for _, lnk in pairs(self.graph.links) do
    if lnk.sourceNode == self then

  local outPins = {}
  for _, pn in pairs(self.pinOut) do
    if tableContains(self.oldOptions, pn.name) then

  end
  for _, pn in pairs(outPins) do
    self:removePin(pn)

  local inPins = {}
  for _, pn in pairs(self.pinInLocal) do
    if tableContains(self.oldOptions, pn.name) then

  end
  for _, pn in pairs(inPins) do
    self:removePin(pn)

function C:_executionStarted()
  for _, p in pairs(self.pinOut) do
    p.value = false

function C:buttonPushed(action)
  for nm, pn in pairs(self.pinOut) do
    self.pinOut[nm].value = nm == action

  end
  for _,pn in pairs(self.pinOut) do
    pn.value = false

}
for _, att in pairs(additionalAttributes) do
  att.valuesByKey = {}

  local bonusStarKeysCache = {}
  for key, act in pairs(mission.careerSetup.starsActive or {}) do
    if act then

  mission.careerSetup._activeStarCache.bonusStarCount = #bonusKeysSorted
  for key, list in pairs(mission.careerSetup.starRewards) do
    for _, reward in ipairs(list) do

  mission.careerSetup._activeStarCache.sortedStarRewardsByKey = {}
  for key, list in pairs(mission.careerSetup.starRewards) do
    local newList = {}

  -- update starRewards attributeKey for backwards compatibility
  for _, list in pairs(missionData.careerSetup.starRewards) do
    for _, reward in ipairs(list) do

  -- sort starReward entries by attributeKey
  for _, list in pairs(missionData.careerSetup.starRewards) do
    -- only order if there's at least 2 elements

  local isNonNumeric = false
  for idx, key in pairs(missionData.careerSetup.defaultStarKeys) do
    if type(idx) ~= "number" then

  missionData.recommendedAttributes = {}
  for k, v in pairs(missionData.recommendedAttributesKeyBasedCache or {}) do
    if v then

  if data.careerSetup.starRewards then
    for key, list in pairs(data.careerSetup.starRewards) do
      for _, reward in ipairs(list) do

          local missionConstructor = require(customPath)() -- gets it as if it was a module, then merges all non-init pairs
          for k, v in pairs(missionConstructor) do
            if k ~= "init" then

  local ret = {}
  for _, mission in pairs(missionsById) do
    if mission.missionType == type then

  if not M.vehicleData[vehId] then return end
  for key, value in pairs(data) do
    M.vehicleData[vehId].data[key] = value

  -- set out pins according to flags and reset flags
  for pName, val in pairs(self.flags) do
    self.pinOut[pName].value = val

  local vehiclesUsedPerStar = saveData.vehiclesUsedPerStar or {}
  for star, achieved in pairs(attempt.unlockedStars or {}) do
    if achieved then

  if mouseInfo.down then
    for idx, node in pairs(objects) do
      local tmpSpotAmount = 1

  local currScale = "Custom"
  for name, vehScale in pairs(psVehScales) do
    if self.current.scl == vehScale then

  if im.BeginCombo("##psScaleSelect", currScale) then
    for name, vehScale in pairs(psVehScales) do
      if im.Selectable1(name) then

        local list = groupBat:getObjects()
        for _,o in pairs(list) do
            local om = scenetree.findObjectById(tonumber(o))

        local list = fdata:getItems()
        for _,f in pairs(list) do
            editor.removeForestItem(fdata, f)

--		lo('??^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ onVal_gen_unique:'..tostring(pth)..':'..tableSize(amesh))
	for i,s in pairs(list) do
--			lo('?? for_file:'..i..':'..s)

	list = FS:findFiles(pth, '*.json', -1, true, false)
	for i,s in pairs(list) do
		FS:removeFile(s)

--		lo('?? onVal_gen_unique:'..tostring(pth)..':'..tableSize(amesh))
	for i,s in pairs(list) do
--			lo('?? for_file:'..i..':'..s)

		-- refresh static mmeshes
		for _,o in pairs(list) do
			local om = scenetree.findObjectById(tonumber(o))

	if true then
		for id,desc in pairs(adesc) do
			houseUp(nil, id)

				local ref = vec3(0,0,0)
				for i,v in pairs(am[1].verts) do
					local ang = U.vang(vec3(1,1,0),U.proj2D(v),true)

		local stamp
		for i,desc in pairs(adesc) do
			desc.selection = {}

--			desc.selection[2] = {1,6} --{1,3,2}
			for j,aw in pairs(desc.selection) do
				if not desc.aspline then desc.aspline = {} end --{aij={}} end

		for i,d in pairs(adesc) do
				d.selection = {}

				base = {}
				for j,aw in pairs(d.selection) do
					table.sort(aw)

					local isvalid = true
					for k,iw in pairs(aw) do
						if k>1 and aw[k]-aw[k-1]>1 then

				ref = vec3(0.0,0)
			for i,b in pairs(base) do
				base[i] = base[i]-ref

			lo('?? if_frst:'..tostring(#list))
		for _,o in pairs(list) do
			lo('?? if_ctx:'..tostring(o:getContextID())) --..tostring(o.ctxid)..':'..tostring(o.contextID)) --o:getContextID())

			lo('?? fdata:'..#list)
		for _,f in pairs(list) do
--			lo('?? for_it:'..tostring(f:getPosition()))

		-- {'b_22946.dae','b_22934.dae'}
		for _, nm in pairs(list) do
			if not scenetree.findObject(nm) then

		local dirname = editor.getLevelPath()..'bat/'
		for k,d in pairs(adesc) do
			local pth = dirname..'emat_2s.dae' -- 'emat_'..d.id..'.dae'

			if true then return end
		for k,d in pairs(adesc) do
				lo('?? for_DAE:'..k)

		local dirname = editor.getLevelPath()..'bat/'
		for k,d in pairs(adesc) do
				lo('?? for_DESC:'..tostring(d.id))

			lo('?? sdf:'..tostring(m.obj:getStaticDataFieldbyIndex(1, 1)))
		for k,f in pairs(fields) do
			lo('?? fof:'..tostring(k)..':'..tostring(f))

--			U.dump(m, '?? for_OBJ:')
--		for k,v in pairs(m.obj) do
--			lo('?? for_Key:'..tostring(k))

		for i,desc in pairs(adesc) do
			local ascan = W.buildingScan(desc, function(ascan)

			lo('??+++++++++++++++ if_TST:'..tostring(tst))
			for _,k in pairs(tst.kids) do
				lo('?? for_TST_KID:'.._..':'..tostring(k.type))

--			U.dump(nd_maingeo)
--			for _,k in pairs(nodevs.kids) do
--				lo('?? for_KID:'.._..':'..tostring(k.name))

    if false then
		for _,d in pairs(adesc) do
			W.buildingScan(d)

			lo('?? for_node:'..tostring(xml))
--		for i,k in pairs(xml.kids) do
--			lo(k.name)

--		for _,d in pairs(data) do
			if false then

--                lo('?? for_am:'..#adata)
			for i,d in pairs(adata) do
				-- set heights

			local mat
			for t,c in pairs({orange='1 0.5 0 1', green='0 1 0 1', blue='0 0 1 1',yellow='1 1 0 1'}) do
				mat = createObject("Material")

			local matFiles = FS:findFiles('/art/shapes/objects/', pref..'materials.json', -1, true, false)
			for _,f in pairs(afile) do
				matFiles[#matFiles+1] = f

			--    local list = {}
			for k,f in pairs(matFiles) do
					lo('?? for_mat_FILE:'..tostring(f))

--                loadJsonMaterialsFile(v)
--            for _,f in pairs(afile) do
				local desc = jsonReadFile(f)

				if desc then
					for k,v in pairs(desc) do
						local ind = U.index(amat, k)[1]

	local ref = base[1]
	for _,b in pairs(base) do
		av[#av+1] = b

	local af = {}
	for _,c in pairs(achunk) do
		af = M.zip(c, af)

	for _,e in pairs(out.fwhite) do
		e[1] = e[1] + vec3(-265,1148,1)

	if out.fyell then
		for _,e in pairs(out.fyell) do
			for i,n in pairs(e) do

		for _,e in pairs(out.fyell) do
			for i,n in pairs(e) do
				e[i] = e[i] + vec3(-265,1148,1)

	end
	for _,e in pairs(out.flbl) do
		e[1] = e[1] + vec3(-265,1148,1)

    for nodeId, tris in pairs(resultData.nodeTriPairs) do
      local node = nodes[nodeId]

      for triId, nodeTriData in pairs(tris) do
        local tri = triangles[triId]

  for k,v in pairs(vdata) do
    if type(v) == 'table' then

  table.clear(allWheelSlips)
  for k, v in pairs(throttleFactorData) do
    throttleFactors[k] = v.throttleFactor

    end
    for k, v in pairs(throttleFactorData) do
      v.integral = 0

    end
    for k, v in pairs(throttleFactorData) do
      v.integral = 0

  for _, v in pairs(throttleFactorData) do
    v.lastSlip = v.peakSlip

    end
    for _, v in pairs(throttleFactorData) do
      v.integral = 0

  local maxUsefulThrottleIntegral = (1 - currentESCConfiguration.minThrottleFactor) / currentESCConfiguration.throttleIntegralFactor
  for k, v in pairs(throttleFactorData) do
    local doUseTCS = (tcsThrottleMode == "reduce" and v.allWheelSlip > 0) and v.tcsActive

        generator = function(entries)
          for k, v in pairs(escConfigurations) do
            local entry = {

  local totalMass = 0
  for _, v in pairs(v.data.nodes) do
    tmp = tmp + vec3(v.pos) * v.nodeWeight

  local twRight = 0
  for _, n in pairs(v.data.nodes) do
    if n.cid == wheelCache[frontRightWheelId].node1 then

  for id, wd in pairs(wheels.wheels) do
    if actionedWheelLookup[wd.name] then

  throttleFactorData = {}
  for _, v in pairs(throttleFactorAssingment) do
    throttleFactorWheelLookup[v.wheelName] = v.throttleFactorName

  wheelIdCache = {}
  for k, _ in pairs(wheelCache) do
    table.insert(wheelIdCache, k)

  local tmpConfigs = {}
  for name, config in pairs(escConfigs.configurations) do
    if type(config) == "table" and config.escConfigurationEnabled then

  )
  for _, config in pairs(tmpConfigs) do
    escConfigurations[counter] = config

  for _, config in pairs(escConfigurations) do
    if type(config) == "table" and config.escConfigurationEnabled and config.characteristicSpeed <= 0 then --calculate char. speed if no override is provided

  if escConfigs.blacklistedEngines and type(escConfigs.blacklistedEngines) == "table" then
    for _, v in pairs(escConfigs.blacklistedEngines) do
      blacklistedEngines[v] = true

  revLimiterEngines = {}
  for _, v in pairs(engines) do
    --make sure the device supports temp rev limiters, otherwise we'll just run into issues

        }
        for _, c in pairs(v.configs) do
          if c["Top Speed"] and c["Top Speed"] > 10 then

function C:highlightLinks()
  for i, lnk in pairs(self.links) do
    lnk._highlight = true

    local widthCubics = {}
    for key, _ in pairs(laneKeys) do
      local k = laneKeys[key]

    local laneHOffsets = {}
    for key, _ in pairs(laneKeys) do
      local k = laneKeys[key]

  for k, v in pairs(wheelGroupControlData) do
    debugPacket.wheelGroups[k] = debugPacket.wheelGroups[k] or {}

  if controlParameters.tractionControl then
    for k, v in pairs(controlParameters.tractionControl.wheelGroupSettings) do
      debugPacket.tractionControl.wheelGroupControl[k] = debugPacket.tractionControl.wheelGroupControl[k] or {}

  if controlParameters.tractionControl then
    for k, _ in pairs(controlParameters.tractionControl.wheelGroupSettings) do
      wheelGroupControlData[k].tractionControlPID:reset()

  if controlParameters.tractionControl then
    for k, v in pairs(controlParameters.tractionControl.wheelGroupSettings) do
      wheelGroupControlData[k].slipThreshold = v.slipThreshold

    for _, setting in pairs(jbeamPIDSettings) do
      controlParameters.yawControl.PIDSettings[setting.type] = {

    controlParameters.yawControl.controlledMotorNames = {}
    for _, v in pairs(yawControlledMotors) do
      relevantMotorNames[v] = true

  for k, _ in pairs(relevantMotorNames) do
    table.insert(controlledMotors, k)

  for k, _ in pairs(wheelGroupControlData) do
    CMU.applyParameter(controlParameters, initialControlParameters, parameters, "tractionControl.wheelGroupSettings." .. k .. ".kP")

  local meshes = {}
  for _,m in pairs(basicBorders.getMeshes(segment))    do meshes[#meshes+1] = m end
  for _,m in pairs(basicCenters.getMeshes(segment))    do meshes[#meshes+1] = m end

  for _,m in pairs(basicBorders.getMeshes(segment))    do meshes[#meshes+1] = m end
  for _,m in pairs(basicCenters.getMeshes(segment))    do meshes[#meshes+1] = m end
  for _,m in pairs(borderWall.getMeshes(segment))      do meshes[#meshes+1] = m end

  for _,m in pairs(basicCenters.getMeshes(segment))    do meshes[#meshes+1] = m end
  for _,m in pairs(borderWall.getMeshes(segment))      do meshes[#meshes+1] = m end
  for _,m in pairs(ceilingMesh.getMeshes(segment))     do meshes[#meshes+1] = m end

  for _,m in pairs(borderWall.getMeshes(segment))      do meshes[#meshes+1] = m end
  for _,m in pairs(ceilingMesh.getMeshes(segment))     do meshes[#meshes+1] = m end

  minExistingGearCoordinateIndex = 0
  for _, coordinate in pairs(gearCoordinateTable) do
    gearCoordinates[coordinate.gearIndex] = coordinate.value

  for _itemKey, item in pairs(clusteredItems.itemsByKey) do
    local favouriteIdx = backend.isFavourite(item.key) or 0

  for _, item in pairs(clusteredItems.itemsByKey) do
    if item.type ~= "Freeroam Spawnpoint" then

  for _, item in pairs(clusteredItems.itemsByKey) do
    if firstMissionTypeLabel == nil and item.missionTypeLabel then

    local itemsList = {}
    for _, item in pairs(clusteredItems.itemsByKey) do
      table.insert(itemsList, item)

  local sourceIconsLookup = {}
  for _, item in pairs(clusteredItems.itemsByKey) do
    for _, source in pairs(item.sourceIcons or {}) do

  for _, item in pairs(clusteredItems.itemsByKey) do
    for _, source in pairs(item.sourceIcons or {}) do
      sourceIconsLookup[source.icon or source.svg] = true

  local sourceIcons = {}
  for source, active in pairs(sourceIconsLookup) do
    if string.endswith(source, ".svg") then

  local sourceIconsWithOrder, sourceIconsWithoutOrder = {}, {}
  for _, sourceIcon in pairs(sourceIcons) do
    if sourceIconsOrder[sourceIcon.icon or sourceIcon.svg] then

  local auxiliarySum = true
  for _, item in pairs(clusteredItems.itemsByKey) do
    auxiliarySum = auxiliarySum and item.isAuxiliary

  for _, item in pairs(items) do
    local group = clusterModeFunctions[clusterMode](item) or "Other..."

  coords2d = {}
  for k, p in pairs(coords3d) do
    coords2d[k] = vec3(p.x, p.y, 0.0)

  local ctr = 0
  for k, v in pairs(table) do
    if type(v) == 'table' then

local function doesCollectionContainSegment(collection, testSeg)
  for k, trialSeg in pairs(collection) do
    local matches = 0

    local matches = 0
    for k1, v1 in pairs(trialSeg) do
      for k2, v2 in pairs(testSeg) do

    for k1, v1 in pairs(trialSeg) do
      for k2, v2 in pairs(testSeg) do
        if v1 == v2 then

local function doesSegmentContainKey(currentPath, nextSuccessorKey)
  for k, v in pairs(currentPath) do
    if v == nextSuccessorKey then

  local keys = {}
  for key in pairs(tbl) do
    table.insert(keys, key)

  local ctr = 1
  for headKey, v1 in pairs(graph) do
    local firstChildren = getChildren(graph[headKey])

    -- Remove condition that filtered out nodes with 2 children
    for childKey, v2 in pairs(successors) do
      local currentPath = {}

        local allSuccessorsVisited = true
        for nextSuccessorKey, _ in pairs(nextSuccessors) do
          if not doesSegmentContainKey(currentPath, nextSuccessorKey) then

        local didFind = false
        for nextSuccessorKey, v3 in pairs(nextSuccessors) do
          if doesSegmentContainKey(currentPath, nextSuccessorKey) == false then

  local avgWidths = {}
  for k, seg in pairs(pathSegments) do
    local subTotal = 0.0

    local ctr = 0
    for i, key in pairs(seg) do
      subTotal = subTotal + widths[key]

  local ctr = 1
  for i, v in pairs(pathSegments) do
    -- Use the sorted iteration map to choose the segment processing order here.

  local ctr = 0
  for i, seg in pairs(pathSegments) do
    -- Test if the path segment's first node is a true junction (no dead ends). Only add if we haven't already found it previously.

local function updateConnectivityData()
  for k, r in pairs(roads) do

    local predecessor = 'none'
    for j, r2 in pairs(roads) do
      if k ~= j and r['start'] == r2['finish'] then

    local successor = 'none'
    for j, r2 in pairs(roads) do
      if k ~= j and r['finish'] == r2['start'] then

  local jCtr = 1
  for key, id in pairs(junctionMap) do
    local connectionRoads = {}

    local ctr = 1
    for rid, r in pairs(roads) do
      if key == r['start'] then

  -- Write the road data.
  for rid, r in pairs(roads) do

  -- Write the junction data, in order.
  for jid, j in pairs(junctions) do
    f:write('\n')

    local ctr = 0
    for i1, ra in pairs(j['connectionRoads']) do
      for i2, rb in pairs(j['connectionRoads']) do

    for i1, ra in pairs(j['connectionRoads']) do
      for i2, rb in pairs(j['connectionRoads']) do
        if i1 ~= i2 then

local startTriggersSorted = {}
for k, _ in pairs(startTriggerTypes) do table.insert(startTriggersSorted, k) end
table.sort(startTriggersSorted)

  local avgWheelNodePos, numOfWheels = vec3(), 0
  for _, wheel in pairs(wheels.wheels) do
    -- obj:getNodePosition is the pos vector of query node (wheel.node1) relative to ref node in world coordinates

  local avgBackWheelPos, backWheelCount = vec3(), 0
  for _, wheel in pairs(wheels.wheels) do
    local wheelPos = obj:getNodePosition(wheel.node1)

    else
      for k, v in pairs(mapmgr.objects) do
        if k ~= objectId then

    else
      for k, v in pairs(mapmgr.objects) do
        if k ~= objectId and v.active == true then

  local i = 0
  for id in pairs(mapmgr.getObjects()) do
    if id ~= objectId then

  local outEdgeDir, maxOutflow, minNode = vec3(), 0, nil
  for k, v in pairs(mapData.graph[wp2]) do
    if k ~= wp1 then

  for nodeId, edgeData in pairs(graph[newNode.id]) do
    if nodeId ~= newNode.nextNodeInPath and nodeId ~= prevNodeInPath then -- and not mapmgr.signalsData.nodes[newNode.id]

    local nextPosibleNode = nil
    for k, v in pairs(graph[newNode.id]) do
      if k ~= newNode.prevNodeInPath then

  table.clear(traffic.trafficTable)
  for plID, v in pairs(mapmgr.getObjects()) do
    if plID ~= objectId and (M.mode ~= 'chase' or plID ~= player.id or internalState.chaseData.playerState == 'stopped') then

  for plID, v in pairs(mapmgr.getObjects()) do
    if plID ~= objectId and (M.mode ~= 'chase' or plID ~= player.id or internalState.chaseData.playerState == 'stopped') then

    edgeDict = {}
    for nid, n in pairs(mapData.graph) do
      if currentSCC[nid] or not opt.driveInLaneFlag then

      if currentSCC[nid] or not opt.driveInLaneFlag then
        for lid, data in pairs(n) do
          if (currentSCC[lid] or not opt.driveInLaneFlag) and (data.drivability > cutOffDrivability) then

  for plID, v in pairs(mapmgr.getObjects()) do
    if plID ~= objectId and v.states then

          -- Check if there's a vehicle next to this one
          for otherID, v in pairs(mapmgr.getObjects()) do
            if otherID ~= objectId and v.pos and otherID ~= trafficStates.action.nearestPoliceId and v.dirVec and v.dirVec:dot(ego.dirVec) < 0 then

          if not giveWay and drivability < 1 then
            for _, edgeData in pairs(mapData.graph[nid1]) do
              if edgeData.drivability > drivability then

            if prevNode and tableSize(mapData.graph[nid1]) == 3 then
              for k, v in pairs(mapData.graph[nid1]) do
                if k ~= prevNode and k ~= nid2 then

            local distToJcenter = tSi.turnNode and ego.pos:distance(mapData.positions[tSi.turnNode]) or 1
            for vId, v in pairs(mapmgr.getObjects()) do
              if vId ~= objectId then

            -- get most distant non walked edge
            for k, v in pairs(edgeDict) do
              if v <= lim then

        local nodeDegree = 1
        for lid, _ in pairs(mapData.graph[target]) do
          -- we're looking for neighboring nodes other than the targetLink

      for vehId in pairs(mapmgr.getObjects()) do
        if vehId ~= objectId then

      for _, d in pairs(visDebug.debugSpots) do
        debugDrawer:drawSphere(0.2, d[1], d[2])

    if dt then
      for k, v in pairs(mapmgr.getObjects()) do
        if k ~= objectId then

    debugDrawer:drawSphere(0.1, refNodePos, color(255,0,0,255))
    for _, wheel in pairs(wheels.wheels) do
      local wheelRadius = wheel.radius

    if not b then
        for k,v in pairs(self.channels) do
            self.channels[k] = nil

    local data = { }
    for id, btn in pairs(self.buttons) do
      if btn.active.value then

  self.buttonsChanged = nil
  for id, btn in pairs(self.buttons) do
    self.variables:change(id.."clicked", false)

  local notFound = 0
  for name, value in pairs(missionTypeData) do
    if mgr.variables:variableExists(name) then

  local namesCounter = {}
  for _, filename in pairs(camPathFiles) do
    local path = loadPath(filename)

local types = {}
for type, color in pairs(typeColors) do
  types[type] = { ['color'] = color }

-- some style setup
for g, info in pairs(graphTypes) do
  info.tabColor = info.tabColor or lerpVec4(info.color, im.ImVec4(1, 1, 1, 1), 0.4)

    local sortedConfigs = { }
    for k, v in pairs(self.configs) do
      table.insert(sortedConfigs, { key = k, value = v })

            local sortedConfigs = { }
            for k, v in pairs(self.configs) do
              table.insert(sortedConfigs, { key = k, value = v })

                local sortedConfigs = { }
                for k, v in pairs(self.configs) do
                  table.insert(sortedConfigs, { key = k, value = v })

      for mIdx, m in ipairs(self.models) do
        for cIdx, c in pairs(core_vehicles.getModel(m.key).configs) do
          vehSearch:queryElement({

              local sortedConfigs = { }
              for k, v in pairs(self.configs) do
                table.insert(sortedConfigs, { key = k, value = v })

  for k, _ in pairs(triggers[key].objects) do
    if scenetree.findObject(k) then

  for k, v in pairs(triggers[key].objects) do
    local obj = scenetree.findObject(k)

    triggers[key].objects = {}
    for k, v in pairs(data.objects) do
      triggers[key].objects[k] = {

  if useOrigState then
    for k, v in pairs(triggers) do
      removeTrigger(k, useOrigState)

  for k, v in pairs(data) do
    addTrigger(k, v)

  if not active then
    for _, vState in pairs(trigger.vehIds) do
      if vState then

    if trigger.objects then
      for _, objData in pairs(trigger.objects) do
        objData.timer = 0

  for k, v in pairs(triggers) do
    if v.type == 'zone' and zones.byName[k] and not v.vehIds[0] then -- veh id of 0 blocks detection

  for k, v in pairs(triggers) do
    if v.vehIds and isVehicleValid(k, newId) then

  for k, v in pairs(triggers) do
    if v.vehIds then

  local zoneExists = false
  for k, v in pairs(triggers) do
    if v.type == 'zone' then

    if v.objects then
      for name, data in pairs(v.objects) do
        local obj = scenetree.objectExists(name)

  local needAll = false
  for _, sub in pairs(subscribers) do
    if sub.all then

    local vehicles = getAllVehicles()
    for _, veh in pairs(vehicles) do
      table.insert(vehicleData, getVehicleData(veh))

    -- Only fetch specific IDs
    for _, sub in pairs(subscribers) do
      if sub.vid then

  -- Send appropriate data to each subscriber
  for peerId, sub in pairs(subscribers) do
    local dataToSend = {}

local function updateGFX(dtSim)
  for sensorId, _ in pairs(powertrains) do
    updatePowertrainGFXStep(dtSim, sensorId, false, nil)

local function onVehicleDestroyed(vid)
  for sensorId, _ in pairs(powertrains) do
    if vid == objectId then

  local out = {}
  for id, tr in pairs(trajectories) do
    out[id] = ptr2ValTraj(tr)

  table.clear(trajectories)
  for id, tr in pairs(data) do
    trajectories[id] = val2PtrTraj(tr)

local function detachTrajectory(str)
  for k, tr in pairs(trajectories) do
    if tr.vehicle == str then

  local polyLinesToExecute = {}                                                   -- First, format all the trajectories so they can be run by the scriptAI backend.
  for k, tr in pairs(trajectories) do
    if tr.vehicle ~= "" and tr.vid ~= nil then

  end
  for vid, p in pairs(polyLinesToExecute) do                                      -- Execute all the vehicle trajectories using the scriptAI backend.
    scenetree.findObject(vid):queueLuaCommand('ai.startFollowing(' .. serialize(p) .. ')')

local function stopExecute()
  for k, tr in pairs(trajectories) do                                             -- Stop executing all the vehicle scripts.
    local vid = tr.vid

      local vehicles, numTrajectories, numVehicles = data.vehicles, 0, 0        -- Compute valid starting positions for all the vehicles which are to be spawned.
      for k, tr in pairs(trajectories) do
        numTrajectories = numTrajectories + 1

      end
      for k, tr in pairs(vehicles) do
        numVehicles = numVehicles + 1

        local ctr = 1
        for k, tr in pairs(trajectories) do
          local polyLine = tr.polyLine

      local ctr = 1                                                             -- Spawn all the vehicles which are required.
      for k, data in pairs(vehicles) do
        local _ = core_vehicles.spawnNewVehicle(data.jBeam, { pos = spawnPositions[ctr], config = data.config })

      local alreadyAttachedVehicles = {}
      for id, tr in pairs(trajectories) do
        local vehicle = tr.vehicle

  end
  for k, v in pairs(d.ratios) do                                                -- Project each time position to the mouse-controlled interval.
    if k ~= lLock and k ~= uLock then

  local isHovered = false
  for k, tr in pairs(trajectories) do
    local boxData = tr.boxData

  local dClosest, trClosest, nClosest = 1e30, nil, nil
  for id, tr in pairs(trajectories) do
    if tr.isDisplay[0] == true then

  -- Iterate over the full array of trajectories and ignore those which are not marked for display.
  for k, tr in pairs(trajectories) do
    local c = tr.col

  local numTrajectories = 0
  for k, tr in pairs(trajectories) do
    numTrajectories = numTrajectories + 1

    toolWinData.tStart, toolWinData.tEnd = 0.0, 0.0
    for k, tr in pairs(trajectories) do
      local polyLine = getPolyRef(tr)

      if editor.uiIconImageButton(editor.icons.watch_later, im.ImVec2(28, 28), nil, nil, nil, 'normalizeTrajectory') then
        for k, tr in pairs(trajectories) do
          local poly = getPolyRef(tr)

      local vehicleAttachState = "[not attached]"
      for k, tr in pairs(trajectories) do
        if tr.vehicle ~= nil and tr.vehicle == vehicle.string then

            table.remove(sceneVehicles, i)
            for tIdx, tr in pairs(trajectories) do
              if tr.vid == selectedVehicle.vid then

            local idx = nil
            for k, tr in pairs(trajectories) do
              if vehicle.vid == tr.vid then

      if im.BeginListBox("", im.ImVec2(170, 180), im.WindowFlags_ChildWindow) then
        for k, tr in pairs(trajectories) do
          im.Columns(3, "columns3", false)

  local numTrajectories = 0
  for k, tr in pairs(trajectories) do
    numTrajectories = numTrajectories + 1

  end
  for k, tr in pairs(trajectories) do
    if tr.vid == vid then

  if imgui.BeginPopup(label) then
    for k, item in pairs(items) do
      local lbl = item.label .. "###" .. label .. tostring(k)

  if imgui.BeginPopup(label) then
    for k, item in pairs(items) do
      local curX = imgui.GetCursorPosX()

  if imgui.BeginPopup(label.."rmb") then
    for k, item in pairs(itemsRMB) do
      if imgui.SmallButton(item.label.."##") then

  if imgui.BeginPopup(label) then
    for k, item in pairs(items) do
      if excludeCurrent then

  if tbl then
    for k,v in pairs(tbl) do
      if type(v) ~= 'table' then

  local tableType = 0
  for _, tv in pairs(t) do
    if type(tv) == 'table' then

  local sortedKeys = {}
  for k in pairs(t) do table.insert(sortedKeys, k) end
  table.sort(sortedKeys)

function C:checkCollisions() -- checks for contact with other tracked vehicles
  for id, veh in pairs(map.objects) do
    if self.id ~= id then

            for otherId, otherVeh in pairs(gameplay_traffic.getTrafficData()) do -- notify other traffic vehicles of collision
              if not otherVeh.otherCollisionFlag and otherId ~= self.id and otherId ~= id then

  for id, coll in pairs(self.collisions) do
    local veh = gameplay_traffic.getTrafficData()[id]

    for id, veh in pairs(gameplay_traffic.getTrafficData()) do
      if id ~= self.id then

      for id, _ in pairs(self.collisions) do
        self:trackCollision(id, dtSim)

    -- queued functions
    for k, v in pairs(self.queuedFuncs) do
      if not v.timer then v.timer = 0 end

  --[[
    for _, node in pairs(v.data.nodes) do
        print("node = " .. tostring(node.cid) .. ' > ' .. tostring(forceVec))

function C:hasFoldersOnly(dir)
  for k,v in pairs(dir) do
    if type(v) == 'table' then

      local sorted = {}
      for dir, v in pairs(self.filteredTemplates) do if not v.isEmpty then table.insert(sorted,dir) end end
      table.sort(sorted)

        if im.TreeNodeEx1("Project Variables") then
          for _, nm  in pairs(self.mgr.variables.sortedVariableNames) do
            local var = self.mgr.variables:getFull(nm)

        if im.TreeNodeEx1("Graph Variables") then
          for _, nm  in pairs(self.mgr.graph.variables.sortedVariableNames) do
            local var = self.mgr.graph.variables:getFull(nm)

          self:refreshMacro()
          for mn,data in pairs(self.filteredMacro) do
            self:displayMacro(mn,data,menuPos)

    if parent then
      for _, nd in pairs(parent.nodes) do
        if nd:representsGraph() and nd:representsGraph().id == self.mgr.graph.id then

        if nd:representsGraph() and nd:representsGraph().id == self.mgr.graph.id then
          for _, pin in pairs(nd.pinOut) do
            table.insert(exits, pin.name)

      local sorted = {}
      for dir, v in pairs(self.filteredTemplates) do if not v.isEmpty then table.insert(sorted,dir) end end
      table.sort(sorted)

  local _, flat = core_flowgraphManager.getAvailableNodeTemplates()
  for path, info in pairs(flat) do
    if not info.node.hidden and self:pinsFilter(info) and (editor.getPreference("flowgraph.general.showObsoleteNodes") or not info.node.obsolete) then

function C:findVar(source, sourceName, sourceNameTag)
  for _, nm  in pairs(source.sortedVariableNames) do
    local var = source:getFull(nm)

  local _, flat = core_flowgraphManager.getAvailableStateTemplates()
  for path, info in pairs(flat) do
    self.search:queryElement({

  if parent then
    for _, nd in pairs(parent.nodes) do
      if nd:representsGraph() and nd:representsGraph().id == self.mgr.graph.id then

      if nd:representsGraph() and nd:representsGraph().id == self.mgr.graph.id then
        for _, pin in pairs(nd.pinOut) do
          table.insert(exits, pin.name)

  for k,v in pairs(dir) do
    if k == mode then

    if k == mode then
      for nName, nVal in pairs(v) do
        local passedNameFilter = true--self:namesFilter(nVal, mode)

  local dirs = {}
  for n, d in pairs(dir) do
    if n ~= mode then

  local res = nil
  for k,v in pairs(dir) do
    local passedNameFilter = true--self:macroNameFilter(k)

    self.stateTemplatesSorted = {}
    for name, s in pairs(self.stateTemplates) do
      table.insert(self.stateTemplatesSorted, name)

    self.filteredFolders = {}
    for k,v in pairs(templates) do
      local nd = self:filterNodes(v, filterPins, mode)

    end
    for name, dir in pairs(self.filteredTemplates) do
      if name ~= mode then

  -- display subfolder tree nodes
  for dirName, dirVal in pairs(dir) do
    if dirName ~= elementFieldName and dirName ~= 'isEmpty' then

  if dir[elementFieldName] then
    for elemName, elem in pairs(dir[elementFieldName]) do
      elementFunction(self, dir, menuPos, elemName, elem)

      local p = nil
      for _, pin in pairs(node.pinOut) do
        p = pin

        local availablePins = {}
        for _, pin in pairs(n.pinInLocal) do
          if self.mgr.graph:canCreateLink(self.newNodeLinkPin, pin) then

        local availablePins = {}
        for _, pin in pairs(n.pinOut) do
          if self.mgr.graph:canCreateLink(pin, self.newNodeLinkPin) then

  local pins = {names = {}, pins = {}}
  for dir, list in pairs(self.mgr:getAvailableNodeTemplates()) do
    self:recursiveGetTags(list, tags, pins)

  table.insert(libtxt, header)
  for dir, list in pairs(self.mgr:getAvailableNodeTemplates()) do
    self:printDir(list, dir, tags, libtxt)

  for nName, node in pairs(dir.nodes) do
    local vals = {}

  end
    for dName, dir in pairs(dir) do
    if dName ~= 'nodes' then

function C:recursiveGetTags(dir, list, pins)
  for dName, c in pairs(dir) do
    if dName ~= 'nodes' then

  end
  for nName, node in pairs(dir.nodes) do
    -- manage Tags

    -- manage Tags
    for _, tag in pairs(node.node.tags or {} ) do
      if arrayFindValueIndex(list, tag) == false then

function C:_executionStarted()
  for _, p in pairs(self.pinOut) do
    p.value = false

  local strLinks = {}
  for _, lnk in pairs(self.graph.links) do
    if lnk.sourceNode == self and tableContains(self.oldOptions, lnk.sourcePin.name) then

  local outPins = {}
  for _, pn in pairs(self.pinOut) do
    if tableContains(self.oldOptions, pn.name) then

  end
  for _, pn in pairs(outPins) do
    self:removePin(pn)

  local inPins = {}
  for _, pn in pairs(self.pinInLocal) do
    local contained = false

  end
  for _, pn in pairs(inPins) do
    self:removePin(pn)

function C:buttonPushed(action)
  for nm, pn in pairs(self.pinOut) do
    if nm == action then

      canPayFee = true
      for key, value in pairs(entryFee) do
        hasEntryFee = hasEntryFee or value > 0

function C:onNodeReset()
  for _,pn in pairs(self.pinOut) do
    pn.value = false

local function renderPickedJBeamObjs()
  for k, node in pairs(pickedNodes) do
    local nodeID = node.cid

  for k, beam in pairs(pickedBeams) do
    local dispText = getBeamDisplayText(beam)

        if im.BeginCombo("##beamTypesCombobox", "Set beam types to pick...", im.ComboFlags_HeightLarge) then
          for k, enabled in pairs(beamTypesRendering) do
            local beamType = beamTypesNames[k]

  -- Populate beamTypesRendering table
  for k,v in pairs(beamTypesNames) do
    beamTypesRendering[k] = im.BoolPtr(true)

  end
  for k, v in pairs(vehicle.beams) do
    if type(v) == "table" and type(v.id1) == "number" and type(v.id2) == "number" and v.id1 > v.id2 then

  -- recurse
  for k, v in pairs(d) do
    if type(v) == 'string' and v == '' and k ~= 'mesh' then -- 'mesh' is a hack to prevent from cleaning flexbody.mesh values. Backward compatibility

  if vehicle.nodes then
    for _, n in pairs(vehicle.nodes) do
      if n.collision == true then n.collision = nil end -- the default

  if vehicle.beams then
    for _, b in pairs(vehicle.beams) do
      if b.beamType == 0 then b.beamType = nil end -- the default

  if vehicle.triangles then
    for _, t in pairs(vehicle.triangles) do
      t.cid = nil

  if vehicle.hydros then
    for _, hydro in pairs(vehicle.hydros) do
      hydro.beamCID = hydro.beam.cid

  if vehicle.wheels then
    for _, wheel in pairs(vehicle.wheels) do
      if wheel.sideBeams then

      if wheel.sideBeams then
        for k, b in pairs(wheel.sideBeams) do
          wheel.sideBeams[k] = b.cid

      if wheel.rimBeams then
        for k, b in pairs(wheel.rimBeams) do
          wheel.rimBeams[k] = b.cid

      if wheel.peripheryBeams then
        for k, b in pairs(wheel.peripheryBeams) do
          wheel.peripheryBeams[k] = b.cid

      if wheel.treadBeams then
        for k, b in pairs(wheel.treadBeams) do
          wheel.treadBeams[k] = b.cid

      if wheel.reinfBeams then
        for k, b in pairs(wheel.reinfBeams) do
          wheel.reinfBeams[k] = b.cid

      if wheel.pressuredBeams then
        for k, b in pairs(wheel.pressuredBeams) do
          wheel.pressuredBeams[k] = b.cid

      if wheel.treadNodes then
        for k, tn in pairs(wheel.treadNodes) do
          wheel.treadNodes[k] = tn.cid

      if wheel.nodes then
        for k, tn in pairs(wheel.nodes) do
          wheel.nodes[k] = type(tn) == 'table' and tn.cid or tn

  -- removing disabled sections
  for keyEntry, entry in pairs(vehicle) do
    if type(entry) == "table" and tableIsDict(entry) and jbeamUtils.ignoreSections[keyEntry] == nil and tableIsDict(entry[0]) and entry[0]['disableSection'] ~= nil then

        // Set-Cookie:  =  ( ";" SP  )*?
        // NOTE: Some attributes can have pairs (e.g. "Path=/"), some are only a
        // single word (e.g. "Secure").

  --dump(configData)
  for k, v in pairs(jbeamData) do
    if k:sub(1, #"configuration_") == "configuration_" then

    for key, val in pairs(aggregate) do
      if self.pinOut[key] then

  local validAps = {}
  for name, ap in pairs(accessPointsByName) do
    if ap[typeLookupKey] and ap[typeLookupKey][logisticType] then

    log("E","","Could not find any access point with logisticType " .. logisticType .. " in this list via " .. typeLookupKey)
    for name, ap in pairs(accessPointsByName) do
      print(name .. " -> " .. dumps(ap[typeLookupKey]))

    for _,file in ipairs(files) do
      for k, v in pairs(jsonReadFile(file) or {}) do
        local item = v

                if f.logisticTypesReceivedLookup[template.logisticType] then
                  for name, ap in pairs(f.accessPointsByName) do
                    if ap.logisticTypesReceivedLookup[template.logisticType] then

    for _,file in ipairs(files) do
      for id, filter in pairs(jsonReadFile(file) or {}) do
        filter.id = id

    for _,file in ipairs(files) do
      for id, data in pairs(jsonReadFile(file) or {}) do
        data.id = id

  local facLocation = {type = "facilityParkingspot", facId = fac.id, psPath = fac.dropOffSpots[1]:getPath()}
  for materialType, storage in pairs(fac.materialStorages) do
    if storage.isReceiver then

    local facLocation = {type = "facilityParkingspot", facId = fac.id, psPath = fac.pickUpS pots[1]:getPath()}
    for materialType, storage in pairs(fac.materialStorages) do
      if storage.isProvider then

      --dump(fac.logisticTypeLookup)
      for key, _ in pairs(generator.logisticTypesLookup) do
        match = match or item.logisticType == key

        --local systems = generatorToSystem[generator.type](generator)
        --for sys, _ in pairs(systems) do
        --  fac[dir][sys] = true

      for name, ap in pairs(accessPointsByName) do
        ap.name = name

        allTypes[type] = true
        for sys, en in pairs(logisticTypeToSystem(type, fac)) do
          if en then

        allTypes[type] = true
        for sys, en in pairs(logisticTypeToSystem(type, fac)) do
          if en then

    copy = {}
    for orig_key, orig_value in pairs(orig) do
      copy[orig_key] = orig_value

  if segment.noPoints then return end
  for name, index in pairs(segment.submeshIndexes) do
    segment.mesh:setMaterial(index, segment.selected and 'track_editor_grid' or segment.materialInfo[name])

      pieces[index].materialInfo = {}
      for key, val in pairs(pieceBefore.materialInfo) do
        pieces[index].materialInfo[key] = val

      end
      for key, val in pairs(p.materialInfo) do
      if not export.materials[s] then export.materials[s] = {} end

    for s,subMats in ipairs(import.materials) do
      for field, mats in pairs(subMats) do
        for mat, list in pairs(mats) do

      for field, mats in pairs(subMats) do
        for mat, list in pairs(mats) do
          for _, index in pairs(list) do

        for mat, list in pairs(mats) do
          for _, index in pairs(list) do
            subPieces[s][index].materialInfo[field] = mat

  local objects = {}
  for objId, _ in pairs(map.objects) do
    local object = getObjectByID(objId)

  local playerWasInvolved = false
  for vehId, _ in pairs(crashEndData.sanitizedData.touchedVehIds) do
    if vehId == currentStepParameters.plVehId then

      --  self.search:setSameScoreResolvingFunction(sortFun)
      for idx, col in pairs(columns) do
        search:queryElement({

      for _, group in ipairs({"osInfo","cpuInfo","gpuInfo","buildInfo","settingsInfo"}) do
        for key, _ in pairs(allFiles[1][group]) do
          table.insert(columns, {keys = {group, key}, enabled = false})

  local res
  for nid, _ in pairs(nodes) do
    if distances[nid] < min or not res then

  -- remove all nodes that are too far away
  for otherNid, data in pairs(mapNodes) do
    if data.pos:squaredDistance(node.pos) > square(maxConnectionRenderDistance) then

      -- remove the links
      for otherNid2, _ in pairs(data.links) do
        if nodesToCheck[otherNid2] then

    for neighbor, otherLinkData in pairs(nextNodeData.links) do
      if nodesToCheck[neighbor] and otherLinkData.inNode == nextNid then

  -- Add distances to the links that are close enough, but not on any shortest route from any node
  for otherNid, data in pairs(mapNodes) do
    if distancesOfLinks[otherNid] then

    if distancesOfLinks[otherNid] then
      for neighbor, linkData in pairs(data.links) do
        if distancesOfLinks[neighbor] and not distancesOfLinks[otherNid][neighbor] then

  -- map.nodes is single sided i.e. edge between nodes a, b is either in map.nodes[a].links[b] or map.nodes[b].links[a] but not both
  for lid, data in pairs(n.links) do
    if mapNodes[lid] then

      if mapNodes then
        for nid, n in pairs(mapNodes) do
          local nPos = n.pos

        for otherNid, link in pairs(node.links) do
          if link.inNode == nid then

  drawMode = nil
  for k, v in pairs(drawModes) do
    if v then drawMode = k end

  if enabled then
    for k, v in pairs(drawModes) do
      drawModes[k] = false

  M.textures = {}
  for tag, taggedTextures in pairs(taggedTextures) do
    local categorizedTextures = {

    for key, file in pairs(taggedTextures) do
      local _, filename, _ = path.split(file)

  local objects = {}
  for objId, _ in pairs(map.objects) do
    local object = getObjectByID(objId)

  if not dragData or not dragData.racers then return end
  for _, racer in pairs(dragData.racers) do
    racer.timersStarted = false

    racer.timersStarted = false
    for timerId,t in pairs(racer.timers) do
      if t.type ~= "dialTimer" then

  if not dragData or not dragData.racers or dragData.isCompleted then return end
  for _, racer in pairs(dragData.racers) do
    if not racer.timersStarted then goto continue end

      for timerName, timer in pairs(timers) do
        if addFrameHistoryDebug[timerName] and not timer.isSet and timer.type == "distanceTimer" then

            timer.frameHistory[#timer.frameHistory+1] = string.format("Racer: %d Went over threshold at %0.5fs (%d%% of this frames duration plus the previous frames) (so between frame %d and %d)", racer.vehId, timer.value, t*100, #timer.frameHistory-1, #timer.frameHistory)
            -- for _, frame in pairs(timer.frameHistory) do
            -- end

  if debugData.completedPathnodes then
    for _ in pairs(debugData.completedPathnodes) do
      debugData.completedCount = debugData.completedCount + 1

    if allStates then
      for crawlerId, state in pairs(allStates) do
        if state and state.active then

  local t = { lines = {} }
  for k,v in pairs(Dumper) do t[k] = v end

        local txt = "{"
        for k,v in pairs(value) do
          txt = txt..safe_tostring(k)..":"..safe_tostring(v)

        end
        --for k,v in pairs(info) do print(k,v) end
        fun_name = fun_name or GuessFunctionName(info)

    local first = true
    for k,v in pairs(message) do
      if first then

      --print(info.namewhat, info.name)
      --for k,v in pairs(info) do print(k,v, type(v)) end
      local function_name = m_user_known_functions[info.func] or m_known_functions[info.func] or info.name or tostring(info.func)

      --print("tail")
      --for k,v in pairs(info) do print(k,v, type(v)) end--print(info.namewhat, info.name)
      dumper:add_f("\n(%d) tail call", level_to_show)

      if not function_name or function_name == "?" then
        --for k,v in pairs(info) do print(k,v, type(v)) end
        function_name = GuessFunctionName(info)

    local first = true
    for k,v in pairs(message) do
      if first then

      --print(info.namewhat, info.name)
      --for k,v in pairs(info) do print(k,v, type(v)) end
      local function_name = m_user_known_functions[info.func] or m_known_functions[info.func] or info.name or tostring(info.func)

      --print("tail")
      --for k,v in pairs(info) do print(k,v, type(v)) end--print(info.namewhat, info.name)
      dumper:add_f("(%d) tail call\n", level_to_show)

      if not function_name or function_name == "?" then
        --for k,v in pairs(info) do print(k,v, type(v)) end
        function_name = GuessFunctionName(info)

  local knownProblems = {hydrodnamicFriction='hydrodynamicFriction', flowBehaviourIndex='flowBehaviorIndex'}
  for j, _ in pairs(v) do
    if knownProblems[j] then

  local newGms = {}
  for k, v in pairs(gms) do
    if string.len(k) > 31 then

  local sortedGmNames = {}
  for k, v in pairs(gms) do
    if k ~= 'ASPHALT' then

    -- filter paths to only return filename without extension
    for _,fn in pairs(files) do
      tableMerge(allGroundModels, loadGroundModelFile(fn));

local function onFilesChanged(files)
  for _,v in pairs(files) do
    local filename = v.filename

      filename = string.upper(filename)
      for _, f in pairs(M.loadedGroundModelFiles) do
        if string.upper(f) == filename then

local function onClientEndMission()
  for k,v in pairs(myTexture) do
    myTexture[k] = nil

local function hide()
  for _, m in pairs(idToMarker) do
    m:hide()

local function show()
  for _, m in pairs(idToMarker) do
    m:show()

  --if not markers[name] then return end
  for id, marker in pairs(markers[name] or {}) do
    marker:clearMarkers()

   -- blend all markers.
  for _, m in pairs(idToMarker) do
    m:update(dt, dtSim)

local function setModes(wpModes)
  for name, marker in pairs(markers[markerListName] or {}) do
    marker:setMode(wpModes[name] or 'hidden')

local function setToCheckpoints(data)
  for name, marker in pairs(markers[markerListName] or {}) do
    if data[name] then

local function drawOnMinimap(td)
  for _, marker in pairs(markers[markerListName] or {}) do
    if marker.drawOnMinimap then

  while mt ~= nil do
    for k, v in pairs(rawget(mt, 1)) do
      workgetters[k] = workgetters[k] or v

    for k, v in pairs(rawget(mt, 2)) do
      worksetters[k] = worksetters[k] or v

    for k, v in pairs(mt) do
      if type(k) == "string" then

  if luaVMname ~= 'vlua' then
    for k, classtable in pairs(classes) do
      -- search for SimObject's metatables

  for k, v in pairs(classes) do
    -- optimize metatables

        if rawget(v, '__newindex') == nil then
          for f, getter in pairs(v) do
            if type(f) ~= 'number' then

        else
          for f, getter in pairs(v) do
            if type(f) ~= 'number' then

    acc[#acc+1] = "{\n"
    for k, v in pairs( tbl ) do
        local str_indent = 1

    local res = {}
    for k,v in pairs(t1) do
        res[k] = {v, t2[k]}

    end
    for k,v in pairs(t2) do
        if res[k] == nil then

    for i = 1, select('#', ...) do
        for k,v in pairs((select(i, ...))) do
            destination[k] = v

    local function checkpatterns(g)
        for k,v in pairs(g.aux) do
            if not LL_ispattern(v) then

function add_elements(a, res)
    for k in pairs(a) do res[k] = true end
    return res

         , (type(b) == "number") and set_new{b} or b
    for el in pairs(a) do
        if a[el] and not b[el] then

    local list = {}
    for el in pairs(s) do
        t_insert(list,el)

        print(offset..prefix.."Grammar")
        for k, pt in pairs(pt.aux) do
            local prefix = ( type(k)~="string"

if Builder.proxymt then
    for k, v in pairs(LL) do
        if k:match"^__" then

function C:buttonPushed(action)
  for nm, pn in pairs(self.pinOut) do
    self.pinOut[nm].value = nm == action

  local filteredFiles = {}
  for i, file in pairs(files) do -- this is a more fine-grained filter to preserve files with similar capture names
    local _, filename = path.split(file)

  elseif t == 'table' then
    for k, v in pairs(data) do
      data[k] = convertBinaryDataToString(v)

  local requestData = {}
  for key, value in pairs(request) do
    if key ~= 'skt' and key ~= 'handled' then

for _, discover in pairs(freeroamExperiences) do
  table.insert(D.pageInfo.sections[1].discoverIds, discover.id)

table.insert(D.pageInfo.sections[1].discoverIds, "johnson_valley")
for _, mission in pairs(missions) do
  table.insert(D.pageInfo.sections[2].discoverIds, mission.id)

    -- add all successors of successors to a list and render them
    for _, from in pairs(nextWps) do
      for i, s in pairs(M.state.branchGraph[from.branch][from.index].successors) do

    for _, from in pairs(nextWps) do
      for i, s in pairs(M.state.branchGraph[from.branch][from.index].successors) do
        if not (M.state.branchGraph[from.branch][from.index].isFinalWaypoint and not (w.lap + 1 < scenario.lapCount or scenario.lapCount == 0)) then

  -- insert successors into graph
  for _,f in pairs(from) do
    -- if the branch does nt exist, create it

    end
    for _,t in pairs(to) do
     -- check if successor already exists

      local existing = false
      for _,s in pairs(M.state.branchGraph[f.branch][f.index].successors) do
        if s.index == t.index and s.branch == t.branch then

  local paths = {}
  for name, branch in pairs(scenario.lapConfigBranches or {}) do
    paths[name] = branch

  M.state.lapConfigName = name
  for pName, path in pairs(paths) do
    --M.state.branchGraph[pName] = {}

    if scenario.BranchLapConfig then
      for bName, branch in pairs(scenario.lapConfigBranches or {}) do
        M.state.waypointBranches[bName] = {}

    if scenario.BranchLapConfig then
      for bName, branch in pairs(scenario.lapConfigBranches or {}) do
        M.state.waypointBranches[bName] = {}

  local allWPs = {}
  for _, wpb in pairs(M.state.branchGraph) do
    for _, wp in pairs(wpb) do

  for _, wpb in pairs(M.state.branchGraph) do
    for _, wp in pairs(wpb) do
      allWPs[wp.cpName] = true

  local wpList = {}
  for wp, _ in pairs(allWPs) do
    local node = scenario.nodes[wp]

  if scenario.lapConfig and #scenario.lapConfig > 0 then
    for _, vid in pairs(scenario.vehicleNameToId) do
      initialiseVehicleData(vid)

  local vehicleWaypointsData = M.state.vehicleWaypointsData or {}
  for vid, vehWpData in pairs(vehicleWaypointsData) do
    local vehicle = getObjectByID(vid)

    if successors and vehicle and vehicleData then
      for k, v in pairs(successors) do
        local nextWp = scenario.nodes[v.cpName]

local function drawDebug()
  for vid, vehWpData in pairs(M.state.vehicleWaypointsData or {}) do
    for i = 1, #vehWpData.previousCorners do

  for _, instance in pairs(statEntry.instances) do
    local vehicle = nil

  for dataKey,data in pairs(vehicleTable) do
    local entry = {}

    if data.instances then
      for _,instance in pairs(data.instances) do
        if instance.maxPoints and instance.maxPoints  ~= 0 then

  local totalMaxPoints = 0
  for _, entryName in pairs(statsOrder) do
    local data = scenarioStats[entryName]

       for k,v in pairs(statData) do
          if not tableFindKey(ignoreInstanceFields, k) then

    local goalVehicles = scenario_scenarios.getScenario().goals.vehicles or {}
    for _, goal in pairs(goalVehicles) do
      if goal.id ~= 'wayPointAction' then

  for _, vehicleName in pairs(vehicles) do
    if not map.objectNames[vehicleName] or not map.objects[map.objectNames[vehicleName]] then

  for _,instance in pairs(statData.instances) do
    if statData.enabled then

  local totalMaxPoints = 0
  for key, statsData in pairs(vehicleTable) do
    local statPoints = calculateStatPoints(key, statsData)

    end
    for _, instance in pairs(statsData.instances) do
      if instance.maxPoints and instance.maxPoints > 0 then

local function stopStatsGathering(scenario)
  for vehicleID, vehicleTable in pairs(statsTable) do
    local data = vehicleTable[getStatKey('distance')]

        -- 1 mile = 1609.34 meters
      for _,instance in pairs(data.instances) do
        value = value + (instance.value or 0)

    if data and data.enabled then
     for _,instance in pairs(data.instances) do
        value = value + (instance.value or 0)

  if damageData and damageData.enabled then
    for _,instance in pairs(damageData.instances) do
      if instance.source then

  if scenario.state == 'post' then
    for vehicleID, vehicleTable in pairs(statsTable) do
      captureFinalDamageData(vehicleTable[getStatKey('damage')])

  for vehicleID, vehicleTable in pairs(statsTable) do
    local data = vehicleTable[getStatKey('distance')]

    if data and data.enabled then
      for _,instance in pairs(data.instances) do
        local vehicle = nil

    if data and data.enabled then
      for _,instance in pairs(data.instances) do
        local vehicle = nil

    if data and data.enabled then
      for _,instance in pairs(data.instances) do
        local vehicleData = nil

local function onRaceInit()
  for vehicleID, vehicleTable in pairs(statsTable) do
    local data = vehicleTable[getStatKey('distance')]

    if data and data.enabled then
      for _,instance in pairs(data.instances) do
        local vehicle = nil

    if data and data.enabled then
      for _,instance in pairs(data.instances) do
        local vehicle = nil

local function captureTimeData(time)
 for vehicleID, vehicleTable in pairs(statsTable) do
    local data = vehicleTable[getStatKey('time')]

    if data and data.enabled then
      for _,instance in pairs(data.instances) do
        instance.value = time

  -- Create the Road Architect roads from each unique road in the hash table.
  for k, uniqueRoad in pairs(roadNetwork) do
    local nodesIn, roadType = uniqueRoad.splineNodes, uniqueRoad.type                                     -- TODO: road_type is not used currently.

  for nodeId, intersectionData in pairs(intersections) do
    local roadIds = intersectionData.connectedRoads

    -- recursive replace
    for k, v in pairs(val) do
      val[k] = replaceSpecialValues(v)

    for sectionName, section in pairs(part) do
      if type(section) == "table" and #section > 1 then

            -- Line is dictionary, so it declares modifier(s)
            for mod, modVal in pairs(lineData) do
              if mod ~= "__astNodeIdx" then

  end
  for mod, modData in pairs(modsScalers) do
    partsModsScalers[modData.partPath] = partsModsScalers[modData.partPath] or {}

    for mod, modData in pairs(newSectionModifiers) do
      --local vehDataModVal = item[mod]

    for mod, modData in pairs(newSectionModifiers) do
      local vehDataModVal = item[mod]

    for sectionName, section in pairs(part) do
      local outModsSection = outMods[sectionName]

              -- Line is dictionary, so it declares modifier(s)
              for mod, modVal in pairs(lineData) do
                if mod ~= "__astNodeIdx" then

                if type(colData) == 'table' and tableIsDict(colData) and #lineData > headerSize then
                  for mod, modVal in pairs(colData) do
                    if mod ~= "__astNodeIdx" then

              -- If current modifiers part origin is not equal to current part and the modifier is not a default value, modifiers are considered leaking
              for mod, modData in pairs(sectionModsCopy) do
                if modsScalers[mod] then

      local mods = partsModsScalers[partName]
      for mod, modVal in pairs(mods) do
        for sectionName, outModsSection in pairs(outMods) do

      for mod, modVal in pairs(mods) do
        for sectionName, outModsSection in pairs(outMods) do
          outModsSection[partName] = outModsSection[partName] or {}

  if runTest then
    for k,v in pairs(testSectionsWrongCounter) do
      print(k .. ": " .. v .. " errors")

  local sortedTbl = tableKeysSorted(sectionsPartsMods)
  for k,v in pairs(sortedTbl) do
    sectionNamesSorted[k] = v

  sectionsModNamesSorted = {}
  for sectionName, mods in pairs(outSectionsAllModNames) do
    sortedTbl = tableKeysSorted(mods)

    for k,v in pairs(sortedTbl) do
      sectionsModNamesSorted[sectionName][k] = v

    str = "{"
    for k,v in pairs(tbl) do
      if i > 1 then str = str .. ", " end

  transformsUtils = {}
  for lineName, lineData in pairs(currDriftSpots[selectedDriftSpotId].spatialInfo.lines) do
    transformsUtils[lineName.."driftBox"] = createNewTransform("Sign pos", true, true, true, lineData.pos, quatFromEuler(lineData.rot.x, lineData.rot.y, lineData.rot.z), lineData.scl)

  }
  for lineName, lineData in pairs(spotData.spatialInfo.lines) do
    local newLineData = {

  local tempSpot
  for _, spotData in pairs(gameplay_drift_saveLoad.loadAndSanitizeDriftFreeroamSpotsCurrMap()) do
    tempSpot = sanitizeDriftSpot(spotData)

  currDriftSpots[spotId] = nil
  for key, value in pairs(currDriftSpots) do
    selectDriftSpot(key)

local function saveCurrentDriftSpots()
  for spotId, spotData in pairs(currDriftSpots) do
    local newSpotData = {

    local name = spotId:match("([^/]+)$")
    for lineName, lineData in pairs(spotData.spatialInfo.lines) do
      local newLineData = {

  im.TextWrapped("Drift spots in the current level: ")
  for spotId, spotData in pairs(currDriftSpots) do
    if im.Selectable1(spotId, spotId == selectedDriftSpotId) then

    im.Separator()
    for lineName, lineData in pairs(currDriftSpots[selectedDriftSpotId].spatialInfo.lines) do
      im.Text(lineName)

      for _,l in pairs(currentAttemptsByKey.labels) do
        im.TableSetupColumn(l)

      im.TableNextColumn()
      for _, missionData in pairs(currentAttemptsByKey.rows) do
        for _, c in pairs(missionData) do

      for _, missionData in pairs(currentAttemptsByKey.rows) do
        for _, c in pairs(missionData) do
          im.Text(tostring(c.text or "(notext?)"))

  local invalidValue = false
  for k,g in pairs(goalSchema) do
    invalidKey=false

    invalidType = false
    for kl,vl in pairs(g) do
      invalidValue = false

    if type(v.value) == "table" then
      for gkey,val in pairs(v.value) do
        checkGoalItem(goalSchema, v.id, gkey, val)

local function istable(t)
    for k, _ in pairs(t) do
        if type(k) ~= "number" then

  for _, goal in pairs(goals) do
    goal.init(scenario)

    -- iterate over all vehicles in the scene and find if goals exist
    for vName, vObjId in pairs(scenario.vehicleNameToId) do
      local tempGoals = nil

       if tempGoals then
        for k, v in pairs(tempGoals) do
          local goal = {}

  local goals = M.state.goals
  for i, goal in pairs(goals) do
    goal.updateFinalStatus(scenario)

  local goals = M.state.goals
  for i, goal in pairs(goals) do
    goal.processState(scenario, 'onRaceStart')

  local goals = M.state.goals
  for i, goal in pairs(goals) do
    goal.processState(scenario, 'onRaceInit')

  local goals = M.state.goals
  for i, goal in pairs(goals) do
    goal.processState(scenario, 'onRaceWaypointReached', data)

  local goals = M.state.goals
  for i, goal in pairs(goals) do
    goal.processState(scenario, 'onRaceTick', data)

  local goals = M.state.goals
  for i, goal in pairs(goals) do
    goal.processState(scenario, 'onRaceResult')

  local goals = M.state.goals
  for i, goal in pairs(goals) do
    goal.processState(scenario, 'onCountdownEnded')

        }
        for _, c in pairs(v.configs) do
          local passConfig = true

  local storages = energyStorage.getStorages()
  for _, storage in pairs(storages) do
    -- filter for electric batteries

  -- clamp all stats
  for k,v in pairs(result) do
    result[k].fill = clamp(v.fill, 0,100)

    if #markers == 0 then
      for k,v in pairs(nameMarkers) do
        local mk = scenetree.findObject(v)

    local mapData = map.getMap()
    for k, v in pairs(currentLine.navhelp) do
      for _, wp in pairs(v) do

    for k, v in pairs(currentLine.navhelp) do
      for _, wp in pairs(v) do
        if not mapData.nodes[wp] then

  -- if bext.y*1.25 < w then w = bext.y*1.25 end
  for k,marker in pairs(markers)do
    if k == 1 then --top left

local function isTriggerOnBusLine(tasks,tname)
  for k,v in pairs(tasks) do
    if v[1] == tname then return true end

      if currentLine.navhelp then
        for k,v in pairs(currentLine.navhelp) do --reset passedWp because of navhelp
          for i2,v2 in ipairs(v) do

  local fields = player:getFields()
  for k, f in pairs(fields) do
    if k ~= 'dataBlock' and k ~= 'parentGroup' then -- why do we need to exclude these?

function setAudioChannelsVolume(data)
  for k, v in pairs(data) do
    local AudioChannel = scenetree[k]

  if not o or #o == 0 then return nil end
  for _, v in pairs(o) do
    table.insert(res, scenetree.findObject(v))

  local obj = SimGroup()
  for k, v in pairs(t) do
    obj[k] = v

      for k, v in pairs(modelDataPaints) do
        local bc = v.baseColor

    result = {}
    for vid,v in pairs(data) do
      local vehicle = getObjectByID(vid)

    result = {}
    for vehicleName,v in pairs(data) do
      local vehicle = scenetree.findObject(vehicleName)

  local residx = 1
  for _, value in pairs(files) do
    -- because for some reason there are files inside the result if recursive level is >0

  local n = 0
  for k, v in pairs(t) do
    n = n + 1

  local dirs = {}
  for _,v in pairs(files) do
    if FS:directoryExists(v) and not FS:fileExists(v) then

  }
  for _, f in pairs(files) do
    --print( ' - ' .. string.upper(f) .. ' = ' .. hashStringSHA1(string.upper(f)))

    local resSorted = {}
    for k, v in pairs(res) do
      table.insert(resSorted, k);

  for nm, pin in pairs(self.pinInLocal) do
    if nm ~= 'flow' and nm ~= 'translationString' then

      if self.variablesState == 2 then
        for nm, pin in pairs(self.pinInLocal) do
          if nm ~= 'flow' and nm ~= 'translationString' then

    local hasData = false
    for _, file in pairs(busLineFiles) do
      local busLine = jsonReadFile(file)

      local busLine = jsonReadFile(file)
      for _, route in pairs(busLine.routes) do
        -- we save the data per route. route key is unfortunately a composite key of id and variance :(

  local res = {}
  for _, obj in pairs(objs) do
    if obj.speedTrapType == speedTrapType then

    -- recursive replace
    for k, v in pairs(val) do
      val[k] = replaceSpecialValues(v)

  -- walk everything and look for options
  for keyEntry, entry in pairs(vehicle) do
    if type(entry) ~= "table" then

  -- then walk all (keys) / entries of that vehicle
  for keyEntry, entry in pairs(vehicle) do
    -- verify key names to be proper formatted

  local res = {}
  for k, v in pairs(tbl) do
    table.insert(res, {k, v})

    local i = 1
    for k,d in pairs(body) do
        if not d.g then d.g = {} end

        else
            for j,_ in pairs(d.ac) do
                if j == 1 then

                local taa = {}
                for k,d in pairs(body) do
    --                lo('?? for_part:'..k..':'..#d.ac)

    --                lo('?? for_part:'..k..':'..#d.ac)
                    for _,c in pairs(d.ac) do
                        taa[#taa+1] = c

--        U.dump(body,'>> build:'..#ac..':'..cfix)
    for k,d in pairs(body) do
        for j,_ in pairs(d.ac) do

    for k,d in pairs(body) do
        for j,_ in pairs(d.ac) do
--            if i == ind then

    local list = {}
    for k,d in pairs(body) do
        list[#list+1] = {dnode[d.frto[1] ],dnode[d.frto[2] ]}

        if sdw then
            for i,v in pairs(adw[ind[2]]) do
                if sdw[i] then

    aa = {}
    for k,d in pairs(body) do
        lo('?? for_part:'..k..':'..#d.ac)

        lo('?? for_part:'..k..':'..#d.ac)
        for _,c in pairs(d.ac) do
            if d.fix then

        lo('?? for_L0:'..tostring(L)..':'..#aa)
    for k,c in pairs(aa) do
        local cac = step(aa, k, s)

    list = {}
    for k,d in pairs(body) do
        list[#list+1] = {dnode[d.frto[1]],dnode[d.frto[2]]}

    local set = {}
    for _,d in pairs(dnode) do
        set[#set+1] = d

    list = {}
    for k,d in pairs(body) do
        list[#list+1] = {dnode[d.frto[1]],dnode[d.frto[2]]}

    local list = {}
    for k,d in pairs(body) do
        list[#list+1] = {dnode[d.frto[1]],dnode[d.frto[2]]}

            local akey = {}
            for key,d in pairs(body) do
                akey[#akey+1] = key

                im.Columns(2)
                for _,key in pairs(akey) do
                    local d = body[key]

                    im.Indent(80)
                    for i,val in pairs(d.ac) do
                        ord = ord + 1

            akey = {}
            for key,d in pairs(dw) do
                akey[#akey+1] = key

            local tot = 0
            for i,key in pairs(akey) do
                im.Text(key)

  local sortedKeys = {}
  for key, mode in pairs(editor.editModes) do
    if key ~= "objectSelect" and key ~= "createObject" and mode.icon then table.insert(sortedKeys, key) end

  local allStates = gameplay_crawl_utils.getAllCrawlStates()
  for crawlerId, state in pairs(allStates) do
    if state and state.active then

        local tmp = i
        for k, v in pairs(o) do
          if type(k) ~= 'string' then

    for i = old, new+1, -1 do
      for _, lnk in pairs(self.graph.links) do
        if lnk.sourcePin == self.pinInLocal['vehId_'..i] then

  if type(turbo.wastegateStart) == "table" then
    for k, v in pairs(turbo.wastegateStart) do
      wastegateStart[k] = v * constants.psiToPascal

  if type(turbo.wastegateLimit) == "table" then
    for k, v in pairs(turbo.wastegateLimit) do
      wastegateLimit[k] = v * constants.psiToPascal

  else
    for k, v in pairs(wastegateStart) do
      wastegateLimit[k] = v + 0.01 * constants.psiToPascal

  maxWastegateRange = 1
  for k, v in pairs(wastegateStart) do
    local start = v

  for k, _ in pairs(assignedEngine.torqueCurve) do
    if type(k) == "number" and k < assignedEngine.maxRPM then

    table.sort(sortedKeys)
    for _, key in pairs(sortedKeys) do
      if key ~= "fieldName" and string.startswith(key, "fieldName") then

      -- find all field with fieldname
      for _, key in pairs(sortedKeys) do
        if key ~= "fieldName" and string.startswith(key, "fieldName") then

  C.__index = C
  for k, v in pairs(derivedClass) do
    o[k] = v

  local rewardsLabel = {}
  for _, reward in pairs(milestoneConfig.getRewards(step)) do
    sumChange[reward.attributeKey] = (sumChange[reward.attributeKey] or 0) + reward.rewardAmount

      if wheelData.treadBeams ~= nil then
        for _, beamcid in pairs(wheelData.treadBeams) do
          obj:setBeamSpringDamp(beamcid, v.data.beams[beamcid].beamSpring * beamCoef, 2, -1, -1)

      if wheelData.sideBeams ~= nil then
        for _, beamcid in pairs(wheelData.sideBeams) do
          obj:setBeamSpringDamp(beamcid, 0, 10, -1, -1)

      if wheelData.peripheryBeams ~= nil then
        for _, beamcid in pairs(wheelData.peripheryBeams) do
          obj:setBeamSpringDamp(beamcid, v.data.beams[beamcid].beamSpring * beamCoef, 2, -1, -1)

      if wheelData.reinfBeams ~= nil then
        for _, beamcid in pairs(wheelData.reinfBeams) do
          obj:setBeamSpringDamp(beamcid, v.data.beams[beamcid].beamSpring * beamCoef, 0.7, 0, 0)

  if brakeThermalsEnabled then
    for _, wd in pairs(M.wheelRotators) do
      if wd.enableBrakeThermals then

  for _, wd in pairs(M.wheelRotators) do
    if wd.enableBrakeThermals then

      local node2Pos = vec3(v.data.nodes[wheel.node2].pos)
      for _, n in pairs(wheel.nodes) do
        local wheelNode = v.data.nodes[n]

      if wd.axleBeams then
        for _, name in pairs(wd.axleBeams) do
          if not axleBeamLookup[name] then

  local avgWheelPos = vec3(0, 0, 0)
  for _, rotator in pairs(M.wheelRotators) do
    if rotator.brakeTorque > 0 then

  for _, rotator in pairs(M.wheelRotators) do
    local wheelNodePos = vec3(v.data.nodes[rotator.node1].pos) --find the wheel position

	if not list then list = {} end
	for k,v in pairs(matFiles) do
		loadJsonMaterialsFile(v)

			}
			for _,nm in pairs(wrCommon) do
				local mo = scenetree.findObject(nm)

	local terrBlockName = ffi.string(terrainImpExp.terrainName)
	for tbName, tbData in pairs(terrainBlockProxies) do
		if string.lower(tbName) == string.lower(terrBlockName) then

	local pref,prep = forPrefix(afile[1])
	for i,p in pairs(afile) do
		-- get world box

			local ma,ima = 0
			for i,c in pairs({'x','y','z'}) do
				local L = math.abs(ddae[p].fr[c]-ddae[p].to[c])

	end
	for i,d in pairs(daePath[tp]) do
		local str = type(d) == 'string' and d or d[1]

	local adsc = {}
	for _,id in pairs(aid) do
		adsc[#adsc+1] = adesc[id]

	end
	for i,f in pairs(desc.afloor) do
		for j,w in pairs(f.awall) do

	for i,f in pairs(desc.afloor) do
		for j,w in pairs(f.awall) do
			local tocall = false

		if forall and desc.aspline and desc.aspline[i] then
			for key,s in pairs(desc.aspline[i]) do
				if aij and #U.index(aij[i], key) > 0 then

		if U._PRD == 0 then
			for id,d in pairs(adesc) do
				cedit.mesh = id

	forBuilding(desc, function(w,ij)
		for pth,list in pairs(w.df) do
			for _,id in pairs(list) do

		for pth,list in pairs(w.df) do
			for _,id in pairs(list) do
				local item = dforest[id].item

	if desc and desc.selection and scope=='wall' and tableSize(desc.selection)==1 then
		for i,f in pairs(desc.selection) do
			for _,key in pairs(f) do

		for i,f in pairs(desc.selection) do
			for _,key in pairs(f) do
				if not tonumber(key) then

	end
	for i,f in pairs(desc.afloor) do
		aij[#aij + 1] = {}

	local akey = {}
	for k,r in pairs(buf) do
		akey[#akey+1] = k

	local aij = forSide({akey[1], buf[akey[1]][1]})
	for i,row in pairs(buf) do
		if not aij[i] then

		end
		for _,j in pairs(row) do
			if #U.index(aij[i],j) == 0 then

	if not tosave then
		for j,c in pairs(shmap) do
			for i,h in pairs(c) do

		for j,c in pairs(shmap) do
			for i,h in pairs(c) do
				tb:setHeightWs(vec3(j,i), h)

	if desctop and desctop.df ~= nil then
		for dae,list in pairs(desctop.df) do
			for i,key in ipairs(list) do

	if forestoff ~= false then
		for _,s in pairs(dforest) do
			editor.removeForestItem(fdata, s.item)

		end
		for id,d in pairs(adesc) do
			local obj = scenetree.findObjectById(id)

	local aid = {}
	for id,d in pairs(jdesc) do
		lo('?? for_desc:'..id..':'..tostring(adesc[tonumber(id)]))

		adesc[cid] = U.fromJSON(d)
		for i,d in pairs(adesc) do
			if d.idr == cid then

		if d.acorner_ then
			for i,c in pairs(d.acorner_) do
				for _,s in pairs(c.list) do

			for i,c in pairs(d.acorner_) do
				for _,s in pairs(c.list) do
					for j,p in pairs(s) do

				for _,s in pairs(c.list) do
					for j,p in pairs(s) do
						if s[j..''] and tonumber(j) then

		end
		for _,f in pairs(d.afloor) do
			f.awplus = {}

			end)
			for i,f in pairs(desc.afloor) do
				forestClean(f)

			for _,s in pairs(dforest) do
				editor.removeForestItem(fdata, s.item)

	desc.selection = nil
	for i,f in pairs(desc.afloor) do
		if f.achild then

		if f.achild then
			for k,c in pairs(f.achild) do
				c.id = nil

				c.id = nil
				for ci,cf in pairs(c.afloor) do
					for cj,cw in pairs(cf.awall) do

				for ci,cf in pairs(c.afloor) do
					for cj,cw in pairs(cf.awall) do
						cw.id = nil

						cw.id = nil
						for dae,cd in pairs(cw.df) do
							cw.df[dae] = {scale = cd.scale}

					end
					for dae,cd in pairs(cf.top.df) do
						cf.top.df[dae] = {scale = cd.scale}

		end
		for j,w in pairs(f.awall) do
			w.id = nil

			w.id = nil
			for dae,d in pairs(w.df) do
				w.df[dae] = {scale = d.scale}

		end
		for dae,d in pairs(f.top.df) do
			f.top.df[dae] = {scale = d.scale}

	forBuilding(desc, function(w,ij)
		for pth,list in pairs(w.df) do
			for _,id in pairs(list) do

		for pth,list in pairs(w.df) do
			for _,id in pairs(list) do
				local item = dforest[id].item

		lo('??+++++++++++++++++ f_CLEAN:'..#W.out.adf[desc.idpersist])
		for _,df in pairs(W.out.adf[desc.idpersist]) do
			for dae,list in pairs(df) do

		for _,df in pairs(W.out.adf[desc.idpersist]) do
			for dae,list in pairs(df) do
				for i,key in ipairs(list) do

		forBuilding(desc, function(w, ij)
			for pth,list in pairs(w.df) do
				for _,id in pairs(list) do

			for pth,list in pairs(w.df) do
				for _,id in pairs(list) do
					local item = dforest[id].item

					local its = fdata:getItemsCircle(pos, 1.2)
					for i,o in pairs(its) do
						local key = o:getKey()

		lo('?? to_HIDE:'..tableSize(dhide))
		for k,f in pairs(dhide) do
			f:setPosition(f:getPosition()+vec3(0,0,-100))

		if FS:directoryExists(dirname) then
			for _,o in pairs(list) do
				local om = scenetree.findObjectById(tonumber(o))

				lo('?? for_path:'..tostring(ok))
			for _,tp in pairs({'balcony','corner','doors','pillar','store_front','stairs',
				'windows',

			end
			for k,v in pairs(W.adae) do
				cnt[k] = v

		if U._MODE == 'conf' then
			for _,p in pairs(decalPath) do
				adec = D.decalsLoad()--, grid)

		local aid = {}
		for id,d in pairs(adesc) do
		aid[#aid+1] = id

		for i,id in pairs(aid) do
			lo('??^^^^^^^^^^^^^^^^^^^ recover_house:'..id)

		-- clean up awplus
		for i,wp in pairs(f.awplus) do
			if wp.id then

			local adec = editor.getAllRoads()
			for id,_ in pairs(adec) do
				local obj = scenetree.findObjectById(id)

	if mode ~= 'conf' and forest then
		for id,desc in pairs(adesc) do
			local obj = scenetree.findObjectById(id)

			if obj ~= nil then
				for i,f in pairs(desc.afloor) do
					for j,w in pairs(f.awall) do

				for i,f in pairs(desc.afloor) do
					for j,w in pairs(f.awall) do
						forestClean(w)

		end
		for _,s in pairs(dforest) do
			editor.removeForestItem(fdata, s.item)

			local list = fdata:getItems()
			for _,f in pairs(list) do
				editor.removeForestItem(fdata, f)

		base = {}
		for k,iw in pairs(aw) do
			local wall = desc.afloor[ifloor].awall[iw]

			if #saforest>0 and inupdate and not sdata.spacefit then
				for ind,_ in pairs(aforest) do
					if ind<=#saforest then

				-- update forest positions
				for _,d in pairs(aforest) do
					d.p.x = d.p.x + dwl

		lo('?? for_AFOR:'..#aforest)
		for i,d in pairs(aforest) do
			local w,h = d.list and d.list[2]:distance(d.list[1]) or ddae[d.dae].w,ddae[d.dae].h

	if not sdata.ahole then sdata.ahole = {} end
	for i,h in pairs(sdata.ahole) do
		ahole[#ahole+1] = h

	local margin = 0.06
	for i,d in pairs(aforest) do
		if d.scale then

	end
	for i,d in pairs(afpos) do
		aforest[i].pos = (d[1]+d[2])/2 + vec3(0,0,d[3].y)

			local pos = 0
			for k,dae in pairs(desc.storefront.adae) do
				local a = U.vang(U.vturn(desc.u, -math.pi/2), ddae[dae].front, true)

			if desc.arcext then
				for _,rce in pairs(desc.arcext) do
					arc[#arc+1] = rce

						local am = {alod[1].list[1].m}
						for _,d in pairs(alod[1].list) do
							for k,v in pairs(d.m.verts) do

						for _,d in pairs(alod[1].list) do
							for k,v in pairs(d.m.verts) do
								d.m.verts[k] = d.m.verts[k] + shift

						local pset = {}
						for i,v in pairs(am[1].verts) do
							local a = desc[tp].skew

						end
						for i,n in pairs(am[1].normals) do
							local ang = U.vang(vec3(1,1,0),n)

					U.dump(aplinth, '??____ APLINTH_:')
				for _,p in pairs(aplinth) do
					local list = M.fillSegment(

						local ckey
						for _,d in pairs(list) do
							local k = d:getKey()

					if list then
						for _,d in pairs(list) do
							local k = d:getKey()

				local ckey
				for _,d in pairs(list) do
					ckey = d:getKey()

			local vn = desc.v:normalized()
			for k,p in pairs(mbody.verts) do
				mbody.verts[k] = un*p.x + vn*p.y

	if false then
		for _,plus in pairs(desc.avplus) do
			lo('??____________________________________ desc_plus:'..tostring(desc.plus))

				af[#af + 1] = {v = #av+1, n = 0, u = #av+1}
				for _,p in pairs(plus) do
					av[#av + 1] = p -- desc.pos

				af[#af + 1] = {v = #av+2, n = 0, u = #av+2}
				for _,p in pairs(plus) do
					av[#av + 1] = p -- desc.pos

	-- set position
	for o,v in pairs(av) do
		av[o] = av[o] + desc.pos -- desc.pos is the bottom-left corner

						out.avedit = {}
						for _,v in pairs(b1) do
							out.avedit[#out.avedit + 1] = v + vec3(0,0,1)

	local base = {}
	for i,b in pairs(cbase) do
		base[#base+1] = vec3(b.x,b.y)

	end
	for _,p in pairs(base) do
		p.z = lift

	local aid = #asel > 0 and asel or {cedit.mesh}
	for _,id in pairs(aid) do
		local dfcorner = {}

			U.dump(desc.acorner_, '?? frame_CORNER:')
			for i,c in pairs(desc.acorner_) do
				for j,f in pairs(c.list) do

			for i,c in pairs(desc.acorner_) do
				for j,f in pairs(c.list) do
					if not dfcorner[f[1]] then

					local H = forHeight(desc.afloor,ij[1]-1)
					for _,d in pairs(s.aforest) do
						if d.dae == forestMeshName then

					end
					for i,b in pairs(desc.aspline[ij[1]][ij[2]].base) do
						out.dyell[ij[1]][i] = {b+vec3(0,0,H),b+vec3(0,0,H+desc.afloor[ij[1]].h)}

					if w.df[forestMeshName] then
						for _,key in pairs(w.df[forestMeshName]) do
							local h = ddae[forestMeshName].to.z - ddae[forestMeshName].fr.z

				else
					for d,list in pairs(w.df) do
						for _,key in ipairs(list) do

						if desc.aspline and desc.aspline[ij[1]] then
							for key,_ in pairs(desc.aspline[ij[1]]) do
								local aw = U.split(key,'_')

						if w['win'..'_inf'] and w['win'..'_inf'].ddae then
							for k,dae in pairs(w['win'..'_inf'].ddae) do
								-- get key

								if w.df[dae] then
									for _,key in pairs(w.df[dae]) do
										if cedit.fscope ~= 1 or key == cedit.forest then

											U.dump(cw.pilaster, '?? has_PIL:'..j..':'..#cw.df[forestMeshName])
										for _,key in pairs(cw.df[forestMeshName]) do
											akey[#akey+1] = key

								end
								for _,key in pairs(akey) do
									out.aforest[#out.aforest + 1] = dforest[key].item:getPosition()

					elseif ({corner=1})[ddae[forestMeshName].type] and desc.acorner_ then
						for i,s in pairs(desc.acorner_) do
							for _,n in pairs(s.list) do

						for i,s in pairs(desc.acorner_) do
							for _,n in pairs(s.list) do
								if n[1] == ij[1] and n[2] == ij[2] then

			local H = forHeight(desc.afloor,cij[1]-1)
			for _,d in pairs(s.aforest) do
				if #U.index(cedit.aforest, d.key)>0 then

						local base = U.polyMargin(child.base, child.margin or 0)
						for _,p in pairs(base) do
							pth[#pth+1] = adesc[cedit.mesh].pos + floor.pos + p + vec3(0,0,h+(child.fat or 0)) + posplus

					local achunk = T.forChunks(floor.base)
					for k,rc in pairs(achunk) do
						for _,i in pairs(rc) do

					for k,rc in pairs(achunk) do
						for _,i in pairs(rc) do
							local p = floor.base[i]

					local base = U.polyMargin(floor.base, marginplus + (floor.top.margin or 0))
					for _,p in pairs(base) do
						pth[#pth+1] = adesc[cedit.mesh].pos + floor.pos + p + vec3(0,0,h+(floor.top.fat or 0)) + posplus

	if desc.achild then
		for i,c in pairs(desc.achild) do
			if c.id then

	local ax, ay = {0}, {0}
	for k,list in pairs(mskip) do
		for s in pairs(list) do

	for k,list in pairs(mskip) do
		for s in pairs(list) do
			if k % 2 == 0 then

				else
					for _,c in pairs(floor.top.achild) do
						c.shape = 'flat'

					floor.top.body = {}
					for _,c in pairs(floor.top.achild) do
						-- cleanup

			if floor.top.shape ~= 'flat' then
				for _,w in pairs(floor.awall) do
					if w.roofborder then

				floor.top.ridge.on = false
				for _,c in pairs(floor.top.achild) do
					if c.id then

	local cheight = 0
	for i,f in pairs(desc.afloor) do
		cheight = cheight + f.h

		cheight = cheight + f.h
		for j,w in pairs(f.awall) do
			if ij ~= nil then

	-- update walls
	for j,w in pairs(floor.awall) do
		w.u = U.proj2D(U.mod(j+1,base) - base[j])

		end
		for _,m in pairs(am) do
			for i=1,#m.verts do

			local ref = base[1]
			for _,a in pairs(arc) do
				local ai = {}

				M.zip(ai,af) --,true)
				for k,b in pairs(a) do
					av[#av+1] = b

			local ref = base[1]
			for _,a in pairs(arc) do
				local ai = {}

				M.zip(ai,af) --,true)
				for _,b in pairs(a) do
					av[#av+1] = b

    if not av or #av == 0 then return end
		for i,_ in pairs(av) do
			av[i] = av[i] + prn.pos + vec3(0,0,H)

	local amdata = {mdata}
	for _,m in pairs(am) do
		amdata[#amdata+1] = m

		if desctop.df ~= nil then
			for dae,list in pairs(desctop.df) do
				for i,key in pairs(list) do

			for dae,list in pairs(desctop.df) do
				for i,key in pairs(list) do
					if key == cedit.forest then

			dC = 0.17
	--                    for i,v in pairs(dsc.av) do
	--                        lo('?? for_v:'..i..':'..tostring(v-desc.pos))

				local c = desctop.achild[1]
	--            for _,c in pairs(desctop.achild) do
--                    U.dump(c, '?? for_child:')

		lo('!! houseUp_NODESC:'..tostring(toedit)..':'..tableSize(adesc)..':'..tostring(adesc[tonumber(toedit)])..':'..tostring(adesc[toedit..'']))
	--      for k,d in pairs(adesc) do
	--      return

	local mdata
	for i,f in pairs(desc.afloor) do
		forestClean(f.top)

		if not f.awplus then f.awplus = {} end
		for k,wp in pairs(f.awplus) do
--                U.dump(wp, '?? for_WP:'..i..':'.._)

				lo('?? FLOOR_children:'..#f.achild, true)
			for _,c in pairs(f.achild) do
					lo('?? child_id:'..tostring(c.id)..':'..tostring(c.prn),true)

				lo('?? if_SPLINE:'..i..':'..#desc.aspline..':'..#cedit.aforest) --..':'..tostring(s))
			for k,s in pairs(desc.aspline[i]) do
				local ij = {i,k}

						local iforest = {}
						for fi,d in pairs(afpos) do
							local dz = aforest[fi].type == 'win' and -ddae[wall.win].fr.z*(aforest[fi].scale and aforest[fi].scale.z or 1) or 0

    	local botext
		for j,w in pairs(f.awall) do
			-- check splined

--				U.dump(desc.aspline,'??_______________ ASPLINE:'..i)
				for ifloor,aw in pairs(desc.aspline) do
					if ifloor == i then

--							U.dump(aw,'??****************** for_SPLf:'..ifloor..':'..j)
						for kwall,s in pairs(aw) do
							if string.find(kwall, '_'..j..'_') then

						-- initialize
						for je,b in pairs(base) do
							fe.awall[je].arcext = nil

						end
						for je,b in pairs(base) do

						local un = we.u:normalized()
						for k,rc in pairs(arcext) do
			--                      lo('?? to_check:'..tostring(base[je])..':'..tostring(U.mod(je+1,base))..'<'..tostring(f.base[j]+(w.u:normalized()*rc[1].x)))

								end
								for ie,v in pairs(rc) do
								rc[ie] = rc[ie] - vec3(ds,f.h,0) -- (U.mod(j+1,f.base) - f.base[j]):normalized()*ds

							if dext[je] then
							for _,v in pairs(dext[je]) do
								bote[#bote+1] = v

						if f.top.achild and #f.top.achild>0 then
							for k,c in pairs(f.top.achild) do
			--                    U.dump(c, '??^^^^^^^^^^^^^^^^^ for_CEST:'..k)

							local botec
							for icb,je in pairs(c.imap) do
								if botext[je] then

						desc.afloor[i+1].botext = nil
						for k,w in pairs(desc.afloor[i+1].awall) do
						w.arcext = nil

					-- link forest items
					for dae,list in pairs(w.df) do
						for _,key in ipairs(list) do

						local isvalid = true
						for _,m in pairs(cam) do
							if not m or #m.faces == 0 or #m.verts == 0 then

					if not indrag then lo('?? for_cover: i='..i..' ifchild:'..#f.top.achild..':'..cheight..':'..tostring(forsplit)..':'..tostring(dirty)..':'..#f.top.achild) end
			for _,w in pairs(f.awall) do
				w.avplus = {}

				local auvdim = {}
				for ic,c in pairs(f.top.achild) do
					if c.uvref then

				else
					for ic,c in pairs(f.top.achild) do
						if auvdim[ic] then

				elseif mdata then
					for j,q in pairs(cbase) do
						for k,p in pairs(mdata.verts) do

					for j,q in pairs(cbase) do
						for k,p in pairs(mdata.verts) do
							if (U.proj2D(p) - U.proj2D(q)):length() < small_dist then

				local ref = base[1]
				for _,a in pairs(arc) do
					local ai = {}

					M.zip(ai,af) --,true)
					for _,b in pairs(a) do
						av[#av+1] = b

--                if forsplit or (ischild and dsc.id == nil) then
				for i,m in pairs(adata) do
					if false and m.material == out.defmat then

					-- to solid building
					for _,d in pairs(adata) do
						am[#am + 1] = d

				end
				for ic,c in pairs(f.top.achild) do
							lo('?? for_CHILD:'..ic..':'..tostring(c.shape)..':'..tostring(c.fat))

						end
						for k,d in pairs(amd) do
							asi = forFat(d, c.base, c)

						local am = {}
						for _,d in pairs(desctop.adata) do
						if desctop.uvref then

						end
						for k,sd in pairs(asubdata) do
							am[#am+1] = sd

					end
					for k,d in pairs(amd) do
						asi = forFat(d, f.base, f.top)

					local am = {}
					for _,d in pairs(desctop.adata) do
						if desctop.uvref then

					-- add side plates
					for k,sd in pairs(asubdata) do
						am[#am+1] = sd

--                        end
					for _,uv in pairs(auvb) do
						uv.u = uv.u*f.top.border.uvscale[1]

				end
				for k,n in pairs(base) do
--                        if k > 4 then break end

--				U.dump(f.awplus,'??++++++++++++ for_SUBROOF:'..i)
			for k,wp in pairs(f.awplus) do
--					lo('?? for_K:'..k)

--                        U.dump(wp.list, '?? for_AWP:'..i..':'..tostring(dirty))
					for _,list in pairs(wp.list) do
--							U.dump(list,'??++++++++++++++++ for_WP:')

--							U.dump(list,'??++++++++++++++++ for_WP:')
						for key,p in pairs(list) do
--                                lo('?? if_key:'..tostring(key)..':'..tostring(tonumber(key)))

--                U.dump(desc.acorner_, '??>>>>>> for_CORNER:'..tableSize(desc.acorner_))
		for i,s in pairs(desc.acorner_) do
--            if i > 1 then break end

		if false then
			for i,f in pairs(desc.afloor) do
				if f.achild then

				if f.achild then
					for k,c in pairs(f.achild) do
							lo('??^^^^^^^^^^^^^^^^+++++++++++++++ to_CHILD_PRN:'..k,true)

		if desctop and desctop.df ~= nil then
			for dae,list in pairs(desctop.df) do
				for _,key in ipairs(list) do

			lo('?? for_child:'..desc.floor) --#desc.prn.afloor[desc.floor].achild)
		for k,c in pairs(adesc[desc.prn].afloor[desc.floor-1].achild) do
--                    lo('?? for_child:'..k..':'..tostring(c.id))

	if not fkeep then
		for i,f in pairs(desc.afloor) do
			for j,w in pairs(f.awall) do

		for i,f in pairs(desc.afloor) do
			for j,w in pairs(f.awall) do
				forestClean(w)

	else
		for i,f in pairs(desc.afloor) do
			for j,w in pairs(f.awall) do

		for i,f in pairs(desc.afloor) do
			for j,w in pairs(f.awall) do
				adf[#adf+1] = w.df

	local fnew = deepcopy(desc.afloor[i])
	for j,w in pairs(fnew.awall) do
		w.id = nil

		w.id = nil
		for dae,d in pairs(w.df) do
			w.df[dae] = {scale = d.scale}

		lo('??^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ building4test:'..tostring(pth)..':'..tableSize(amesh))
	for i,s in pairs(list) do
--			lo('?? for_file:'..i..':'..s)

	list = FS:findFiles(pth, '*.json', -1, true, false)
	for i,s in pairs(list) do
		FS:removeFile(s)

--		lo('?? onVal_gen_unique:'..tostring(pth)..':'..tableSize(amesh))
	for i,s in pairs(list) do
--			lo('?? for_file:'..i..':'..s)

		desc.id = nil
		for i,f in pairs(desc.afloor) do
			for j,w in pairs(f.awall) do

		for i,f in pairs(desc.afloor) do
			for j,w in pairs(f.awall) do
				w.id = nil

--    toJSON(desc)
--        for key,b in pairs(adesc) do
--            U.dump(adesc[key].afloor[1].base, '<< buildingGen:'..key..':'..tostring(adesc[key].pos))

	local xma,yma = 0,0
	for _,path in pairs(apth) do
		local img = imguiUtils.texObj(path)

	local cx = 0
	for i,img in pairs(aimg) do
		arc[#arc+1] = {fr={cx/xma,(1-img.size.y/yma)}, to={(cx+img.size.x)/xma,1}}

		else
			for i,c in pairs(desctop.achild) do
				if cb then cb(c) end

			local v = -u:cross(vec3(0,0,1))
			for i,uv in pairs(mesh.uvs) do
				uv.u = suvs[i].u + ds:dot(u)

--            U.dump(w.agrid, '?? for_AGRID:')
		for _,xy in pairs(w.agrid) do
--                lo('?? for_XY1:'..tostring(xy[1])..':'..tostring(xy[2]), true)

--            lo('?? duvs:'..ij[1]..':'..ij[2]..' suvs:'..#suvs..' verts:'..#mesh.verts)
		for i,p in pairs(mesh.verts) do
			auv[#auv+1] = {}

	local auv = {}
	for _,xy in pairs(desc.agrid) do
		auv = M.uv4grid({desc.uv[1], desc.uv[3]}, {desc.uv[2], desc.uv[4]},

local function bufToggle(buf, ij, yes)
	for i,r in pairs(buf) do
		for j,c in pairs(r) do

	for i,r in pairs(buf) do
		for j,c in pairs(r) do
			for k,cij in pairs(c) do

		for j,c in pairs(r) do
			for k,cij in pairs(c) do
				if ij[1] == cij[1] and ij[2] == cij[2] then

		local hit
		for i,s in pairs(acorner) do
			if (s.pos-U.proj2D(v)):length() < small_dist then

					lo('?? f_SPLINE:'..ij[2]..':'..tostring(s))
				for _,d in pairs(s.aforest) do
					if #U.index(cedit.aforest,d.key)>0 then

				end
				for d,list in pairs(w.df) do
					iforest = U.index(w.df[d], cedit.forest)[1]

--					U.dump(forspline.aforest, '?? for_SPLINE:'..cedit.forest..':'..cedit.fscope..':'..tp)
				for i,d in pairs(forspline.aforest) do
					if d.type == tp then

								local hmax = 0
								for _,w in pairs(floor.awall) do
					--                            local dae = w[tp]

	if desc and desc.selection then
		for i,row in pairs(desc.selection) do
			for _,key in pairs(row) do

		for i,row in pairs(desc.selection) do
			for _,key in pairs(row) do
--					lo('?? for_SPLINE:'..i..':'..key..':'.._)

		if #dmesh[cmesh].sel == 0 then
			for _,m in pairs(dmesh[cmesh].data) do
				m.material = nm

			lo('?? for selection:')
			for _,m in pairs(dmesh[cmesh].sel) do
				m.material = nm

			local info = currentMaterial:getFieldInfo('normalMap', 1)
			for k,v in pairs(info) do
--                lo('?? KV:'..tostring(k)..':'..tostring(v))

		elseif #floor.top.achild > 0 then
			for _,c in pairs(floor.top.achild) do
				c.mat = nm

--[[
	for _,f in pairs(desc.afloor) do
		for o,w in pairs(f.awall) do

	for _,f in pairs(desc.afloor) do
		for o,w in pairs(f.awall) do
			w.mat = nm

		local mat = adesc[cedit.mesh].afloor[cij[1] ].top.mat
		for i,m in pairs(dmat.roof) do
--                lo('?? for_mat:'..tostring(m))

			local apair,amult = T.pairsUp(base)
			for _,m in pairs(amult) do
				if #m > 1 then

			local len,pos
			for i,r in pairs(aij) do
				for j,n in pairs(r) do

			for i,r in pairs(aij) do
				for j,n in pairs(r) do
					if desc.afloor[i].awall[n].doorind then

			lo('?? hide_AFOREST:'..#cedit.aforest..':'..tostring(s))
		for i,d in pairs(s.aforest) do
			if d.skip then

				local s = adesc[cedit.mesh].selection[ij[1] ][ij[2] ]
				for i,d in pairs(s.aforest) do
					if d.skip then

		local dae = dforest[cedit.forest].item:getData():getShapeFile()
		for k,key in pairs(dsc.df[dae]) do
			if key == cedit.forest then

	forBuilding(desc, function(w, ij)
		for _,akey in pairs(w.df) do
			if #U.index(akey, key) > 0 then

  if achunk then
    for i,c in pairs(achunk) do
      table.insert(floor.top.achild, floor.top.cchild, {

--!!    houseUp(adesc[cedit.mesh], cedit.mesh)
	for ic,wp in pairs(floor.awplus) do
		if wp.id then

	local bpos = floor.pos + adesc[cedit.mesh].pos + vec3(0, 0, aint[1][1].z) -- basic outer position
	for j,v in pairs(floor.base) do
		local p = v + bpos

	end
	for k,v in pairs(avclose) do
		if v[2] == 0 then

	local list = {}
	for i,rc in pairs(arc) do
		floor.top.body[#floor.top.body + 1] = rc

	list = {}
	for i,rc in pairs(arc) do
		floor.top.body[#floor.top.body + 1] = rc

	if desctop.achild then
		for i,c in pairs(desctop.achild) do
		local cobj = scenetree.findObjectById(c.id)

	local jmi = math.huge
	for i,r in pairs(buf) do
		table.sort(r)

			if j < jmi then jmi = j end
--        for _,j in pairs(r) do
			local ij = {i,j}

--[[
	for _,ij in pairs(aij) do
	end

	end
	for i,r in pairs(buf) do
		for _,j in pairs(r) do

	for i,r in pairs(buf) do
		for _,j in pairs(r) do

			-- split walls
			for i,e in pairs(out.asplit) do
					U.dump(e, '?? u:'..i..':'..e.u..':'..tostring(base2world(adesc[cedit.mesh], e.ij)))

	local desc = adesc[cedit.mesh]
	for _,e in pairs(out.asplit) do
		local base = desc.afloor[e.ij[1]].base

	if #its > 0 then
		for _,itm in pairs(its) do
			local key = itm:getKey()

--                        U.dump(desctop.base,'??^^^^^^^^^^^^^^^^^^^^^ ifHit:'..tostring(desctop.shape)..':'..tostring(phit)..':'..tostring(p))
	for k,c in pairs(floor.top.achild) do
		local cbase = {}

		local base = c.base or floor.base
		for _,b in pairs(base) do
			cbase[#cbase+1] = base2world(desc,{i,1},b)+vec3(0,0,floor.h)

		local arc = coverUp(cbase)
		for _,rc in pairs(arc) do
			for j=1,#rc do

  if floor.top.achild then
    for i,c in pairs(floor.top.achild) do
      if c.id then

local function floorClean(floor)
	for j,w in pairs(floor.awall) do
		for dae,r in pairs(w.df) do

	for j,w in pairs(floor.awall) do
		for dae,r in pairs(w.df) do
			w.df[dae] = {scale = r.scale or 1}

	end
	for dae,r in pairs(floor.top.df) do
		floor.top.df[dae] = {scale = r.scale or 1}

		local ima = 0
		for i,r in pairs(house.selection) do
			if i > ima then ima = i end

			afloor[#afloor+1] = f
			for j,w in pairs(f.awall) do
				for dae,_ in pairs(w.df) do

			for j,w in pairs(f.awall) do
				for dae,_ in pairs(w.df) do
					w.df[dae] = {scale = w.df[dae].scale or 1}

			end
			for dae,_ in pairs(f.top.df) do
				f.top.df[dae] = {scale = f.top.df[dae].scale or 1}

		end
	--                for k,f in pairs(afloor) do
		for k = #afloor,1,-1 do

	--            table.insert(house.afloor, ito, newfloor)
		for j,w in pairs(newfloor.awall) do
			for dae,_ in pairs(w.df) do

		for j,w in pairs(newfloor.awall) do
			for dae,_ in pairs(w.df) do
				w.df[dae] = {scale = w.df[dae].scale or 1}

		end
		for dae,_ in pairs(newfloor.top.df) do
			newfloor.top.df[dae] = {scale = newfloor.top.df[dae].scale or 1}

			floor.top.body = coverUp(floor.base)
			for i,c in pairs(floor.top.achild) do
				c.ridge = {}

	desc.afloor[#desc.afloor + 1] = newfloor
	for i,w in pairs(floor.awall) do
		w.roofborder = {yes=false}

  	W.floorClear(desc.afloor[#desc.afloor-1])
	for j,w in pairs(newfloor.awall) do
		w.ij[1] = newfloor.ij[1]

--    lo('>> forHit:')
	for i,f in pairs(desc.afloor) do
--            lo('?? forHit_f:'..i)

					local cbase = {}
					for _,b in pairs(base) do
						cbase[#cbase+1] = base2world(desc,{i,1},b)+vec3(0,0,f.h)

--[[
				for _,b in pairs(desctop.base) do
					base[#base+1] = base2world(desc,{i,1},b)

			if #f.top.achild > 0 then -- and not f.top.ridge then -- (not f.top.ridge or not f.top.ridge.on) then
				for _,c in pairs(f.top.achild) do
--                        U.dump(c.base,'?? forHit_child:'..i..':'..tostring(c.shape)..':'.._)

		if false and f.awplus then
			for j,wp in pairs(f.awplus) do
--                U.dump(wp, '?? for_WP:'..i..':'..j)

--                U.dump(wp, '?? for_WP:'..i..':'..j)
				for k,r in pairs(wp.list) do
					local vn = (r[2]-r[1]):cross(r[3]-r[2])

		-- walls
		for j,w in pairs(f.awall) do
      -- local phit = U.ray2plane(ray,p,vec3(0,0,1))

	--                    lo('?? for_build:'..ij[1]..':'..ij[2])
						for _,akey in pairs(w.df) do
							local cind = U.index(akey, key)

						dae = desc[tp][1]
						for _,akey in pairs(desc.df) do
							local cind = U.index(akey, key)

			local desc = (id and adesc[id]) and adesc[id] or adesc[cedit.mesh] --or adesc[id]
--            for _,f in pairs(desc.afloor) do
--                f.top.cchild = nil

--        data = cedit.cval['Drag_Z'][2]
		for ord,m in pairs(data) do
	--        for i = 1,6,6 do

	local dpop,dtrans = forFaces(cedit.cval['Drag_Z'].afaces)
	for ord,m in pairs(dmesh[meshID].data) do
		m.faces = U.clone(cedit.cval['Drag_Z'].afaces[ord])

	local dpopsel,dtranssel = forFaces(cedit.cval['Drag_Z'].aselfaces)
	for ord,m in pairs(dmesh[meshID].sel) do
		m.faces = U.clone(cedit.cval['Drag_Z'].aselfaces[ord])

	dmesh[meshID].buf = {}
	for ord,m in pairs(cedit.cval['Drag_Z'].abuffaces) do
		dmesh[meshID].buf[ord] = {

	-- dtranssel->dtrans
	for ord,list in pairs(dtranssel) do
		for _,i in pairs(list) do

	for ord,list in pairs(dtranssel) do
		for _,i in pairs(list) do
--            dtrans[ord][#dtrans[ord] + 1] = i

		-- dtrans->dpop
		for ord,list in pairs(dtrans) do
			for _,i in pairs(list) do

		for ord,list in pairs(dtrans) do
			for _,i in pairs(list) do
				dpop[ord][#dpop[ord] + 1] = i

	for ord,m in pairs(dmesh[meshID].data) do
		amesh[#amesh + 1] = m

--				if true then return end
			for i,f in pairs(desc.selection) do
--				lo('?? fsel:'..tableSize(f))

				if tableSize(f) == 1 then
					for j,key in pairs(f) do
--							lo('?? if_SPL:'..tostring(s))

							if s.base then
								for k,b in pairs(s.base) do
	--									lo('?? if_NODE:'..k..':'..tostring(b+vec3(0,0,s.box.minExtents.z))..':'..tostring(b+vec3(0,0,s.box.maxExtents.z)))

											local aind = U.split(key,'_')
											for _,iw in pairs({aind[1],aind[#aind]+1}) do
--												lo('?? for_I:'..iw)

						lo('?? rcp:'..tostring(rayCast.pos))
					for i,d in pairs(desc.aspline[ij[1]][ij[2]].aforest) do
						if d.key == cedit.forest then

					cedit.cval['DragPos'].cpos = p
					for i,d in pairs(desc.aspline[ij[1]][ij[2]].aforest) do
						if d.key == cedit.forest then

				local db = (U.proj2D(rayCast.pos - base2world(desc, out.acorner[1].ij))):dot(u)
				for k,e in pairs(out.acorner) do
					desc.afloor[e.ij[1]].base[e.ij[2]] = desc.afloor[e.ij[1]].base[e.ij[2]] + db*u

--------------------
							for k,c in pairs(incorner) do

								-- corossing with opposite side
								for j,b in pairs(base) do
									if math.abs(j-ind) > 1 then

		--                    U.dump(floor.top.achild, '?? achild:')
						for i,c in pairs(floor.top.achild) do
							if c.id then

				if db:length() > 0 then
					for k,e in pairs(incorner) do
	--                    for k,e in pairs(out.acorner) do

					for k,e in pairs(incorner) do
	--                    for k,e in pairs(out.acorner) do
		--                    db = vec3(0.1,0,0)

	--                            _dbdrag = true
							for i,s in pairs(cedit.cval['DragPos'].insplit) do
								local base = desc.afloor[s.floor].base

		if desc and desc.selection and scope=='wall' and tableSize(desc.selection)==1 then
			for i,f in pairs(desc.selection) do
				for _,key in pairs(f) do

			for i,f in pairs(desc.selection) do
				for _,key in pairs(f) do
					if not tonumber(key) then

				cedit.cval['DragPos'] = {}
				for _,f in pairs(desc.afloor) do
					cedit.cval['DragPos'][#cedit.cval['DragPos'] + 1] = U.clone(f.base)

				U.dump(side, '?? SIDE:'..tostring(cij))
			for i,f in pairs(side) do
				for j,w in pairs(f) do

			for i,f in pairs(side) do
				for j,w in pairs(f) do
					local ij = {i, w}

					lo('?? dv:'..tostring(dirhit)..':'..tostring(dv))
				for ord,m in pairs(dmesh[cmesh].data) do
					for i = 1,#m.verts do

	]]
				for ord,m in pairs(dmesh[cmesh].data) do
					afaces[#afaces+1] = U.clone(m.faces)

					if dmesh[cmesh].trans[ord] ~= nil then
						for _,f in pairs(dmesh[cmesh].trans[ord].faces) do
							list[#list + 1] = f

					if dmesh[cmesh].buf[ord] ~= nil then
						for _,f in pairs(dmesh[cmesh].buf[ord].faces) do
	--                        list[#list + 1] = f

	--[[
				for _,m in pairs(dmesh[cmesh].trans) do
	--                afaces[#afaces+1] = U.clone(m.faces)

				local aselfaces = {}
				for _,m in pairs(dmesh[cmesh].sel) do
					aselfaces[#aselfaces+1] = U.clone(m.faces)

				local abuffaces = {}
				for _,m in pairs(dmesh[cmesh].buf) do
					abuffaces[#abuffaces+1] = U.clone(m.faces)

						-- TODO: use childRebase?
						for _,c in pairs(floor.top.achild) do
							if c.imap then

--                                    U.dump(c.imap, '?? for_c_map:'..ij[2])
								for k,m in pairs(c.imap) do
									if m == ij[2] then

							local floor = desc.afloor[ij[1]]
							for i,c in pairs(incorner) do
								if c.ij[1] == ij[1] and c.ij[2] == ij[2] then

									-- TODO: use childRebase?
									for _,c in pairs(floor.top.achild) do
										if c.imap then

--                                                U.dump(c.imap, '?? for_c_map:'..ij[2])
											for k,m in pairs(c.imap) do
												if m == ij[2] then

		local dmi,bmi = near_dist
		for k,q in pairs(base) do
			local d = a:distanceToLine(U.mod(k+1,base), q)

		local hit = false
		for j,p in pairs(floor.base) do
			a = p + floor.pos

			end
			for k,q in pairs(floorpre.base) do
				b = q + floorpre.pos

--            local dmi,imi = math.huge
			for k,q in pairs(floorpre.base) do
				local d = a:distanceToLineSegment(U.mod(k+1,floorpre.base), q)

			local ishit
			for i1,f1 in pairs(desc.afloor) do
				for i2,f2 in pairs(adesc[desc.prn].afloor) do

			for i1,f1 in pairs(desc.afloor) do
				for i2,f2 in pairs(adesc[desc.prn].afloor) do
					a,b,tp = forNear(f1, f2, desc)

						local isperp = true
						for k,v in pairs(ashift) do
								lo('?? if diff:'..i1..':'..i2..':'..k..':'..U.vang(v, b-a)..':'..tostring(U.vang(v, b-a) % math.pi))

		forBuilding(adesc[cedit.mesh], function(w, ij)
			for _,k in pairs({'plinth','roofborder'}) do
				if w[k] then

				local dmi,ijmi,ds=math.huge
				for i,a in pairs(basea) do
					for j,b in pairs(baseb) do

				for i,a in pairs(basea) do
					for j,b in pairs(baseb) do
						local d = (a+pa-b+pb):length()

					dmi,ds=math.huge,nil
					for i,a in pairs(basea) do
						for j,b in pairs(baseb) do

					for i,a in pairs(basea) do
						for j,b in pairs(baseb) do
							local d = U.toLine(a+pa,{b+pb,U.mod(j+1,baseb)+pb})

				U.dump(out.ahole, '??__________ inhole:'..tostring(base2world(adesc[cedit.mesh], cij))..':'..tostring(cw.u))
			for i=1,4 do -- in pairs(out.ahole) do
				rc[#rc+1] = world2wall(out.ahole[i], cw)

					local aij = forSide(cij)
					for i,r in pairs(aij) do
						if i == cij[1] then

							local jmi = math.huge
							for _,j in pairs(r) do
								awall[#awall+1] = floor.awall[j]

			lo('?? if_edit:'..tostring(cedit.mesh)..':'..tostring(id)..':'..tableSize(adesc))
--      for k,d in pairs(adesc) do
--        lo('?? if_DESC:'..k..':'..tostring(adesc[k]))

		cedit.aforest = {}
		for i,f in pairs(desc.aspline) do
			for key,s in pairs(f) do

		for i,f in pairs(desc.aspline) do
			for key,s in pairs(f) do
				if s.id == id then

					-- dforest[key].type
					for i,p in pairs(cw.achild[ihole].base) do
	--                    lo('?? for_p:'..tostring(cw.pos)..':'..tostring(p)..':'..tostring(cw.u)..':'..tostring(cw.v))

--                    out.ahole = nil
--            for _,c in pairs(cw.achild) do
--            end

					elseif inrc ~= nil then
						for i,c in pairs(floor.top.achild) do
--                            U.dump(c, '?? for_LIST:'..i..':'..inrc..' scch:'..tostring(scchild)..':'..#U.index(c.list, inrc))

				else
					for i,m in pairs(dmat.wall) do
						if tostring(m) == cmat then

--            for i,f in pairs(desc.afloor) do
--            end

--[[
			for ord,m in pairs(dmesh[id].sel) do
				for _,f in pairs(m.faces) do

			for ord,m in pairs(dmesh[id].sel) do
				for _,f in pairs(m.faces) do
					out.avedit[#out.avedit + 1] = m.verts[f.v + 1]

				local apick = {}
				for _,f in pairs(m.faces) do
					if #U.index(apick, f.v) == 0 then

			out.avedit = {}
			for _,x in pairs({ob.minExtents.x, ob.maxExtents.x}) do
				for _,y in pairs({ob.minExtents.y, ob.maxExtents.y}) do

			for _,x in pairs({ob.minExtents.x, ob.maxExtents.x}) do
				for _,y in pairs({ob.minExtents.y, ob.maxExtents.y}) do
					for _,z in pairs({ob.minExtents.z, ob.maxExtents.z}) do

				for _,y in pairs({ob.minExtents.y, ob.maxExtents.y}) do
					for _,z in pairs({ob.minExtents.z, ob.maxExtents.z}) do
						out.avedit[#out.avedit+1] = vec3(x, y, z)

			local function forNear(floor, floorpre, child)
				for j,p in pairs(floor.base) do
					local a = p + floor.pos

					local hit = false
					for k,q in pairs(floorpre.base) do
						local b = q + floorpre.pos

					local dmi,imi = math.huge
					for j,q in pairs(floorpre.base) do
						local d = a:distanceToLineSegment(U.mod(j+1,floorpre.base), q)

				forBuilding(desc, function(w, ij)
					for d,list in pairs(w.df) do
						for _,k in ipairs(list) do

						if inrc ~= nil then
							for i,c in pairs(floor.top.achild) do
--                                U.dump(c, '?? for_LIST2:'..i..':'..inrc..' scch:'..tostring(scchild)..':'..#U.index(c.list, inrc))

				out.asplit = nil
				for i,a in pairs(desc.aspline) do
					local H = forHeight(desc.afloor, i-1)

					local H = forHeight(desc.afloor, i-1)
					for j,d in pairs(a) do
--							U.dump(d, '?? for_D:'..d.id..':'..id..':'..tostring(tostring(d.id) == tostring(id)))

							local hit = false
							for k,v in pairs(d.base) do
								if true then

				local center = vec3(0,0,0)
				for _,v in pairs(dmesh[cmesh].apick) do
					center = center + m.verts[v+1]

				local dr = dirobj*0.02
				for _,v in pairs(dmesh[cmesh].apick) do
					m.verts[v+1] = m.verts[v+1] + dir*dr

				local amesh = dmesh[cmesh].data
				for _,m in pairs(amesh) do
					for _,v in pairs(m.verts) do

				for _,m in pairs(amesh) do
					for _,v in pairs(m.verts) do
						center = center + v

				local dr = dirobj*0.02
				for i,m in pairs(amesh) do
					local m = amesh[i]

					local m = amesh[i]
					for j,v in pairs(m.verts) do
						m.verts[j] = m.verts[j] + dir*dr

			set(floor, 'h', floor.h + dir*0.02) -- 0.2 * dir)
			for _,w in pairs(floor.awall) do
				set(w, 'v', vec3(0,0,floor.h))

				local floor = house.afloor[#house.afloor]
				for _,w in pairs(floor.awall) do
					for i,key in pairs(w.df[w.win]) do

				for _,w in pairs(floor.awall) do
					for i,key in pairs(w.df[w.win]) do
--                    for i,key in pairs(w.awin) do

					for i,key in pairs(w.df[w.win]) do
--                    for i,key in pairs(w.awin) do
						editor.removeForestItem(fdata, dforest[key].item)

				--- update u's
				for j,w in pairs(f.awall) do
					w.u = base[j % #base + 1] - base[j]

		if desc.selection then
			for _,s in pairs(desc.selection) do
				forWall(U.split(s, '_'))

--                        U.dump(asij, '?? asij:')
				for i,f in pairs(asij) do
					for _,j in pairs(f) do

				for i,f in pairs(asij) do
					for _,j in pairs(f) do
--                            lo('?? for_wall:'..tostring(f)..':'..tostring(j))

						_dbdrag = true
				for i,floor in pairs(adesc[cedit.mesh].afloor) do
--                    forFloor(floor, i)

local function floor2level(f, ind)
	for _,w in pairs(f.awall) do
		w.ij[1] = ind

	if f.achild then
--        for _,c in pairs(f.achild) do
--        end

--            floor2level(desc.afloor[cij[1]], cij[1])
			for _,w in pairs(floor.awall) do
				w.ij[1] = w.ij[1]+dir

			end
			for _,w in pairs(desc.afloor[cij[1] ].awall) do
				w.ij[1] = w.ij[1]-dir

			if floor.achild then
				for _,c in pairs(floor.achild) do
					c.floor = c.floor + dir

			if desc.afloor[cij[1]].achild then
				for _,c in pairs(desc.afloor[cij[1]].achild) do
					c.floor = c.floor - dir

--[[
			for _,w in pairs(floor.awall) do
				w.ij[1] = w.ij[1]+dir

			end
			for _,w in pairs(desc.afloor[cij[1] ].awall) do
				w.ij[1] = w.ij[1]-dir

					local ima = 0
					for i,r in pairs(house.selection) do
						if i > ima then ima = i end

						afloor[#afloor+1] = f
						for j,w in pairs(f.awall) do
							for dae,_ in pairs(w.df) do

						for j,w in pairs(f.awall) do
							for dae,_ in pairs(w.df) do
								w.df[dae] = {scale = w.df[dae].scale or 1}

						end
						for dae,_ in pairs(f.top.df) do
							f.top.df[dae] = {scale = f.top.df[dae].scale or 1}

					end
	--                for k,f in pairs(afloor) do
					for k = #afloor,1,-1 do

		--            table.insert(house.afloor, ito, newfloor)
					for j,w in pairs(newfloor.awall) do
						for dae,_ in pairs(w.df) do

					for j,w in pairs(newfloor.awall) do
						for dae,_ in pairs(w.df) do
							w.df[dae] = {scale = w.df[dae].scale or 1}

					end
					for dae,_ in pairs(newfloor.top.df) do
						newfloor.top.df[dae] = {scale = newfloor.top.df[dae].scale or 1}

				floor.h, floor.awall[1], cij[1] + 1)
				for j,w in pairs(awall) do
					w.mat = floor.awall[j].mat

				floor2level(f, i)
--                    for j,w in pairs(f.awall) do
--                        w.ij[1] = w.ij[1] + 1

				newfloor.top.ij = {#house.afloor}
				for j,w in pairs(newfloor.awall) do
					w.ij[1] = newfloor.ij[1]

				floor = house.afloor[#house.afloor]
				for _,w in pairs(floor.awall) do
					forestClean(w)

					lo('?? unsel:'..#dmesh[cmesh].sel..':'..#dmesh[cmesh].data)
--                for _,m in pairs(dmesh[cmesh].sel) do
--                end

				local amesh = {} --dmesh[cmesh].data
				for _,m in pairs(dmesh[cmesh].data) do
					amesh[#amesh + 1] = m

				end
				for _,m in pairs(dmesh[cmesh].sel) do
					amesh[#amesh + 1] = m

	local floor = desc.afloor[ind]
	for j,w in pairs(floor.awall) do
		forestClean(w)

  elseif floor.top.achild then
    for i,c in pairs(floor.top.achild) do
      local cobj = scenetree.findObjectById(c.id)

	if string.find(cmd, 'scope') then
		for _,t in pairs({'building','floor','wall','top'}) do
			if string.find(cmd, t) then

	if scope == 'top' then
		for _,t in pairs({'gable','shed','pyramid','flat'}) do
			if string.find(cmd,t) then

			local dset = {o=0,y=0,g=0,b=0}
			for _,list in pairs(conf.set) do
				for j,p in pairs(list) do

			for _,list in pairs(conf.set) do
				for j,p in pairs(list) do
					if p == 'a' then

--        lo('?? for_save:')
--            for j,f in pairs(desc.afloor) do
--                lo('?? for_child:'..j..':'..tostring(f.achild))

				floor.top.cchild = nil
				for i,c in pairs(floor.top.achild) do
					if c.id then

					lo('?? for_child:'..desc.floor) --#desc.prn.afloor[desc.floor].achild)
				for k,c in pairs(adesc[desc.prn].afloor[desc.floor-1].achild) do
--                    lo('?? for_child:'..k..':'..tostring(c.id))

			end
			for i,f in pairs(desc.afloor) do
				for j,w in pairs(f.awall) do

			for i,f in pairs(desc.afloor) do
				for j,w in pairs(f.awall) do
					forestClean(w)

			local floor = desc.afloor[cij[1] ]
			for j,w in pairs(floor.awall) do
				forestClean(w)

--            lo('?? for_fwhite:'..#out.fwhite)
		for _,v in pairs(out.fwhite) do
			debugDrawer:drawLine(v[1], v[2], ColorF(1,1,1,1), 4)

	if out.fmtop then
		for _,pth in pairs(out.fmtop) do
			for i=1,#pth-1 do

	if false and out.dyell then
		for i,row in pairs(out.dyell) do
			for j,pth in pairs(row) do

		for i,row in pairs(out.dyell) do
			for j,pth in pairs(row) do
				local incorner

						U.dump(out.acorner, '?? acorn:')
					for i,c in pairs(out.acorner) do
						if c.ij[1] == i and c.ij[2] == j then

--            lo('?? for_fwhite:'..#out.fwhite)
		for _,pth in pairs(out.fyell) do
--            Render.path(pth, color(255,255,150,155), 4)

		for i=2,#out.ahole do
--        for _,v in pairs(out.ahole) do
			debugDrawer:drawLine(out.ahole[i-1], out.ahole[i], ColorF(1,1,0,1), 4)

	if out.aforest then
		for _,s in pairs(out.aforest) do
			local r = 0.02*math.sqrt((s-core_camera.getPosition()):length())

		for i = 1,#out.aedge.e-1 do
--        for _,d in pairs(out.aedge.e) do
			debugDrawer:drawLine(out.aedge.e[i], out.aedge.e[i+1], ColorF(1,1,1,1), 4)

	if out.flbl then
		for _,l in pairs(out.flbl) do
			if l[2] then

--            U.dump(out.asplit, '?? mark_split:')
		for _,e in pairs(out.asplit) do
			debugDrawer:drawLine(e[1], e[2], ColorF(1,1,0,1))

--			lo('?? for_DYELL:')
		for i,row in pairs(out.dyell) do
--			if row.noz then

--			end
			for j,pth in pairs(row) do
--					if not tonumber(j) and j ~= 'len' then

--                        U.dump(out.acorner, '?? acorn:')
					for _,c in pairs(out.acorner) do
						if i==c.ij[1] then

							local floor = desc.afloor[ij[1]]
							for k,p in pairs({
								base2world(desc, ij),

			--                    lo('?? ab:'..tostring(a)..':'..tostring(b)..':'..tostring(desc.pos)..':'..tostring(rayCast.pos))
							for k,p in pairs({a, b}) do
								local campos = core_camera.getPosition()

	--                        if scope == 'floor' then
	--                            for i,_ in pairs(base) do
	--                            end

						local pmi,pma,mi,ma = math.huge,0
						for i,r in pairs(aside) do
							if i == cij[1] then

							if i == cij[1] then
								for _,j in pairs(r) do
									local prj = (U.mod(j,base) - base[cij[2]]):dot(u)

							local jp = cij[2]
							for k,j in pairs(aside[cij[1]]) do
								local p1,p2 = (base[j] - base[cij[2]]):dot(u),(U.mod(j+1,base) - base[cij[2]]):dot(u)

		end)
		for i,f in pairs(desc.afloor) do
			forestClean(f)

		desc.id = nil
		for i,f in pairs(desc.afloor) do
			for j,w in pairs(f.awall) do

		for i,f in pairs(desc.afloor) do
			for j,w in pairs(f.awall) do
				w.id = nil

				if tableSize(incopy) == 1 then
					for id,buf in pairs(incopy) do
						local akey = {}

						local akey = {}
						for k,r in pairs(buf) do
							akey[#akey + 1] = k

						local afloor = {}
						for _,k in pairs(akey) do
--                        for i,r in pairs(buf) do

						for _,k in pairs(akey) do
--                        for i,r in pairs(buf) do
							local r = buf[k]

							-- append floors
							for _,f in pairs(afloor) do
								floorClean(f)

					if tableSize(incopy) == 1 then
						for id,b in pairs(incopy) do
							buf = b

				local akey = {}
				for k,r in pairs(buf) do
					akey[#akey+1] = k

							local jmi = math.huge
							for _,j in pairs(buf[akey[1]]) do
	--                            for j,_ in pairs(buf[akey[1]]) do

							for _,j in pairs(buf[akey[1]]) do
	--                            for j,_ in pairs(buf[akey[1]]) do
								awall[#awall+1] = deepcopy(dsrc.afloor[akey[1]].awall[j])

	--[[
							for _,j in pairs(buf[akey[1] ]) do
	--                            for j,_ in pairs(buf[akey[1] ]) do

							for _,j in pairs(buf[akey[1] ]) do
	--                            for j,_ in pairs(buf[akey[1] ]) do
	end

	end
	for _,j in pairs(buf[akey[1] ]) do
	--                                    for j,_ in pairs(buf[akey[1] ]) do

	for _,j in pairs(buf[akey[1] ]) do
	--                                    for j,_ in pairs(buf[akey[1] ]) do
	end

								local L = amm.L[1] + (amm.L[2] - amm.L[1])*c
								for j,q in pairs(ain.base) do
									if ain.dir < 0 then

									local n = 0
									for _,j in pairs(buf[akey[1]]) do
	--                                    for j,_ in pairs(buf[akey[1]]) do

									for _,j in pairs(buf[akey[1]]) do
	--                                    for j,_ in pairs(buf[akey[1]]) do
										local w = awall[n+1] -- deepcopy(dsrc.afloor[akey[1]].awall[j])

										local w = awall[n+1] -- deepcopy(dsrc.afloor[akey[1]].awall[j])
										for dae,r in pairs(w.df) do
											w.df[dae] = {scale = r.scale}

									n = 1
									for _,j in pairs(buf[akey[1]]) do
	--                                    for j,_ in pairs(buf[akey[1]]) do

									for _,j in pairs(buf[akey[1]]) do
	--                                    for j,_ in pairs(buf[akey[1]]) do
	--                                        lo('?? inserting:'..(ij[2]+n), true)

								-- cleanup
								for j,w in pairs(floor.awall) do
									forestClean(w)

								end
								for j,w in pairs(newfloor.awall) do
									for dae,r in pairs(w.df) do

								for j,w in pairs(newfloor.awall) do
									for dae,r in pairs(w.df) do
										w.df[dae] = {scale = r.scale or 1}

								end
								for dae,r in pairs(newfloor.top.df) do
									newfloor.top.df[dae] = {scale = r.scale or 1}

									local buf = {}
									for i,r in pairs(desc.selection) do
										table.sort(r)

												U.dump(buftgt, '?? BT:')
										for i,r in pairs(buftgt) do
											ftgt = desc.afloor[i]

												lo('?? for_row:'..i..':'..tostring(desc)..':'..tostring(ftgt))
											for j,_ in pairs(r) do
												acol[#acol+1] = j

											lo('?? ftgt_pre:'..#acol..':'..jmi..':'..#ftgt.base)
										for o,j in pairs(acol) do
											if o > 1 then

										-- insert
										for n,j in pairs(acol) do

									local akeytgt = {}
									for k,r in pairs(buftgt) do
										akeytgt[#akeytgt+1] = k

									local awall = {}
									for _,j in pairs(buf[akey[1]]) do
		--                            for j,_ in pairs(buf[akey[1]]) do

									for _,j in pairs(buf[akey[1]]) do
		--                            for j,_ in pairs(buf[akey[1]]) do
											lo('?? for_wall:'..j)

										local w = awall[#awall]
										for dae,d in pairs(w.df) do
											w.df[dae] = {scale = d.scale}

		--                                    lo('?? iind:'..iind)
									for j,w in pairs(awall) do
										-- to base

								dnew.afloor[1].top.ij[1] = #akey - #dnew.afloor + 1
								for _,w in pairs(dnew.afloor[1].awall) do
									for dae,r in pairs(w.df) do

								for _,w in pairs(dnew.afloor[1].awall) do
									for dae,r in pairs(w.df) do
										w.df[dae] = {scale = w.df[dae].scale}

									if i == 1 then
										for j,w in pairs(desc.afloor[akey[i]].awall) do
											objDown(w)

--        U.dump(out.acorner, '?? AC2:')
		for _,e in pairs(out.acorner) do
			debugDrawer:drawLine(e.line[1], e.line[2], ColorF(1,1,0,1), 2)

--            U.dump(out.asplit, '?? mark_split:')
		for _,e in pairs(out.asplit) do
			debugDrawer:drawLine(e.line[1], e.line[2], ColorF(1,1,0,1))

	if out.fcyan then
		for _,v in pairs(out.fcyan) do
			debugDrawer:drawLine(v[1], v[2], ColorF(0,1,1,1), 4)

--				U.dump(s.aforest,'>> windowsToggle:'..tostring(s))
			for _,h in pairs(s.areg) do
				local av = U.spline2plane(h, s.ap, s.adist)

--            U.dump(desc.acorner_, '?? to_SUBTRACT:', true)
		for n,p in pairs(acorner) do
--            local isext

			local hit
			for m,q in pairs(desc.acorner_) do

--                local hit
				for i,a in pairs(p.list) do
					for j,b in pairs(q.list) do

				for i,a in pairs(p.list) do
					for j,b in pairs(q.list) do
						if a[1] == b[1] and a[2] == b[2] then

					local hit
					for i,a in pairs(p.list) do
						for j,b in pairs(q.list) do

					for i,a in pairs(p.list) do
						for j,b in pairs(q.list) do
							if a[1] == b[1] and a[2] == b[2] then

		if not daePath[tp..'_corner'] then return end
		for _,s in pairs(daePath[tp..'_corner']) do
			-- parse the name

	local p = U.proj2D(cw.pos)
	for _,d in pairs(awall) do
		if U.proj2D(d.pos):distance(p) < small_dist and math.abs(d.u:length() - cw.u:length()) < small_dist then

						local p = U.proj2D(cw.pos)
						for k,d in pairs(desc.afloor[i].awall) do
--								lo('?? if_POS:'..i..':'..k..':'..tostring(U.proj2D(d.pos))..':'..tostring(p)..':'..tostring(d.pilaster))

					U.dump(dfirst,'?? to_DEL:'..ndel)
				for f,jfirst in pairs(dfirst) do
					for j = 1,ndel do

--[[
				for _,d in pairs(adel) do
					local buf = {}

			local lastrow = 0
			for i,row in pairs(desc.selection) do
				for _,j in pairs(row) do

			for i,row in pairs(desc.selection) do
				for _,j in pairs(row) do
					if not p then

	--			U.dump(desc.selection, '?? for_SPLIT:'..lastrow)
			for i,s in pairs(asplit) do
--					U.dump(s, '??______************ for_S:'..i..':'..s[1]..'/'..lastrow)

						if U._PRD == 0 then list = deepcopy(daePath[tp]) end
					for i,pth in pairs(list) do
						local m = ddae[pth]

--            U.dump(desc.acorner_, '?? to_SUBTRACT:', true)
			for _,p in pairs(acorner) do
				for _,q in pairs(desc.acorner_) do

			for _,p in pairs(acorner) do
				for _,q in pairs(desc.acorner_) do
					if (p.pos-q.pos):length() < small_dist then

						local hit
						for i,a in pairs(p.list) do
							for j,b in pairs(q.list) do

						for i,a in pairs(p.list) do
							for j,b in pairs(q.list) do
								if a[1] == b[1] and a[2] == b[2] then

	for i=#list,1,-1 do
--	for i,d in pairs(list) do
		if ddae[list[i]] and ddae[list[i]].mute then

	local apair = T.pairsUp(base)
	for i,p in pairs(apair) do
		if ij[2] == p[1] then

    local base,imap = U.polyStraighten(floor.base)
    for k,v in pairs(imap) do
      if v == ij[2] then

    if apair then
      for i,p in pairs(apair) do
        local fit

	local vb,ve = sbase[U.mod(j,#sbase)], sbase[U.mod(j+1,#sbase)]
	for k,c in pairs(achild) do
		-- for top children

		-- for top children
		for _,ib in pairs({j,U.mod(j+1,#sbase)}) do
			-- if wall ends are in the child vertex mapping

--                            U.dump(c, '?? for_child: floor:'..i..' wall:'..j..':'..#aind)
				for _,ic in pairs(aind) do
					local pchild = cbase[k][ic] --c.base[ic]

	local rebuild
	for i,row in pairs(buf) do
		local floor = adesc[cedit.mesh].afloor[i]

		for _,r in pairs(row) do
--            local v = -U.perp(U.mod(r+1, base) - base[r]):normalized()

				w.id = nil
				for dae,d in pairs(w.df) do
					w.df[dae] = {scale = d.scale}

				w.id = nil
				for dae,d in pairs(w.df) do
					w.df[dae] = {scale = d.scale}

		-- move base
		for _,j in pairs(row) do
			-- walls to move

			local vb,ve = asbase[i][U.mod(j,#asbase[i])],asbase[i][U.mod(j+1,#asbase[i])]
			for k,c in pairs(floor.top.achild) do
				-- for top children

				-- for top children
				for _,ib in pairs({j,U.mod(j+1,#base)}) do
--                    U.dump(c.imap, '?? in_map:'..ib..' j:'..j)

--                            U.dump(c, '?? for_child: floor:'..i..' wall:'..j..':'..#aind)
						for _,ic in pairs(aind) do
							local pchild = acbase[i][k][ic] --c.base[ic]

				local av = {}
				for _,f in pairs(m.faces) do
					if #U.index(av, f.v) == 0 then

					U.dump(av, '?? h_IVERTS:'..tostring(w.u)..':'..tostring(dmesh[w.id]))
				for _,v in pairs(av) do
	--                    lo('?? for_v:'..tostring(m.verts[v+1]))

		lo('?? mat2xml.for_node:'..tostring(xml))
--		for i,k in pairs(xml.kids) do
--			lo(k.name)

	local list = {}
	for i,desc in pairs(ahouse) do
		editor.clearObjectSelection()

			--		U.dump(w.df, '?? for_wall:'..ij[1]..':'..ij[2])
				for pth,list in pairs(w.df) do
					for _,id in pairs(list) do

				for pth,list in pairs(w.df) do
					for _,id in pairs(list) do
						local item = dforest[id].item

			if desc.selection and tableSize(desc.selection) == 1 then
				for j,aw in pairs(desc.selection) do
					if not desc.aspline then desc.aspline = {} end --{aij={}} end

		-- clean folder
		for i,s in pairs(amesh) do
			lo('?? for_file:'..i..':'..s)

		scope = 'building'
		for _,d in pairs(adesc) do
			if not df[d.id] then df[d.id] = {list={},apos={}} end

			forBuilding(d, function(w, ij)
				for pth,list in pairs(w.df) do
					for _,id in pairs(list) do

				for pth,list in pairs(w.df) do
					for _,id in pairs(list) do
						local item = dforest[id].item

			local list = groupBat:getObjects()
			for _,o in pairs(list) do
				local om = scenetree.findObjectById(tonumber(o))

		local item,key
		for id,list in pairs(dpos) do
			for _,p in pairs(list) do

		for id,list in pairs(dpos) do
			for _,p in pairs(list) do
				for _,o in pairs(df[id].list) do

			for _,p in pairs(list) do
				for _,o in pairs(df[id].list) do
					local mtx = o.mtx

--[[
		for i,o in pairs(af) do
			item = fdata:createNewItem(o.obj, o.mtx, o.scale)

		local df = {}
		for _,d in pairs(sdesc) do
			for _,p in pairs(dpos[d.id]) do

		for _,d in pairs(sdesc) do
			for _,p in pairs(dpos[d.id]) do
				lo('?? topos:'..d.id..':'..tostring(p))

				forBuilding(d, function(w, ij)
					for pth,list in pairs(w.df) do
						for _,id in pairs(list) do

					for pth,list in pairs(w.df) do
						for _,id in pairs(list) do
				local item = dforest[id].item

		if false then
			for i,desc in pairs(adesc) do
				local ascan = W.buildingScan(desc, function(ascan)

			scope = nil
			for _,d in pairs(adesc) do
				local nm = 'b_'..d.id

				lo('?? deld:'..tostring(scope))
			for _,nm in pairs(list) do
				if not scenetree.findObject(nm) then

					local i = 1
					for id,d in pairs(adesc) do
						if i > istart then

]]
					for i,id in pairs(aid) do
							lo('??^^^^^^^^^^^^^^^^^^^ recover_house:'..id)

				local aid = {}
				for id,d in pairs(adesc) do
				d.id = nil

				end
				for i,id in pairs(aid) do
					lo('??^^^^^^^^^^^^^^^^^^^ recover_house:'..id)

				-- top childs to floor childs
				for _,c in pairs(floor.top.achild) do
			-- new floor child

					child.awall = {}
					for i,b in pairs(child.base) do
						child.awall[#child.awall+1] = deepcopy(floor.awall[c.imap[i]])

					for _,w in pairs(child.awall) do
						for dae,r in pairs(w.df) do

					for _,w in pairs(child.awall) do
						for dae,r in pairs(w.df) do
							w.df[dae] = {scale = w.df[dae].scale}

				end
				for j,w in pairs(floor.awall) do
					objDown(w)

			out.avedit = {}
			for i,a in pairs(cchild.base) do
				for _,c in pairs(achild) do

			for i,a in pairs(cchild.base) do
				for _,c in pairs(achild) do
					if _ ~= desc.afloor[cij[1] ].top.cchild then

					if _ ~= desc.afloor[cij[1] ].top.cchild then
						for j,b in pairs(c.base) do
							if (a-b):length() < small_dist then

				f.ij[1] = f.ij[1]+1
				for j,w in pairs(f.awall) do
					w.ij[1] = w.ij[1]+1

--                U.dump(desc.acorner_, '?? corners_shift:')
				for i,b in pairs(desc.acorner_) do
					for j,f in pairs(b.list) do

				for i,b in pairs(desc.acorner_) do
					for j,f in pairs(b.list) do
						f[1] = f[1] + 1

			if desc.acorner_ then
				for i,b in pairs(desc.acorner_) do
					for j,f in pairs(b.list) do

				for i,b in pairs(desc.acorner_) do
					for j,f in pairs(b.list) do
						f[1] = f[1] - 1

      if desc.afloor[2] then
        for _,w in pairs(desc.afloor[2].awall) do
          w.doorstairs = nil

			if floor.top.achild then
				for j,c in pairs(floor.top.achild) do
					cbase[#cbase+1] = U.clone(c.base)

--            U.dump(dmove, '?? to_move:')
		for ic,c in pairs(cedit.cval['DragPos'].cbase) do
			for ib,b in pairs(c) do

		for ic,c in pairs(cedit.cval['DragPos'].cbase) do
			for ib,b in pairs(c) do
				floor.top.achild[ic].base[ib] = b + dmove[ic][ib]

			out.ahole = {}
			for i,p in pairs(b.base) do
				out.ahole[#out.ahole+1] = cw.pos + p.x*cw.u:normalized() + p.y*cw.v:normalized()

				local floor = desc.afloor[#desc.afloor]
				for _,w in pairs(floor.awall) do
					forestClean(w)

			cedit.cval['DragVal'] = {}
			for i,f in pairs(desc.afloor) do
				cedit.cval['DragVal'][#cedit.cval['DragVal'] + 1] = {base = U.clone(f.base), achild = {}}

				local achild = cedit.cval['DragVal'][#cedit.cval['DragVal']].achild
				for i,c in pairs(f.top.achild) do
--                    cedit.cval['DragVal'][#cedit.cval['DragVal']].achild[cedit.cval['DragVal'][#cedit.cval['DragVal']].achild+1] = U.clone(c.base)

					local fchild = {}
					for i,d in pairs(f.achild) do
						fchild[i] = {}

						fchild[i] = {}
						for j,fc in pairs(d.afloor) do
							fchild[i][#fchild[i]+1] = U.clone(fc.base)

			local base = cedit.cval['DragVal'][ij[1]].base
			for j,_ in pairs(base) do
				desc.afloor[ij[1]].base[j] = center + U.vturn(base[j]-center, 2*math.pi*val/360)

--            if ij[1] == #desc.afloor and floor.top.achild then
				for k,c in pairs(floor.top.achild) do
--                    U.dump(c, '?? for_child:'..k)

			if floor.achild then
				for i,d in pairs(floor.achild) do
					local basechild = cedit.cval['DragVal'][ij[1]].fchild[i]

					local basechild = cedit.cval['DragVal'][ij[1]].fchild[i]
					for j,f in pairs(d.afloor) do
--                            U.dump(basechild, '?? fo_fch:'..i..':'..j)

			local u = (base[2]-base[1]):normalized()
			for j,_ in pairs(base) do
				desc.afloor[ij[1] ].base[j] = base[j] + u*(base[j]-center):dot(u)*(val-1)

			cedit.cval['DragVal'] = {}
			for i,f in pairs(desc.afloor) do
				cedit.cval['DragVal'][#cedit.cval['DragVal'] + 1] = U.clone(f.base)

			local u = (base[2]-base[1]):normalized()
			for j,_ in pairs(base) do
				desc.afloor[ij[1]].base[j] = base[j] + u*(base[j]-center):dot(u)*(val-1)

			cedit.cval['DragVal'] = {}
			for i,f in pairs(desc.afloor) do
				cedit.cval['DragVal'][#cedit.cval['DragVal'] + 1] = U.clone(f.base)

			local u = U.perp(base[2]-base[1]):normalized()
			for j,_ in pairs(base) do
				desc.afloor[ij[1]].base[j] = base[j] + u*(base[j]-center):dot(u)*(val-1)

			local cbase = {} -- children bases
			for f,_ in pairs(desc.selection) do
				abase[f] = U.clone(desc.afloor[f].base)

					cbase[f] = {}
					for j,c in pairs(desc.afloor[f].top.achild) do
						-- check consistency with top children

--                            U.dump(abase[f], '??^^^^^^^^^^^ for_fbase:'..j..':'..f)
						for a,isel in pairs(desc.selection[f]) do
							if c.base then

							if c.base then
								for b,ic in pairs(c.base) do
										lo('?? if_cross:'..a..':'..isel..':'..b..':'..tostring(abase[f][isel]))

					floor.top.shape = 'flat'
					for _,c in pairs(floor.top.achild) do
						scenetree.findObjectById(c.id):delete()

--                U.dump(desc.afloor[cij[1]].top.achild, '?? AW_children:')
			for _,wp in pairs(desc.afloor[cij[1]].awplus) do
				wp.dirty = true

			-- clear previous
			for j,w in pairs(cedit.cval['DragExt'].awall) do
				if w.id then

					cedit.cval['DragPos'] = {dpos={}} --, val = val}
					for i,d in pairs(s.aforest) do
						if d.key == cedit.forest or #U.index(cedit.aforest,d.key)>0 then

				end
				for i,d in pairs(s.aforest) do
					if d.key == cedit.forest or #U.index(cedit.aforest,d.key)>0 then

					cedit.cval['DragPos'] = {dpos={}} --, val = val}
					for i,d in pairs(s.aforest) do
						if d.key == cedit.forest or #U.index(cedit.aforest,d.key)>0 then

				end
				for i,d in pairs(s.aforest) do
					if d.key == cedit.forest or #U.index(cedit.aforest,d.key)>0 then

--					U.dump(desc.aspline,'?? win_bot:'..ij[2])
				for _,d in pairs(desc.aspline[ij[1]][ij[2]].aforest) do
					if d.key == cedit.forest then

				if w['win'..'_inf'] then
				for i,dae in pairs(w['win'..'_inf'].ddae) do
					for j,k in pairs(w.df[dae]) do

				for i,dae in pairs(w['win'..'_inf'].ddae) do
					for j,k in pairs(w.df[dae]) do
		--                U.dump(dforest[k], '?? in_dforest:'..j)

function DynamicProps:getFirstPropAvailable()
  for id, value in pairs(self.props) do
    if not value then

  local source
  for id, _ in pairs(self.props) do
    source = scenetree.findObjectById(id)

  for k, v in pairs(vehicle.nodes) do
    local x, y, z = jbeamUtils.getPosAfterNodeRotateOffsetMove(v, v.posX, v.posY, v.posZ)

  if not vehicle.hydros then return end
  for i, hydro in pairs(vehicle.hydros) do
    hydro.beamType = BEAM_HYDRO

  if not vehicle.ropes then return end
  for i, rope in pairs(vehicle.ropes) do
    rope.segments = rope.segments or 1

  local tbi = tableEndC(vehicle.triangles)
  for _, quad in pairs(vehicle.quads) do
    local tri1 = deepcopy(quad)

      local sp = tc:getSystemPacenotes()
      for key,val in pairs(sp) do
        for i,variant in ipairs(val) do

  local stage3 = {}
  for k,v in pairs(stage2) do
    table.insert(stage3, v)

  local wps = {}
  for i,pacenote in pairs(self.pacenotes.objects) do
    for j,wp in pairs(pacenote.pacenoteWaypoints.objects) do

  for i,pacenote in pairs(self.pacenotes.objects) do
    for j,wp in pairs(pacenote.pacenoteWaypoints.objects) do
      wps[wp.id] = wp

function C:getWaypoint(wpId)
  for i, pacenote in pairs(self.pacenotes.objects) do
    for i, waypoint in pairs(pacenote.pacenoteWaypoints.objects) do

  for i, pacenote in pairs(self.pacenotes.objects) do
    for i, waypoint in pairs(pacenote.pacenoteWaypoints.objects) do
      if waypoint.id == wpId then

  local lang_set = {}
  for _, codriver in pairs(self.codrivers.objects) do
    if not lang_set[codriver.language] then

  local languages = {}
  for lang, codrivers in pairs(lang_set) do
    table.insert(languages, { language = lang , codrivers = codrivers })

function C:setAllRadii(newRadius, wpType)
  for i, pacenote in pairs(self.pacenotes.objects) do
    pacenote:setAllRadii(newRadius, wpType)

function C:allToTerrain()
  for i, pacenote in pairs(self.pacenotes.objects) do
    pacenote:allToTerrain()

  local links = {}
  for _,lnk in pairs(self.graph.links) do
    if lnk.targetPin == self.pinInLocal[self.varName] then

  local links = {}
  for _,lnk in pairs(self.graph.links) do
    if lnk.targetPin == self.pinInLocal[self.varName] then

      table.clear(occlusionPixels)
      for id, transform in pairs(occlusionTransforms) do
        local x, y, width, height = transform[1], transform[2], transform[3], transform[4]

  for _, transform in pairs(occlusionTransforms) do
    --im.Text(string.format("Pixel: %d, %d, %d, %d", pixel[1], pixel[2], pixel[3], pixel[4]))

  if debugSettings.drawOcclusion then
    for id, transform in pairs(occlusionTransforms) do
      im.Text(string.format("Occ %s: %0.3f, %0.3f, %0.3f, %0.3f", id, transform[1], transform[2], transform[3], transform[4]))

  -- avg position
  for pid, _ in pairs(plvehicles) do
    local k = be:getPlayerVehicleID(pid)

  -- max distance
  for k, _ in pairs(plvehicles) do
    local v = map.objects[be:getPlayerVehicleID(k)]

  -- Loop through all spinners and update their timers
  for id, timer in pairs(spinnerTimers) do
    timer = timer + dtSim

  local minDistanceTemperature = 0
  for k, v in pairs(hotNodes) do
    local squareDistance = obj:nodeSquaredLength(k, cid)

  -- Particles --
  for hotcid, node in pairs(hotNodes) do
    if hotcid ~= currentNodeKey then

  if v.data.beams then
    for k, b in pairs(v.data.beams) do
      if b.containerBeam then

    local centreNodeDist = 100
    for _, node in pairs(v.data.nodes) do
      local nodeDist = sqrt((node.pos.x * node.pos.x) + (node.pos.y * node.pos.y) + (node.pos.z * node.pos.z))

  if wheels.wheels then
    for id, wd in pairs(wheels.wheels) do
      wheelNodes[wd.node1] = {wheelID = id, node1 = wd.node1, node2 = wd.node2}

  local possibleNodes = {}
  for k, n in pairs(flammableNodes) do
    if n and n.canIgnite and not wheelNodes[k] and n.intensity <= 0 then

  local possibleNodes = {}
  for k, n in pairs(flammableNodes) do
    if n and n.canIgnite and not wheelNodes[k] and n.intensity <= 0 then

local function igniteVehicle()
  for cid, _ in pairs(flammableNodes) do
    if not wheelNodes[cid] then --don't ignite wheelnodes right away to delay the tire popping a bit

local function explodeVehicle()
  for cid, node in pairs(flammableNodes) do
    if node.containerBeam then

local function extinguishVehicle()
  for cid, node in pairs(flammableNodes) do
    node.temperature = tEnv

local function extinguishVehicleSlowly()
  for _, node in pairs(flammableNodes) do
    node.chemEnergy = 0

  local latestReading = {}
  for _, device in pairs(powertrain.getDevices()) do
    local deviceData = {inputAV = device.inputAV, gearRatio = device.gearRatio, isBroken = device.isBroken, mode = device.mode}

      if lane.waypoints then
        for waypointType, waypoint in pairs(lane.waypoints) do
          convertedLane.waypoints[waypointType] = {

  for vehId, racer in pairs(dragData.racers) do
    if racer.timers and racer.timers.time_1_4 and racer.isPlayable then

          for i, racerInfo in ipairs(historyEntry.racerInfos) do
            for rVehId, rRacer in pairs(dragData.racers) do
              if rRacer.lane == racerInfo.laneNum then

  local result = {}
  for configHash, data in pairs(dialTimes) do
    result[configHash] = {

  local allHistory = {}
  for configHash, data in pairs(dialTimes) do
    if data.history then

    local res, _ = self.examples:getExamplesLookup()
    for r, e in pairs(res.beginner.examples) do
      table.insert(self._examplesSorted, e)

  for k, p in pairs(self.demoProjects) do
    if fancyIconButton('welcomeContentColumn2demo1' .. k, editor.icons.folder_open, editor.icons.folder, p.name, p.description) then

      local _, fn, ext = path.splitWithoutExt(vData.config.partConfigFilename)
      for k, c in pairs(mData.configs) do
        if fn == c then

  for k, v in pairs(device.torqueCurve) do
    if type(k) == "number" then

  device.energyStorageRegenRatios = {}
  for _, s in pairs(device.registeredEnergyStorages) do
    local storage = energyStorage.getStorage(s)

  local previousStorageCount = device.storageWithEnergyCounter
  for _, s in pairs(device.registeredEnergyStorages) do
    local storage = energyStorage.getStorage(s)

    local hasValidReactioNodes = true
    for _, v in pairs(torqueReactionNodes_nodes) do
      if type(v) ~= "number" then

  local points = {}
  for _, v in pairs(torqueTable) do
    table.insert(points, {v.rpm, v.torque})

    points = {}
    for _, v in pairs(regenTorqueTable) do
      table.insert(points, {v.rpm, v.torque})

  tempElectricalEfficiencyTable = {}
  for k, v in pairs(copy) do
    if type(k) == "number" then

  device.electricalEfficiencyTable = {}
  for k, v in pairs(tempElectricalEfficiencyTable) do
    device.electricalEfficiencyTable[k * 0.01] = v

    highestDetail = -1
    for k,v in pairs(shapeInfo.details) do
      if v.size < 0 then goto continue_info end

      comboSeqCtxTxt = ""
      for k,v in pairs(shapeInfo.sequences) do
        log("I","info.seq", dumps(k).."|"..dumps(v.name))

    f:write(string.format("function %s::onLoad(%%this)\n{\n", filenameNoExt))
    for k,v in pairs(meshConstructor.createMeshLOD) do
      if v.sloppy then

  local fdata = originalMaterial:getFieldsForEditor()
  for k,v in pairs(fdata) do
    if arrayFindValueIndex(skipFields,k) == false then

  end
  for k,v in pairs(fdata.Stages_beginarray.fields) do
    for i = 0, 3 do

  end
  for k,v in pairs(meshConstructor.createMeshLOD) do
    if v.dest == dest then

        -- im.Columns(2)
        -- for k,v in pairs(shapePrev:getMeshStat()) do
        --   im.Text(k)

          if data then
            for k, v in pairs(data) do
              if type(v) ~= 'table' then

        if meshConstructor and meshConstructor.createMeshLOD and not lodBrokenMesh then
          for k,v in pairs(meshConstructor.createMeshLOD) do
            local src = tostring(v.src)

      loadData.cargo = {}
      for key, fac in pairs(loadData.facilities) do
        fac.logisticGenerators = nil

  end
  for vehId, veh in pairs(vehs) do

        --for key, amount in pairs(elem.totalCargoSlots) do
        --  elem.usedCargoSlots[key] = 0

      -- check if all cargo was sent
      for key, val in pairs(vehCargoData) do
        if val == -1 then return end

      local ret = {}
      for _, list in pairs(vehCargoData) do
        for _, elem in ipairs(list) do

  local maxDelay = 0
  for _, delay in pairs(data) do
    maxDelay = math.max(delay, maxDelay)

      step.makeStepReturnTrueFunction(function()
        for vehId, data in pairs(data) do
          local veh = scenetree.findObjectById(vehId)

    -- 1s delay, no freeze
    for vehId, data in pairs(data) do
      local veh = scenetree.findObjectById(vehId)

  --if next(updatePerVehicle) then
  for vehId, data in pairs(updatePerVehicle) do
    local veh = scenetree.findObjectById(vehId)

    for _, con in pairs(updatePerVehicle[vehId]) do
      log("I","",string.format("Container %d => volume %0.1f | density: %0.1f",con.containerId, con.volume or 0, con.density or 1))

  local delayData = {}
  for vehId, data in pairs(updatePerVehicle) do
    delayData[vehId] = -1

  for vehId, data in pairs(updatePerVehicle) do
    local veh = scenetree.findObjectById(vehId)

      for key, val in pairs(delayData) do
        if val == -1 then return end

    local anyValue = false
    for key, value in pairs(loadData.penalty) do
      if value ~= 0 then

      for name, ap in pairs(fac.accessPointsByName) do
        local ps = ap.ps

          local pos = lastPsPos
          for name, ap in pairs(fac.accessPointsByName) do
            if ap.isInspectSpot then

        local fac = dGenerator.getFacilityById(elem.facId)
        for materialType, storage in pairs(fac.materialStorages) do
          if storage.isProvider then

    local fine = dVehicleTasks.getFineForAbandonAllVehicleTasks()
    for attKey, amount in pairs(fine) do
      penalty[attKey] = (penalty[attKey] or 0) + amount

  local fcts = {}
  for k,v in pairs(timings_tmp) do
    if calls_tmp[k] > 0 then

    local elements = getElementsForBrush(brushName)
    for id, elementName in pairs(elements) do
      forestBrushElements[id] = elementName

local function removeItemsActionUndo(actionData)
  for _, item in pairs(actionData.items) do
    editor.addForestItem(var.forestData, item)

local function removeItemsActionRedo(actionData)
  for _, item in pairs(actionData.items) do
    editor.removeForestItem(var.forestData, item)

local function addItemsActionUndo(actionData)
  for _, item in pairs(actionData.items) do
    editor.removeForestItem(var.forestData, item)

local function addItemsActionRedo(actionData)
  for _, item in pairs(actionData.items) do
    editor.addForestItem(var.forestData, item)

local function replaceItemsActionUndo(actionData)
  for i, item in pairs(actionData.newItems) do
    editor.removeForestItem(var.forestData, item)

  end
  for i, item in pairs(actionData.oldItems) do
    editor.addForestItem(var.forestData, item)

local function replaceItemsActionRedo(actionData)
  for _, item in pairs(actionData.oldItems) do
    editor.removeForestItem(var.forestData, item)

  end
  for _, item in pairs(actionData.newItems) do
    editor.addForestItem(var.forestData, item)

        local delItems = {}
        for _, item in pairs(itemsToDel) do
          table.insert(delItems, item)

        ---local forestData = forest:getData()
        ---for _, item in pairs(itemsToAdd) do
          --local uids = forestData:generateAndSetItemUid(itemKeys)

        local delItems = {}
        for _, item in pairs(itemsToDel) do
          table.insert(delItems, item)

            local delItems = {}
            for _, item in pairs(itemsToDel) do
              table.insert(delItems, item)

            local delItems = {}
            for _, item in pairs(itemsToDel) do
              table.insert(delItems, item)

  for i, beam in pairs(v.vdata.beams) do
    local id1 = beam.id1

  for mesh, d in pairs(meshes) do
    if meshNodeMap[mesh] then

  local parentage = {}
  for parent, children in pairs(slotMap) do
    for idx, child in ipairs(children) do

    if partNode.children then
      for _, child in pairs(partNode.children) do
        partTreeParser(child,partNode.chosenPartName)

  for part, data in pairs(slotMap) do
    if parentPart[part] ~= nil and parentPart[part] ~= '' then

      if data.slots ~= nil then
        for subPart, d in pairs(data.slots) do
          if parentPart[subPart] ~= nil and parentPart[subPart] ~= '' then

  local parent = {}
  for kn,vn in pairs(gltfRoot.nodes) do
    if rootNodes[kn-1] then

  -- end
  -- for kp,rootNode in pairs(rootNodes) do
  --   if rootNodes then

  -- log("I", logTag, "===================================  dump child")
  -- for k,v in pairs(gltfRoot.nodes) do
  --   log("I", logTag, dbgNodeName(gltfRoot,k-1) .. dumps(v.children))

  for kn,vn in pairs(gltfRoot.nodes) do
    if not parent[kn-1] then

  --log("D", logTag,"export image indexes "..dumps(materialObj.name))
  for k,v in pairs(gltfCurrentMaterial) do
    if k:endswith("Map") then

  local partToFlexMesh = {}
  for _, flexMesh in pairs(v.vdata.flexbodies or {}) do
    local path = flexMesh.partPath or ""

  end
  for _, prop in pairs(v.vdata.props or {}) do
    -- print("prop["..dumps(_)..dumps(prop.mesh))

  gltfRoot.scenes[1].nodes = {}
  for nodeID, root in pairs(rootNodes) do
    if root then

    local matNames = veh:getMaterialNames()
    for i,v in pairs(gltfRoot.materials) do
      gltfRoot.materials[i].name = matNames[v.extras.bngMaterialId+1]

  for i, e in pairs(gltfRoot.scenes[1].nodes) do
    local node = gltfRoot.nodes[e + 1]

    local totalBinBufSize = getStartByteBufferView(#binaryBuffers)
    for k,v in pairs(gltfRoot.bufferViews) do
      if v.buffer ~= 0 then

  local function gather_from_table(tbl, class_name, is_static)
    for key, value in pairs(tbl) do
      if type(key) == "string" and type(value) == "function" then

  -- Iterate over global variables
  for global_key, global_value in pairs(_G) do
    -- Ignore the global variable named "extensions"

local function onUpdate()
  for vehId, data in pairs(flaggedVehicles) do
    local obj = getObjectByID(vehId)

local function deleteFlaggedVehicles()
  for vehId, _ in pairs(flaggedVehicles) do
    deleteVehicle(vehId)

local function setFieldsRedo(data)
  for idx, _ in pairs(data.newDataMap) do
    data.self.path.pathnodes.objects[idx][data.field] = data.newDataMap[idx]

  local oldDataMap = {}
  for idx, _ in pairs(newDataMap) do
    oldDataMap[idx] = self.path.pathnodes.objects[idx][field]

    local allTransforms = {}
    for _, pn in pairs(self.path.pathnodes.objects) do
      local transforms = pn:getSideTransforms(self:getSideTransformParameters())

    local newDataMap = {}
    for _, node in pairs(self.path.pathnodes.objects) do
      newDataMap[node.id] = core_terrain.getTerrainHeight(node.pos)

    local newDataMap = {}
    for _, node in pairs(self.path.pathnodes.objects) do
      if node.hasNormal then

    local newDataMap = {}
    for _, node in pairs(self.path.pathnodes.objects) do
      newDataMap[node.id] = nodeSize[0]

  if im.Button("Remove Redundant BeamNGWaypoints") then
    for _, node in pairs(self.path.pathnodes.objects) do
      if scenetree.findObject(node.name) then

  if im.Button("Align All Pathnodes to Grid") then
    for _, node in pairs(self.path.pathnodes.objects) do
      node.pos.x = round(node.pos.x)

  for _, wp in pairs(currentScenario.lapConfig) do
    local n = currentScenario.nodes[wp]

        local lastWpp = nil
        for _, wpp in pairs(path) do
          if wpp ~= lastWpp then

    local i = 0
    for _, wp in pairs(currentScenario.lapConfig) do
      i = i + 1

    local lastwpdStr = nil
    for _, wp in pairs(currentScenario.debugPath) do
      local wpd = currentScenario.debugNodes[wp]

  local rootGraphs = {}
  for _, graph in pairs(self.mgr.graphs) do
    if graph.type == "graph" and graph:getParent() == nil and (not self.mgr.stateGraph or graph.id ~= self.mgr.stateGraph.id) then

  if im.BeginCombo("Target Graph", label) then
    for _, graph in pairs(rootGraphs) do
      if im.Selectable1(graph.id .. "-"..graph.name, graph.id == id) then

  local names = {}
  for n, pin in pairs(self.pinOut) do
    table.insert(names,n)

  local camData = tech_cameraPreview.getCamData()
  for id, cam in pairs(camData) do
    if not cam.visualize[0] then

  local camData = tech_cameraPreview.getCamData()
  for id, cam in pairs(camData) do
    if cam.visualize[0] then

    end
    for id, cam in pairs(camData) do
      im.Text(tech_sensors.getCameraSensorName(cam.id))

  local variety = 0
  for _ in pairs(uniqueStunts) do
    variety = variety + 1

  for name, gm in pairs(groundModels) do
    tbl.colors[name] = {}

  if tbl then
    for name, color in pairs(tbl.colors) do
      if groundModels[name] then

  if #groundModels[name].aliases > 0 then
    for _,alias in pairs(groundModels[name].aliases) do
      be:setGroundModel(alias, gm.data)

  local data = {}
  for k,v in pairs(groundModels) do
    data[k] = {}

    data[k] = {}
    for propertyName, propertyVal in pairs(v.cdata) do
      data[k][propertyName] = propertyVal[0]

      if im.SmallButton("Enable All") then
        for _,k in pairs(gms) do
          groundModels[k].active[0] = true

      if im.SmallButton("Disable All") then
        for _,k in pairs(gms) do
          groundModels[k].active[0] = false

      for _,k in pairs(gms) do
        local v = groundModels[k]

            if #v.aliases > 0 then
              for _, name in pairs(v.aliases) do
                groundModels[name].active[0] = groundModels[k].active[0]

      -- no groundtype filtering: draw them all!
      for _,k in pairs(gms) do
        local gm = groundModels[k]

  found = true
    for k,v in pairs(item) do
      found = found and valueObj[k] == v

  if onEventData then
    for key,entry in pairs(onEventData) do
      if key == 'remove' then

      if key == 'remove' then
        for subKey,data in pairs(entry) do
          if subKey == 'gold' or subKey == 'silver' or subKey == 'bronze' then

            if earnedMedal and subKey == earnedMedal then
              for invType,value in pairs(data) do
                processTable('remove', invType, value)

  local trackersToUnload = {}
  for trackerName, _ in pairs(trackingExtensions) do
    local priority = trackerPriorities[trackerName] or 500

      local numOfTrapsTriggered = 0
      for name, velocityMilestone in pairs(velocityMilestonesByTrapName) do
        if milestones.saveData.general[velocityMilestone.id].notificationStep > 0 then

  local res
  for nid, _ in pairs(nodes) do
    if distances[nid] < min or not res then

  -- remove all nodes that are too far away
  for otherNid, data in pairs(mapNodes) do
    if data.pos:squaredDistance(node.pos) > square(maxConnectionRenderDistance) then

      -- remove the links
      for otherNid2, _ in pairs(data.links) do
        if nodesToCheck[otherNid2] then

    for neighbor, otherLinkData in pairs(nextNodeData.links) do
      if nodesToCheck[neighbor] and otherLinkData.inNode == nextNid then

  -- Add distances to the links that are close enough, but not on any shortest route from any node
  for otherNid, data in pairs(mapNodes) do
    if distancesOfLinks[otherNid] then

    if distancesOfLinks[otherNid] then
      for neighbor, linkData in pairs(data.links) do
        if distancesOfLinks[neighbor] and not distancesOfLinks[otherNid][neighbor] then

  local result
  for nid1, nodeLinks in pairs(editor.selection.stLink) do
    for nid2, _ in pairs(nodeLinks) do

  for nid1, nodeLinks in pairs(editor.selection.stLink) do
    for nid2, _ in pairs(nodeLinks) do
      if result then return nil end

local function isLinkSelectionEmpty()
  for nid1, nodeLinks in pairs(editor.selection.stLink) do
    for nid2, _ in pairs(nodeLinks) do

  for nid1, nodeLinks in pairs(editor.selection.stLink) do
    for nid2, _ in pairs(nodeLinks) do
      return false

    -- Find which road this link belongs to
    for roadId, road in pairs(roads) do
      local controlPoints = road.controlPoints

local function changeNodeFieldActionUndo(actionData)
  for nid, _ in pairs(actionData.nids) do
    setNodeField(nid, actionData.fieldName, actionData.oldValues[nid])

local function changeNodeFieldActionRedo(actionData)
  for nid, _ in pairs(actionData.nids) do
    setNodeField(nid, actionData.fieldName, actionData.newValues[nid])

  local result = {}
  for nid, _ in pairs(nids) do
    result[nid] = mapNodes[nid].links

  nids[nid] = true
  for nid1, links in pairs(getConnectedLinks(nids)) do
    for nid2, link in pairs(links) do

  for nid1, links in pairs(getConnectedLinks(nids)) do
    for nid2, link in pairs(links) do
      deleteLink(nid1, nid2)

  if actionData.linkInfos then
    for nid1, links in pairs(actionData.linkInfos) do
      for nid2, linkInfo in pairs(links) do

    for nid1, links in pairs(actionData.linkInfos) do
      for nid2, linkInfo in pairs(links) do
        deleteLink(nid1, nid2)

  if actionData.linkInfos then
    for nid1, links in pairs(actionData.linkInfos) do
      for nid2, linkInfo in pairs(links) do

    for nid1, links in pairs(actionData.linkInfos) do
      for nid2, linkInfo in pairs(links) do
        mapNodes[nid1].links[nid2] = linkInfo

  -- Draw road segments connected to this node
  for roadId, road in pairs(roads) do
    local controlPoints = road.controlPoints

  mapNodes = {}
  for nid, node in pairs(rawNodes) do
    mapNodes[nid] = {

  -- Add links temporarily for road tracing
  for nid1, node in pairs(rawNodes) do
    for nid2, link in pairs(node.links) do

  for nid1, node in pairs(rawNodes) do
    for nid2, link in pairs(node.links) do
      -- Create two-way links for easier traversal

    for linkedNodeId, linkData in pairs(node.links) do
      if linkedNodeId ~= prevNodeId and

    if not prevNodeId then
      for linkedNodeId, _ in pairs(mapNodes[currentNodeId].links) do
        if not processedLinks[currentNodeId .. "-" .. linkedNodeId] and

  -- Process all nodes and links to create roads
  for nodeId, node in pairs(mapNodes) do
    -- Find unprocessed links from this node

    -- Find unprocessed links from this node
    for linkedNodeId, _ in pairs(node.links) do
      if not processedLinks[nodeId .. "-" .. linkedNodeId] and

  -- Clear temporary links from mapNodes
  for nid, node in pairs(mapNodes) do
    node.links = {}

    mapNodes = loadedNavgraph
    for nid1, node in pairs(mapNodes) do
      for nid2, link in pairs(node.links) do

    for nid1, node in pairs(mapNodes) do
      for nid2, link in pairs(node.links) do
        mapNodes[nid2].links[nid1] = link

          local roadsArray = {}
          for roadId, road in pairs(roads) do
            -- Apply filter if any

        for roadId, road in pairs(roads) do
          local controlPoints = road.controlPoints

        -- First add all nodes to the quadtree
        for nid, n in pairs(mapNodes) do
          local nPos = n.pos

        -- Then add edges from roads
        for roadId, road in pairs(roads) do
          local controlPoints = road.controlPoints

        for otherNid, link in pairs(node.links) do
          if link.inNode == nid then

          if not tableIsEmpty(editor.selection.stNode) then
            for nodeId, _ in pairs(editor.selection.stNode) do
              nodeOldPositions[nodeId] = mapNodes[nodeId].pos

          local newValues = {}
          for nid, _ in pairs(editor.selection.stNode) do
            newValues[nid] = vec3(mapNodes[nid].pos)

            if core_forest.getForestObject() then core_forest.getForestObject():disableCollision() end
            for nodeId, _ in pairs(editor.selection.stNode) do
              local rayDist = castRayStatic(nodeOldPositions[nodeId] + nodeOffset + upVector, downVector, 10)

  for nid, _ in pairs(mapNodes) do
    editor.selection.stNode[nid] = true

    local nodeInfos = {}
    for nid, _ in pairs(editor.selection.stNode) do
      local nodeInfo = {nid = nid, pos = vec3(mapNodes[nid].pos), radius = mapNodes[nid].radius, links = deepcopy(mapNodes[nid].links)}

    local linkInfos = {}
    for nid1, nodeLinks in pairs(editor.selection.stLink) do
      for nid2, _ in pairs(nodeLinks) do

    for nid1, nodeLinks in pairs(editor.selection.stLink) do
      for nid2, _ in pairs(nodeLinks) do
        if not linkInfos[nid1] then linkInfos[nid1] = {} end

    local mapNodesCopy = deepcopy(mapNodes)
    for nid1, node in pairs(mapNodes) do
      for nid2, link in pairs(node.links) do

    for nid1, node in pairs(mapNodes) do
      for nid2, link in pairs(node.links) do
        if link.inNode ~= nid1 then

  --Get the names of the rewards
  for _, tierData in pairs(rewards) do
    for _, reward in ipairs(tierData) do

  --dump("getting skills for " .. branchId)
  for _, skill in pairs(career_branches.getSortedBranches()) do
    --dump(branchId .. " is a skill of " .. skill.id.." / "..dumps( skill.parentId))

  }
  for key, value in pairs(fac.providedSystemsLookup) do
    if value then

  for key, value in pairs(fac.receivedSystemsLookup) do
    if value then

  local ret = {}
  for key, value in pairs(facility.providedSystemsLookup) do
    if value then

  end
  for key, value in pairs(facility.receivedSystemsLookup) do
    if value then

  for _, subBranch in pairs(career_branches.getSortedBranches()) do
    if subBranch.parentId == branchId then

        local prefix = '{"'
        for kk, vv in pairs(v) do
          bufTmp:put(prefix, type(kk) == 'string' and escapeString(kk) or kk, '":')

        local tableKeys = tableKeysSorted(v)
        for _, kk in pairs(tableKeys) do
          local vv = v[kk]

  if not data then return nil end
  for k,v in pairs(data) do
    for k2,v2 in pairs(v) do

  for k,v in pairs(data) do
    for k2,v2 in pairs(v) do
      if k2 > 1 then

  local tblSize = #tbl
  for k, _ in pairs(tbl) do
    if type(k) ~= 'number' or k < 1 or k > tblSize then return false end

  local keysidx = 0
  for k in pairs(tbl) do
    keysidx = keysidx + 1

  local res = target or table.new(#tbl, 4)
  for _, tb in pairs(tbl) do
    res[tb] = 1

function tableMerge(dst, src)
  for k, v in pairs(src) do
    dst[k] = v

function tableMergeRecursive(t1, t2)
  for k, v in pairs(t2) do
    if type(v) == "table" and type(t1[k]) == "table" then

function tableMergeRecursiveArray(t1, t2)
  for k, v in pairs(t2) do
    if type(v) == "table" and type(t1[k]) == "table" then

  local count = 0
  for _ in pairs(tbl) do
    count = count + 1

function tableFindKey(t, element)
  for k, v in pairs(t) do
    if v == element then

  element = string.lower(element)
  for _, value in pairs(table) do
    if string.lower(value) == element then

  local depth = 1
  for k, v in pairs(tbl) do
    if type(k) == "table" then

    local copy = table.new(#orig, 0)
    for k, v in pairs(orig) do
      copy[k] = v

  lookup_table[object] = new_table
  for index, value in pairs(object) do
    if type(index) == 'table' then

    profilerPushEvent("readFiles readClose batch")
    for filename, f in pairs(batchFiles) do
      if f ~= nil then

local function tableMergeExceptFunc(dst, src)
  for k, v in pairs(src) do
    dst[k] = type(v) ~= "function" and v or nil

  local tmp = {}
  for k, v in pairs(package.loaded) do
    if isPackage(k, v) and type(v) == 'table' and (v['onDeserialized'] ~= nil or v['onSerialize'] ~= nil) then

  for k,v in pairs(package.loaded) do
    if isPackage(k, v) and (filter == nil or k == filter) and type(v) == 'table' and (v['onDeserialized'] ~= nil or v['onDeserialize'] ~= nil) and data[k] ~= nil then

  local dkeys = {}
  for k in pairs(d) do table.insert(dkeys, k) end
  table.sort(dkeys)

  -- save the text
  for _, k in pairs(dkeys) do
    local v = d[k]

      if type(incl) == "table" then
        for kk, vv in pairs(v) do
          if incl[kk] then

      else
        for kk, vv in pairs(v) do
          bufTmp:putf(type(kk) == 'string' and "%q;" or "%s;", kk)

      local prefix = "{"
      for kk, vv in pairs(v) do
        if kk == arrayidx then

  for _, k in pairs(keys) do
    local v = tbl[k]

local function _unflattenTable_rec(tbl, tableRegister, path)
  for k, v in pairs(tbl) do
    if type(v) == 'table' then

  local i = 0
  for k in pairs(t) do
    i = i + 1

function C:_executionStarted()
  for _, p in pairs(self.pinOut) do
    p.value = false

function C:_executionStarted()
  for _, p in pairs(self.pinOut) do
    p.value = false

function C:buttonPushed(action)
  for nm, pn in pairs(self.pinOut) do
    self.pinOut[nm].value = nm == action

    self:reset()
    for _,pn in pairs(self.pinOut) do
      pn.value = false

  local data = jsonReadFile(file)
  for type, listKey in pairs(facilityTypeToListName) do
    for i, f in ipairs(data[listKey] or {}) do

    facilitiesByLevel[levelName] = {}
    for _, listKey in pairs(facilityTypeToListName) do facilitiesByLevel[levelName][listKey] = {} end

    -- put in the default values for this facility, if the facility itself did not define it
    for key, value in pairs(facilityPoiDefaults[f.type]) do
      e[key] = f[key]

  local children = {}
  for k, v in pairs(node) do
    if type(v) == 'table' then

local function doesCollectionContainSegment(collection, testSeg)
  for _, trialSeg in pairs(collection) do
    local matches = 0

    local matches = 0
    for _, v1 in pairs(trialSeg) do
      for _, v2 in pairs(testSeg) do

    for _, v1 in pairs(trialSeg) do
      for _, v2 in pairs(testSeg) do
        if v1 == v2 then

  for headKey, _ in pairs(graph) do
    local successors = getChildren(graph[headKey])

    local successors = getChildren(graph[headKey])
    for childKey, _ in pairs(successors) do
      local currentPath = { headKey }

        local allVisited = true
        for k, _ in pairs(nextSuccessors) do
          if not doesSegmentContainKey(currentPath, k) then

        local found = false
        for k, _ in pairs(nextSuccessors) do
          if not doesSegmentContainKey(currentPath, k) then

  local id = 0
  for k, v in pairs(coords3d) do
    keysToNodeMap[k] = k

    if self.data.debug and closestWheels then
      for k, v in pairs(closestWheels) do
          -- Line from each closest wheel to start line

  local res = {}
  for _, entry in pairs(tbl) do
    if type(entry) == 'function' and not visitedEntries[tostring(entry)]  then

  local snapshot = { tables = {}, tablesTmp = {}, vars = {}, extensions = {} }
  for k, v in pairs(_G) do
    if (type(v) == 'table' and (rawget(v, '___type') or rawget(v, '___getters'))) or type(v) == 'function' or k == '_G' or k == 'extensions' or k == 'package' then goto continue end

  -- now cleanup the tables
  for k, v in pairs(snapshot.tablesTmp) do
    if v.module and v.module.__extensionName__ then

local function _tableFindRecursion(tbl, res, path)
  for k, v in pairs(tbl) do
    if type(v) == 'table' then

  local dupeCount = 0
  for k, v in pairs(res) do
    if #v > 1 then

  local vehiclesUsedPerStar = saveData.vehiclesUsedPerStar or {}
  for star, achieved in pairs(attempt.unlockedStars or {}) do
    if achieved then

  local requests_pub = {}
  for id, r in pairs(requests) do
    requests_pub[id] = r.pub

  local data2display = {}
  for _, data in pairs(storedMessages) do
    if data.uid and hidden_ids[data.uid] then

  for _, cmd in pairs(data.cmds) do
    if cmd.type == 'message' then

local function changeMarkerFieldActionRedo(actionData)
  for index, values in pairs(actionData.markerValues) do
    actionData.path.markers[index][actionData.field] = values.new

local function changeMarkerFieldActionUndo(actionData)
  for index, values in pairs(actionData.markerValues) do
    actionData.path.markers[index][actionData.field] = values.old

  for k, v in pairs(storage.nodes) do
    obj:setNodeMass(k, v + storage.storedEnergy * storage.nodeMassCoef)

  --apply final weight as soon as possible
  for k, v in pairs(storage.nodes) do
    obj:setNodeMass(k, v + storage.storedEnergy * storage.nodeMassCoef)

  if jbeamData.nodes and jbeamData.nodes._engineGroup_nodes then
    for _, n in pairs(jbeamData.nodes._engineGroup_nodes) do
      storage.nodes[n] = v.data.nodes[n].nodeWeight --save initial mass as the offset for the node weights

  --apply final weight as soon as possible
  for k, v in pairs(storage.nodes) do
    obj:setNodeMass(k, v + storage.storedEnergy * storage.nodeMassCoef)

  local min = math.huge
  for _,node in pairs(nodesTbl) do
    totalWeight = totalWeight + obj:getNodeMass(node.cid)

  automaticHandling.availableModeLookup = {}
  for _, v in pairs(automaticHandling.availableModes) do
    automaticHandling.availableModeLookup[v] = true

    fg = core_flowgraphManager.loadManager(sc.track.flowgraph.file)
    for name, value in pairs(sc.track.flowgraph.variables or {}) do
      fg.variables:changeBase(name, value)

  if sc.generatedNodes then
    for k, v in pairs(sc.generatedNodes) do
      sc.nodes[k] = v

  if sc.track.reverse then
    for _, node in pairs(sc.nodes) do
      if node.rot ~= nil then

  -- Reset debug histories
  for _, historyData in pairs(debugHistories) do
    historyData.data = {}

  random = getBlueNoise1d(random)
  for _, scannerData in pairs(scanners) do

      -- remove oldest data
      for _, historyData in pairs(debugHistories) do
        if historyData.data and historyData.data[maxHistorySize] then

        im.BeginChild1("Debug Graph", im.ImVec2(im.GetContentRegionAvailWidth(), 400), true)
        for _, historyData in pairs(debugHistories) do
          im.PushStyleColor2(im.Col_Text, im.ImVec4(historyData.color[1], historyData.color[2], historyData.color[3], historyData.color[4]))

        local i = 1
        for _, historyData in pairs(debugHistories) do
          chartData[i] = {}

  local storages = energyStorage.getStorages()
  for _, storage in pairs(storages) do
    --filter for electric batteries

local function updateStreams()
  for _, moduleID in pairs(moduleIdx) do
    if settings.useModule[moduleID] then

local function createCSVs()
  for _, moduleID in pairs(moduleIdx) do
    local header = getCSVHeader(moduleID)

local function initOutput()
  for _, moduleID in pairs(moduleIdx) do
    local fpath = settings.outputDir .. "\\" .. moduleID .. ".csv"

local function flushOutputStream()
  for _, moduleID in pairs(moduleIdx) do
    local fpath = outputStreams[moduleID].fpath

  for _, moduleID in pairs(moduleIdx) do
    settings.useModule[moduleID] = true

  for _, moduleID in pairs(moduleIdx) do
    if s.useModule[moduleID] ~= nil then

  -- for moduleID, useModule in pairs(settings.useModule) do
  --     log("D", logTag, moduleID..": "..tostring(useModule))

  for moduleID, useModule in pairs(settings.useModule) do
    s.useModule[moduleID] = useModule

    if self.pinIn.propsIds.value then
      for k,v in pairs(self.pinIn.propsIds.value) do
        if cols[v] then

    if iconRendererObj then
      for id, data in pairs(self.iconDataById or {}) do
        data.color = ColorI(0,0,0,0)

    if iconRendererObj then
      for id, _ in pairs(self.iconDataById or {}) do
        iconRendererObj:removeIconById(id)

  local blanks = 0
  for k, v in pairs(self.materialsToTextureMaps) do
    if not v then -- if material to texture map entry is still false

  self.done = false
  for _, p in pairs(self.pinOut) do
    p.value = false

      local unflattenedSettings = {}
      for k, v in pairs(mission.lastUserSettings) do
        table.insert(unflattenedSettings, {key = k, value = v})

    for _, pin in pairs(self.pinOut) do
      if pin.type == 'flow' then

  else
    for _, pin in pairs(self.pinOut) do
      if pin.type == 'flow' then

  self.mgr._fgTutoTestCarsStep.getCarBySortedId = function(id)
    for _,car in pairs(self.mgr._fgTutoTestCarsStep.carsData) do
      if car.id == id then return car end

  clearCFilter(filter)
  for actionGroupName, filtered in pairs(blockedActionGroups[filter]) do
    if filtered then

local function isActionBlocked(actionName)
  for filter, actions in pairs(blockedActions) do
    if actions[actionName] then

  for _, br in pairs(career_branches.getSortedBranches()) do
    if not br.isSkill then

function C:reset()
  for _, pin in pairs(self.pinOut) do
    pin.value = false

  self.pinOut.isTouching.value = false
  for k, v in pairs(self.points) do
    local dist = v.pos:distance(self.center)

  if self.active and self.pinIn.debugMode.value then
    for k, v in pairs(self.points) do
      local color = v.hit and ColorF(1, 0, 0, 1) or ColorF(0, 1, 0, 0.5)

      for inventoryId, transform in pairs(inventoryData.spawnedPlayerVehicles) do
        inventoryId = tonumber(inventoryId)

  local callbackCounter = 0
  for vehId, inventoryId in pairs(vehIdToInventoryId) do
    setVehicleDirty(inventoryId)

local function checkSaveFinished(currentSavePath, oldSaveDate)
  for _, fin in pairs(finishedSaveTasks) do
    if not fin then

  for id, vehicle in pairs(vehiclesCopy) do
    if dirtiedVehicles[id] or not vehicle.dirtyDate then

  data.spawnedPlayerVehicles = {}
  for inventoryId, vehId in pairs(inventoryIdToVehId) do
    local veh = getObjectByID(vehId)

  local ownedVehiclesAmount = 0
  for inventoryId, vehicle in pairs(vehicles) do
    if vehicle.owned and not vehicle.takesNoInventorySpace then ownedVehiclesAmount = ownedVehiclesAmount + 1 end

      local vehiclesToTeleportToGarage = {}
      for inventoryId, location in pairs(loadedVehiclesLocations) do
        local vehInfo = vehicles[inventoryId]

        function (job)
          for inventoryId, location in pairs(vehiclesToTeleportToGarage) do
            local veh = getObjectByID(location.vehId)

  if sellAllVehicles then
    for inventoryId, vehicle in pairs(vehicles) do
      if vehicle.owned then

  local res = {}
  for inventoryId, vehId in pairs(inventoryIdToVehId) do
    spawnedVehicles[inventoryId] = getObjectByID(vehId)

  for _, zone in ipairs(zones) do
    for inventoryId, veh in pairs(spawnedVehicles) do
      if intersecting then

  local inventoryIdsInGarage = getVehiclesInGarage(garage, true)
  for otherInventoryId, _ in pairs(inventoryIdsInGarage) do
    if otherInventoryId ~= inventoryId then

  for otherInventoryId, _ in pairs(inventoryIdsInGarage) do
    if otherInventoryId ~= inventoryId then

  for inventoryId, vehicle in pairs(vehicles) do
    data.vehicles[tostring(inventoryId)] = getVehicleUiData(inventoryId, inventoryIdsInGarage)

  for inventoryId, vehInfo in pairs(vehicles) do
    if vehInfo.timeToAccess then

  local inventoryIdsList = {}
  for inventoryId, _ in pairs(inventoryIdsInGarage) do
    table.insert(inventoryIdsList, inventoryId)

  if next(inventoryIdToVehId) then
    for invId, vehId in pairs(inventoryIdToVehId) do
      if be:getPlayerVehicleID(0) ~= vehId then -- don't display the current player's vehicle

    for i = old, new+1, -1 do
      for _, lnk in pairs(self.graph.links) do
        if lnk.sourcePin == self.pinInLocal['message_'..i] then

		local order = {}
		for name, value in pairs(args.properties) do
			assert(type(name) == "string", "expecting property name to be a string: "..tostring(name))

		local order = {}
		for name, val in pairs(args.user_properties) do
			local ntype = type(name)

      im.Columns(2, "AudioTable")
      for i, v in pairs(filter) do
        for bi, val in ipairs(editor_suspensionAudioDebug.beamSounds) do

  local ctr = 1
  for _, wheel in pairs(wheels.wheels) do
    wNodePos[ctr] = obj:getNodePosition(wheel.node1)

local function electricsName2Id(name)
  for k, _ in pairs(electrics.values) do                                                            -- First check the first-level keys (which the name already is).
    if k == name then

local function powertrainName2Ids(name)
  for k, dev in pairs(powertrain.getDevices()) do
    if string.find(name, dev.name) then

  local wheelIds, wOrderCtr = wheelIds, 1
  for k, _ in pairs(wheelIds) do
    wheelsOrder[wOrderCtr] = k

  local ctr = 1
  for _, v in pairs(dTable) do
    inDMap[ctr] = v

  ctr = 1
  for _, v in pairs(wTable) do
    inWMap[ctr] = v

  local propulsionTorques = inTorques[1]
  for k, _ in pairs(pTorqueKeys) do                                                                 -- Set wheel propulsion torque only if set to be controlled by 3rd party.
    local wheel = wheelRotators[k]

  local brakeTorques = inTorques[2]
  for k, _ in pairs(bTorqueKeys) do                                                                 -- Set wheel braking torque only if set to be controlled by 3rd party.
    wheelRotators[k].desiredBrakingTorque = -brakeTorques[k]

  local frictionTorques = inTorques[3]
  for k, _ in pairs(fTorqueKeys) do                                                                 -- Set wheel friction torque only if set to be controlled by 3rd party.
    wheelRotators[k].frictionTorque = frictionTorques[k]

  local avgWheelPositions = {[-1] = vec3(), [1] = vec3()}
  for wheelSideIndex, wheelSide in pairs(relevantWheels) do
    for _, wheel in ipairs(wheelSide.wheels) do

  for wheelSideIndex, avgWheelPosition in pairs(avgWheelPositions) do
    local wheelVector = avgWheelPosition - avgDiffPosition --create a vector from our "center" to the wheel

  if self.missionTypeData then
    for key, value in pairs(self.missionTypeData) do
      -- Exclude complex data structures that flowgraph can't handle

      }
      for _, c in pairs(v.configs) do
        local passConfig = true

  local removalsNested = {}
  for configKey, _ in pairs(manualRemovals or {}) do
    local model, config = configKey:match("^([^/]+)/(.+)$")

      local selectedOptions = {}
      for option, selected in pairs(filter.values) do
        if selected and option ~= 'Other...' then

  for cbindex in pairs(cbs) do
    if not cbs[cbindex].trigger or newentry.value >= cbs[cbindex].trigger then

  for e in pairs( target ) do
    if target[e].trigger == trigger and target[e].func == callbackFunction then

        if im.TreeNode1("Timers") then
          for k,v in pairs(timers) do
            im.TextUnformatted(k..": "..dumps(v))

      if im.BeginTabItem("entries") then
        for k,v in pairs(fileData.entries) do
          if v.max then

        if fileDataCareer then
          for k,v in pairs(fileDataCareer.entries) do
            if v.max then

        if im.TreeNode1("callbacks general") then
          for k,v in pairs(callbacks) do
            im.TextUnformatted(k..": v="..dumps(v))

        if im.TreeNode1("callbacks career") then
          for k,v in pairs(callbacksCareer) do
            im.TextUnformatted(k..": v="..dumps(v))

local function forceTimerUpdate()
  for k in pairs(timers) do
    _timerSave(k)

  for _,wp in pairs(self.pacenoteWaypoints.objects) do
    foundTypes[wp.waypointType] = true

function C:onSerialize()
  for lang,langData in pairs(self.notes) do
    -- convert from old to new file format.

function C:upgradeFromV2ToV3()
  for lang,langData in pairs(self.notes) do
    local freeformnote = langData.note

function C:matchesSearchPattern(searchPattern)
  for lang,note in pairs(self.notes) do
    local fullNote = self:noteOutputFreeform(lang)

for _, discover in pairs(freeroamExperiences) do
  table.insert(D.pageInfo.sections[1].discoverIds, discover.id)

end
for _, mission in pairs(missions) do
  table.insert(D.pageInfo.sections[2].discoverIds, mission.id)

		if rest then
			for _,i in pairs(rest) do
				dbase[#dbase+1] = dbasepre[i]

			end
			for _,i in pairs(chunk) do
				dchunk[#dchunk+1] = dbasepre[i]

	local af = {}
	for _,c in pairs(achunk) do
		af = M.zip(c, af)

				-- check winding/cross-bounds
				for _,p in pairs(apair) do
					local ps = deepcopy(p)

		local pair,mult = pairsUp(base)
		for _,m in pairs(mult) do
			if #m > 1 then

				for _,v in pairs(ap) do
					av[#av+1] = v

				end
				for _,v in pairs(aP) do
					av[#av+1] = v

			if dbg then
				for i,d in pairs(adata) do
--                    U.dump(d[1], '?? for_DATA:')

--        U.dump(amult, '??+++++ AMULT:')
	for _,l in pairs(amult) do
		if #l > 1 then return false end

	for key,list in pairs(amult) do
--            lo('?? for_M:'..key..':'..#list)

	if #apair == 0 then athread[#athread+1] = cthread end
	for i,t in pairs(athread) do
		if #t % 2 ~= 0 then

	local achunk = {}
	for i,t in pairs(athread) do
		local cbase = {}

		local cbase = {}
		for _,k in pairs(t) do
			cbase[#cbase+1] = base[k]

--        U.dump(cchunk, '?? for_CCHUNK:'..i)
		for _,c in pairs(cchunk) do
			local chunk = {}

			local chunk = {}
			for _,j in pairs(c) do
				chunk[#chunk+1] = t[j]

	local archunk = {}
	for i,p in pairs(apair) do
		archunk[#archunk+1] = {

	for i,p in pairs(apair) do
		--- get centers

--        U.dump(athread, '?? for_THREAD:')
	for _,t in pairs(athread) do
		local cbase = {}

		local cbase = {}
		for _,i in pairs(t) do
			cbase[#cbase+1] = sbase[i]

--            lo('??*************** child_REM:'..#floor.top.achild, true)
			for _,c in pairs(floor.top.achild) do
				if c.id then

--                lo('?? fR_param:'..#achild)
			for i,c in pairs(achild) do
				c.id = floor.top.achild[i].id

						imi = {i,j}
						for _,p in pairs(apair) do
							local ps = deepcopy(p)

--[[
		for key,_ in pairs(noridge) do
				U.dump(achunk[key], '??***************** for_chunk:'..key)

			local cbase = {}
			for _,i in pairs(achunk[key]) do
				cbase[#cbase+1] = sbase[i]

			local isin
			for k,c in pairs(achunk) do
	--                U.dump(c, '?? if_inchunk:'..p[1]..':'..p[2]..':'..#U.index(c,p[1]))

						local b = av[#av-6+j]
	--                for _,b in pairs(baseext) do
						auv[#auv+1] = {u=(b-ref):dot(u), v=(b-ref):dot(v)}

	local ref = base[1]
	for _,b in pairs(baseext) do
		auv[#auv+1] = {u=(b-ref):dot(u), v=(b-ref):dot(v)}

		local ref = base[1]
		for _,b in pairs(baseext) do
			auv[#auv+1] = {u=(b-ref):dot(u), v=(b-ref):dot(v)}

		local ajoin = {}
	--    for k,p in pairs(apair) do
		for k = 1,#apair-1 do

  local strLinks = {}
  for _, lnk in pairs(self.graph.links) do
    if lnk.sourceNode == self then

  local outPins = {}
  for _, pn in pairs(self.pinOut) do
    table.insert(outPins, pn)

  end
  for _, pn in pairs(outPins) do
    self:removePin(pn)

  local inPins = {}
  for _, pn in pairs(self.pinInLocal) do
    if tableContains(self.oldOptions, pn.name) then

  end
  for _, pn in pairs(inPins) do
    self:removePin(pn)

  self.pinOut.vehicleSpawned.value = false
  for flag, act in pairs(self.flags) do
    self.pinOut[flag].value = act

  for _, wd in pairs(wheels.wheels) do
    local name = wd.name

  for f, v in pairs(vals) do
    if M.disabledState[f] ~= nil then

  --apply the smoothers as the last thing
  for f, s in pairs(smoothers) do
    if values[f] ~= nil then

  for _, s in pairs(smoothers) do
    s:reset()

  local combinedSmootherSettings = {}
  for _, setting in pairs(defaultSmoothersSettings) do
    combinedSmootherSettings[setting.electricsName] = setting

  end
  for _, setting in pairs(jbeamSmootherSettings) do
    combinedSmootherSettings[setting.electricsName] = setting

  --iterate over all desired smoothers and create them with the correct settings
  for _, smootherSetting in pairs(combinedSmootherSettings) do
    smoothers[smootherSetting.electricsName] = newSmoother(smootherSetting.smootherType, smootherSetting.params)

  --set all smoothers to the starting value of their respective electrics value
  for electricsName, smoother in pairs(smoothers) do
    if M.values[electricsName] ~= nil then

  extractedWaypoints = {}
  for _, pathNode in pairs(pathData.pathnodes.sorted) do
    table.insert(extractedWaypoints, pathNode.pos)

  local newOldMarkers = {}
  for clusterId, marker in pairs(oldMarkersByClusterId) do
    if not marker.visible then

  -- Move current markers to old markers list for gradual cleanup
  for clusterId, marker in pairs(markersByClusterId) do
    marker:hide()

  local markersToRemove = {}
  for clusterId, marker in pairs(oldMarkersByClusterId) do
    marker:update(updateData)

local function hideMarkers()
  for _, marker in pairs(markersByClusterId) do
    marker:hide()

  -- Also hide old markers
  for _, marker in pairs(oldMarkersByClusterId) do
    marker:hide()

  print("Clearing markers")
  for _, marker in pairs(markersByClusterId) do
    marker:clearObjects()

  -- Also clear old markers
  for _, marker in pairs(oldMarkersByClusterId) do
    marker:clearObjects()

  local ret = {}
  for key, value in pairs(material) do
    if type(material[key]) == "table" then

local function fillDefaults(material, original)
  for key, value in pairs(original) do
    if material[key] == nil then

  if not materials then return end
  for letter, mat in pairs(materials) do
    M.setSingleMaterial(letter,fillDefaults(mat,originalMaterials[letter]), skipSet)

  local ret = {}
  for letter, mat in pairs(currentMaterials) do
    ret[letter] = removeDefaults(mat,originalMaterials[letter])

local function getPreviousAttachedVehicleId(vehId)
  for previousId, connectionInfo in pairs(trailerReg) do
    if type(connectionInfo) == "table" and connectionInfo.trailerId == vehId then

  for vId, coupleInfo in pairs(trailerReg) do
    if coupleInfo and coupleInfo.trailerId == vehId then

  for vID,c in pairs(core_vehicles.vehsCouplerOffset) do
    local veh = getObjectByID(vID)

      local pos = veh:getPosition()
      for ci,cpos in pairs(c) do
        debugDrawer:drawSphere( (pos+cpos), 0.05, ColorF(1, 0, 0, 1))

  local count = 0
  for k, v in pairs(tbl) do
    if type(k) ~= "number" then return false else count = count + 1 end

  -- set the sorted fields array and sort the array fields
  for _, field in pairs(fields) do
    if tableIsArray(field.value) then field.elementCount = #field.value end

      field.sortedFields = {}
      for _, fld in pairs(field.fields) do
        if tableIsArray(fld.value) then fld.elementCount = #fld.value end

      --TODO: use modifiers from the main editor inspector
      for k, v in pairs(self.inspectorFieldModifiers) do
        if v.callback then

      for _, file in pairs(fileCache) do
        if not (options.select_folder and file.filetype ~= 'dir') then

  local cols = editor.getPreference("files.fileDialog.columns")
  for columnName, visible in pairs(cols) do
    for _, column in ipairs(columns) do

  if self._stack then
    for name, pin in pairs(self.pinOut) do
      self.pinOut[name].value = self._stack[name]

      -- collect the in-pins of this node
      for name, pin in pairs(node.pinInLocal) do
        if name ~= 'flow' then

      -- collect the out-pins of this node
      for name, pin in pairs(node.pinOut) do
        if name ~= 'flow' then

  self._pinTemplates = {_in = {}, _out = {}}
  for name, type in pairs(pins) do  table.insert(self._pinTemplates._in,  {name = name, type = type}) end
  table.sort(self._pinTemplates._in,  function(a,b) return a.name < b.name end)

  local keys = {}
  for key in pairs(tbl) do
    table.insert(keys, key)

  local vehicles, ctr = {}, 1
  for k, _ in pairs(mapmgr.getObjects()) do
    if k ~= objectId then

    local i = 1
    for _, v in pairs(sel) do
      if i > 1 then return true end

  for layerUid, layerData in pairs(editor.selection["dynamicDecalLayer"]) do
    if multiSelect then

  for layerType, layerTypeId in pairs(api.layerTypes) do
    layerGui[layerTypeId] = function() im.TextUnformatted(string.format("No layerGui available for '%s'", layerType)) end

  -- copy lpeg shortcuts
  for k,v in pairs( L ) do
    if string.match( k, "^%u%w*$" ) then

      end
      for k,v in pairs( node ) do
        if k ~= "id" and k ~= "pos" then

      local startWidth = nil
      for k, v in pairs(n.widths) do
        if r.profile[k].type == 'road_lane' then

      local laneWidth = max(0.5, min(10.0, startWidth + offset))
      for k, _ in pairs(n.widths) do
        if r.profile[k].type == 'road_lane' then

    for k, _ in pairs(uniqueWheels) do
      local axleBeamsWheel = wheels[k] and (wheels[k].axleBeams or {}) or {}

      engine.torque = {{"rpm", "torque"}}
      for _, v in pairs(v.data.enginetorque) do
        table.insert(engine.torque, {v.rpm, v.torque})

  if engineData then
    for _, e in pairs(engineData) do
      table.insert(v.data.powertrain, e)

  if diffData then
    for _, e in pairs(diffData) do
      table.insert(v.data.powertrain, e)

    --check if we already have an esc controller
    for _, v in pairs(v.data.controller) do
      if v.filename == "esc" then

  for _, deviceData in pairs(v.data.powertrain or {}) do
    local type = deviceData.type

  for _, controllerData in pairs(v.data.controller or {}) do
    if controllerData.fileName == "vehicleController" then

  motors = powertrain.getDevicesByType("electricMotor")
  for _, v in pairs(motors) do
    for _, j in pairs(v.registeredEnergyStorages) do

  for _, v in pairs(motors) do
    for _, j in pairs(v.registeredEnergyStorages) do
      table.insert(batteries, j)

    local aang = {}
    for i,v in pairs(apos) do
        aang[#aang + 1] = {i, math.atan2(v.y, v.x) % (2*math.pi)}

        state = {}
        for i,l in pairs(lines) do
            local a = U.split(l,',')

        local apair = {}
        for o,s in pairs(edges.astamp) do
            if (edges.infaces[s] ~= nil and math.abs(edges.infaces[s]) == 1) or #edges.astamp == 1 then

    end
    for _,n in pairs(anode) do
        n.pos = n.pos + (pos or vec3(0))

    massCenter = vec3(0,0,0)
    for _,n in pairs(anode) do
        massCenter = massCenter + n.pos

    local dpos = pos - massCenter/#anode
    for _,n in pairs(anode) do
        n.pos = n.pos + dpos

    local star, anear = {}, {}
    for _,iuse in pairs(ause) do
        anear[#anear + 1] = iuse - 1

    end
    for _,j in pairs(anear) do
        if j > 0 and j <= #path then

        local dma = 0
        for i,n in pairs(anode) do
            local step = U.stamp({cp, i})

        local crossed, xc, yc
        for o,p in pairs(ap) do
            local w = wa * p.d/dma + wb * p.ang/math.pi + (1 - (wa + wb)) * p.used

                end
                for _,pth in pairs(apath) do
                    crossed = forCross(pth)

                    apath[#apath + 1] = path
                    for _,s in pairs(path) do
                        jointpath[#jointpath + 1] = s

    local aang, angp = {}, 0
    for _,i in pairs(star) do
        local v = anode[i].pos - anode[s].pos

    -- relative to p
    for o,_ in pairs(aang) do
        aang[o][2] = (aang[o][2] - angp) % (2*math.pi)

    lo('>> roadAni:')
    for key,list in pairs(dlist) do
--        U.dump(list, '?? ani_LIST:'..key..':'..#list)

--            U.dump(nodelist, '?? NLIST:'..#nodelist)
        for k,n in pairs(nodelist) do
    --    for k,n in pairs(acnode) do

        for k,n in pairs(nodelist) do
    --    for k,n in pairs(acnode) do
            for i = cedge,nedge do

--            local s = aseg[i]
        for i,s in pairs(aseg) do
--                U.dump(s, '?? for_seg:'..i)

                local an = {s[3]}
                for _,n in pairs(s) do
                    if n.tp and n.tp == 1 then

        local nma = 0
        for _,s in pairs(ani) do
            if #s > nma then

        local epos = road:getMiddleEdgePosition(i)
        for k,n in pairs(acnode) do
            if (n.pos - epos):length() < 0.1 then

            local p = pth[o]
    --        for o,p in pairs(dec) do
            local set = 0

    -- reset heights
    for o,n in pairs(adec) do
        if dbg then

    -- build decal
    for _,r in pairs(roads) do
        local rd = path2decal(r, wHeighway)

    local an = {}
    for _,p in pairs(apos) do
        an[#an + 1] = {pos = p, width = w}

    -- get branches
    for i,r in pairs(roads) do
        local inpath = U.index(r.path, icirc)

--                U.dump(r.apin, '?? r:'..i)
        for _,j in pairs(inpath) do
            inedge[#inedge + 1] = {i, r.apin[r.path2dec[j]][1]}

    local adir = {}
    for _,s in pairs(inedge) do
        print('?? for_s:'..s[1]..':'..s[2])

        -- circles
        for o,n in pairs(anode) do
            local clr = color(255,255,255,255)

        -- paths
        for i,l in pairs(apath) do
            for j,s in pairs(l) do

        for i,l in pairs(apath) do
            for j,s in pairs(l) do
                if j > 1 then

  self.pinOut.menuClosed.value = false
  for flag, act in pairs(self.flags) do
    self.pinOut[flag].value = act

  local pinData = {}
  for k, v in pairs(self.pinIn) do
    if k ~= 'flow' and k ~= 'reset' then

	if true then
		for _,pth in pairs(apath) do
			Render.path(pth, ColorF(c[1],c[2],c[3],c[4] or 1), w, true, z)

		local n = 0
		for _,pth in pairs(apath) do
			for i=1,#pth-1 do

	local campos = core_camera.getPosition()
	for _,pos in pairs(set) do
--			print('?? set:'..tostring(pos)..':'..tostring(campos)..':'..tostring(c))

	c = ColorF(c[1],c[2],c[3],c[4] or 1)
	for _,s in pairs(list) do
--			print('?? label:'..tostring(s[2])..':'..tostring(s[1]))

  -- Disable the AI for all vehicles in the playing table.
  for _, v in pairs(playing) do
    v.vehicle.veh:queueLuaCommand('ai.setState({mode = "stop"})')

  -- Reset the vehicles to their starting positions.
  for _, d in pairs(playing) do
    splineMgr.resetVehiclePose(d.spline, d.vehicle)

local function handlePlayback()
  for _, d in pairs(playing) do
    local isStarted = d.isStarted

  local prioritizedModifiers = {}
  for mod,modData in pairs(config.modifiers) do
    table.insert(prioritizedModifiers, { modName = mod, modData = modData })

  for _,rawDistanceBefore in ipairs(rawDistanceBeforeValues) do
    for caution,cautionText in pairs(config.caution) do
      structured.fields.caution = caution

    for _,cornerSeverity in ipairs(config.cornerSeverity) do
      for cornerDirection,_ in pairs(config.cornerDirection) do
        for _,cornerLength in pairs(config.cornerLength) do

      for cornerDirection,_ in pairs(config.cornerDirection) do
        for _,cornerLength in pairs(config.cornerLength) do
          for _,cornerRadiusChange in pairs(config.cornerRadiusChange) do

        for _,cornerLength in pairs(config.cornerLength) do
          for _,cornerRadiusChange in pairs(config.cornerRadiusChange) do
            structured.fields.cornerSeverity = cornerSeverity.value

    -- for _,cornerSquare in ipairs({true, false}) do
      for cornerDirection,_ in pairs(config.cornerDirection) do
        for _,cornerLength in pairs(config.cornerLength) do

      for cornerDirection,_ in pairs(config.cornerDirection) do
        for _,cornerLength in pairs(config.cornerLength) do
          for _,cornerRadiusChange in pairs(config.cornerRadiusChange) do

        for _,cornerLength in pairs(config.cornerLength) do
          for _,cornerRadiusChange in pairs(config.cornerRadiusChange) do
            structured.fields.cornerSeverity = -1

  for _,rawDistanceBefore in ipairs(rawDistanceBeforeValues) do
    for modName,modData in pairs(config.modifiers) do

      -- clear modifiers to work with a clean and consistent state.
      for modName,_ in pairs(config.modifiers) do
        structured.fields[modName] = false

  electricsConfig = {}
  for _, v in pairs(config) do
    table.insert(electricsConfig, v)

  local mergedConfig = {}
  for _, v in pairs(tableFromHeaderTable(config)) do
    mergedConfig[v.deviceName] = mergedConfig[v.deviceName] or {}

  powertrainConfig = {}
  for k, v in pairs(mergedConfig) do
    local device = powertrain.getDevice(k)

  local mergedConfig = {}
  for _, v in pairs(tableFromHeaderTable(config)) do
    mergedConfig[v.moduleName] = mergedConfig[v.moduleName] or {}

  local controllerPath = "gauges/customModules/"
  for k, v in pairs(mergedConfig) do
    local c = controller.getController(controllerPath .. k)

  --dump(configData)
  for k, v in pairs(jbeamData) do
    if k:sub(1, #"configuration_") == "configuration_" then

  for i, beam in pairs(v.data.beams) do
    local id1 = beam.id1

  for k, v in pairs(damage) do
    damage[k] = {damage = damage[k] / beamCounts[k]}

  for i, beam in pairs(v.data.beams) do
    local id1 = beam.id1

  for k, v in pairs(damage) do
    damage[k] = {damage = damage[k]}

  for i, beam in pairs(v.data.beams) do
    local id1 = beam.id1

  for k, v in pairs(damaged) do
    damaged[k] = {damage = damaged[k] / beamCounts[k]}

  for i, beam in pairs(v.data.beams) do
    local id1 = beam.id1

  for k, v in pairs(damage) do
    damage[k] = {damage = damage[k] / beamCounts[k]}

  for i, beam in pairs(v.data.beams) do
    local id1 = beam.id1

  for k, v in pairs(damage) do
    damage[k] = {damage = damage[k]}

  for i, beam in pairs(v.data.beams) do
    local id1 = beam.id1

  for k, v in pairs(damaged) do
    damaged[k] = {damage = damaged[k] / beamCounts[k]}

  for i, beam in pairs(v.data.beams) do
    local id1 = beam.id1

  for k, v in pairs(damage) do
    damage[k] = {damage = damage[k] / beamCounts[k]}

  for i, beam in pairs(v.data.beams) do
    local id1 = beam.id1

  for k, v in pairs(damage) do
    damage[k] = {damage = damage[k]}

  for i, beam in pairs(v.data.beams) do
    local id1 = beam.id1

  for k, v in pairs(damaged) do
    damaged[k] = {damage = damaged[k] / beamCounts[k]}

  for i, beam in pairs(v.data.beams) do
    local part = beam.partPath

  for k, v in pairs(beamCounts) do
    if partData[k] ~= nil and partData[k].beamsBroken ~= nil then

  local nodeProperties = {}
  for k, v in pairs(v.data.nodes[id]) do
    if type(v) == "string" or type(v) == "boolean" or type(v) == "number" then

  local beamProperties = {}
  for k, v in pairs(beam) do
    if type(v) == "string" or type(v) == "boolean" or type(v) == "number" then

  for i, beam in pairs(v.data.beams) do
    local id1 = beam.id1

    local dF = child:getDynamicFields()
    for _, value in pairs(dF or {}) do
      if type(value) == "string" and value == self.pinIn.dynamicName.value then

    -- Pre-format aggregates for the UI
    for key, prog in pairs(info.parentInfo.formattedProgress.formattedProgressByKey) do
      local ownAggregate = {}

  -- pre-format aggregates for the UI. This formatting might be the default later and then be moved to gameplay_missions_progress
  for key, prog in pairs(info.formattedProgress.formattedProgressByKey) do
    --dump(key)

    local canPayFee = true
    for key, value in pairs(entryFee) do
      hasEntryFee = hasEntryFee or value > 0

    if m.ignoreUserSettingsKeyForActiveStars then
      for key, _ in pairs(m.ignoreUserSettingsKeyForActiveStars) do
        flatSettings[key] = nil

    local same = true
    for k, v in pairs(defaultUserSettings) do
      if type(v) == "table" and type(flatSettings[k]) == "table" then

      if type(v) == "table" and type(flatSettings[k]) == "table" then
        for k2, v2 in pairs(v) do
          same = same and flatSettings[k][k2] == v2

    end
    for k, v in pairs(flatSettings) do
      if type(v) == "table" and type(defaultUserSettings[k]) == "table" then

      if type(v) == "table" and type(defaultUserSettings[k]) == "table" then
        for k2, v2 in pairs(v) do
          same = same and defaultUserSettings[k][k2] == v2

    for key, info in pairs(starInfo) do
      if info.visible then

   -- pre-format aggregates for the UI. This formatting might be the default later and then be moved to gameplay_missions_progress
  for key, prog in pairs(formattedProgress.formattedProgressByKey) do
    --dump(key)

  else
    for label, _ in pairs(soundNames) do
      local sound = scenetree.findObjectById(soundObjectIds[label])

  groupsByKey["all"] = {meta = {type = "all"}, sortingKey = "date", sortingDirection = "desc"}
  for _, diff in pairs(gameplay_missions_missions.getAdditionalAttributes().difficulty.valuesByKey) do
    groupsByKey["difficulty_"..diff.key] = {label = "Difficulty: " ..diff.translationKey, meta = {type = "difficulty"}}

  -- build group lists (new groups might have been added)
  for key, group in pairs(groupsByKey) do
    group.tileIdsUnsorted = {}

  -- add tiles to groups
  for id, tile in pairs(tilesById) do
    for groupKey, _ in pairs(tile.filterData.groupTags) do

  for id, tile in pairs(tilesById) do
    for groupKey, _ in pairs(tile.filterData.groupTags) do
      if groupsByKey[groupKey] then

    career_modules_branches_leagues.clearLeagueUnlockCache()
    for groupKey, group in pairs(groupsByKey) do
      if group.meta.type == "league" then

    -- Group by mission type outside career
    for groupKey, group in pairs(groupsByKey) do
      if group.meta.type == "all" then

  for _, bvs in pairs(cylinder.beamVelocitySmoothers) do
    bvs:reset()

  end
  for k, _ in pairs(cylinder.previousBeamVelocities) do
    cylinder.previousBeamVelocities[k] = 0

  local currentExtend = 0
  for _, bt in pairs(cylinderData.beamTags) do
    if beamstate.tagBeamMap[bt] then

    if beamstate.tagBeamMap[bt] then
      for _, cid in pairs(beamstate.tagBeamMap[bt]) do
        table.insert(cylinder.beamCids, cid)

  local hasPressureWheels = false
  for _, wi in pairs(wheels.wheels) do
    if wi.isPropulsed and not wi.isBroken then

  local newBehavior = gearboxHandling.behavior
  for _, v in pairs(gearboxHandling.behaviors) do
    if found then

  local torqueCurve = engine.torqueData.curves[engine.torqueData.finalCurveName].torque
  for k, v in pairs(gearbox.gearRatios) do
    local shiftUpRPM = nil

  -- local energyStorageCount = 0
  -- for _, s in pairs(controlLogicModule.energyStorages or {}) do
  --   local energyStorage = energyStorage.getStorage(s)

    local jbeamDataCopy = deepcopy(jbeamData)
    for _, v in pairs(shiftRPMNames) do
      if type(jbeamDataCopy[v]) ~= "table" then

  gearboxHandling.behaviorLookup = {}
  for _, v in pairs(gearboxHandling.behaviors) do
    gearboxHandling.behaviorLookup[v] = true

  local energyStorageCount = 0
  for _, s in pairs(controlLogicModule.energyStorages or {}) do
    local energyStorage = energyStorage.getStorage(s)

  --for _, v in pairs(drivingStrategy.core.strategies) do
  --  drivingStrategy[v] = require(drivingStrategyModuleDirectory .. v)

    if mapData and mapData.graph then
      for nid, pos in pairs(mapData.positions) do
        local n = mapData.graph[nid]

        if n then
           for lid, _ in pairs(n) do
             local lPos = mapData.positions[lid]

  for _, col in pairs(index) do
    for _, tile in pairs(col) do

  for _, col in pairs(index) do
    for _, tile in pairs(col) do
      tile._roadMarkingSet = nil

         if n then
           for lid, _ in pairs(n) do
             local lPos = mapData.positions[lid]

        -- Iterate over all cached tiles
        for key, data in pairs(activeTileCache) do
            local ctx = data.metadata.tileX

    core_recoveryPrompt.deactivateAllButtons()
    for _, o in pairs({'flipMission','recoverMission','submitMission','restartMission'}) do
      if self.pinIn[o].value ~= nil then

    local idx = 1
    for bmId, data in pairs(visibleBigMapIdsToCardIds) do
      for cardId, _ in pairs(data.cardIds) do

    for bmId, data in pairs(visibleBigMapIdsToCardIds) do
      for cardId, _ in pairs(data.cardIds) do
        local card = cardsById[cardId]

  -- format each group individually
  for _, group in pairs(cargoByGroupId) do
    local formatted = formatCargoGroup(group, playerCargoContainers, updateFirstSeen)

    local vehicleInfoList = {}
    for vehId, vehicleInfo in pairs(uiData.player.vehicles) do
      --table.sort(vehicleInfo.containers, function(a,b) return a.name < b.name end)

  --[[
  for poiId, list in pairs(visibleBigMapIdsToCardIds) do
    for _, cargo in ipairs(list) do

      local maxDelay = 0
      for _, delay in pairs(data) do
        maxDelay = math.max(delay, maxDelay)

          step.makeStepReturnTrueFunction(function()
            for vehId, data in pairs(data) do
              local veh = scenetree.findObjectById(vehId)

        -- no delay, no freeze
        for vehId, data in pairs(data) do
          local veh = scenetree.findObjectById(vehId)

  targetsById[sourceId] = nil
  for otherFacId, targetData in pairs(targetsById) do
    local dist = targetData.distances[sourceId]

  for tgtId1, targetData1 in pairs(targetsById) do
    for tgtId2, targetData2 in pairs(targetsById) do

  for tgtId1, targetData1 in pairs(targetsById) do
    for tgtId2, targetData2 in pairs(targetsById) do
      if tgtId1 ~= tgtId2 and tgtId1 ~= "player" and tgtId2 ~= "player" then

    if elem then
      for cardId, _ in pairs(elem.cardIds) do
        cardIds[cardId] = true

  visibleBigMapIdsToCardIds = {}
  for cardId, card in pairs(cardsById) do
    --print("Card Id: " .. cardId)

    --print("Card Id: " .. cardId)
    for bigMapId, _ in pairs(card.bigMapIds or {}) do
      --print("  -> " ..bigMapId)

  for k, v in pairs(storage.nodes) do
    obj:setNodeMass(k, v + storage.remainingMass * storage.nodeMassCoef)

  --apply final weight as soon as possible
  for k, v in pairs(storage.nodes) do
    obj:setNodeMass(k, v + storage.remainingMass * storage.nodeMassCoef)

  if jbeamData.nodes and jbeamData.nodes._engineGroup_nodes then
    for _, n in pairs(jbeamData.nodes._engineGroup_nodes) do
      storage.nodes[n] = v.data.nodes[n].nodeWeight --save initial mass as the offset for the node weights

  --apply final weight as soon as possible
  for k, v in pairs(storage.nodes) do
    obj:setNodeMass(k, v + storage.storedEnergy * storage.nodeMassCoef)

  local ptoSupplyNodeNames = jbeamData.pneumaticPTOSupplyCouplerNodeNames or {}
  for _, nodeName in pairs(ptoSupplyNodeNames) do
    if beamstate.nodeNameMap[nodeName] then

  local ptoConsumerNodeNames = jbeamData.pneumaticPTOConsumerCouplerNodeNames or {}
  for _, nodeName in pairs(ptoConsumerNodeNames) do
    if beamstate.nodeNameMap[nodeName] then

          M.count = 1
          for k,v in pairs(subLocationsHints) do
            unlockedHints[k] = subLocationsHints[k][1]

          M.count = #seen +1
          for k,v in pairs(subLocationsHints) do
            if not  M.foundLocation[k] then

local disableAllActionMaps = function()
  for key, value in pairs(ACTION_MAPS) do
    popActionMap(value)

local function latchesOpen()
  for k, v in pairs(controller.getControllersByType("advancedCouplerControl")) do
    v.detachGroup()

local function latchesClose()
  for k, v in pairs(controller.getControllersByType("advancedCouplerControl")) do
    v.tryAttachGroupImpulse()

  for id, wd in pairs(wheels.wheels) do
    local data = {}

    for _, beamId in pairs(rimBeams) do
      local rBeam = v.data.beams[beamId]

    for _, beamId in pairs(sidewallBeams) do
      local sBeam = v.data.beams[beamId]

    for _, beamId in pairs(sidewallReinfBeams) do
      local rBeam = v.data.beams[beamId]

--dump(v.data.beams)
    for beamId, beam in pairs(v.data.beams) do
      --we only care for non-rim beams

    for _, treadNodeId in pairs(v.data.wheels[id].treadNodes) do
      table.insert(data.treadNodes, treadNodeId)

function C:work(args)
  for _, pin in pairs(self.pinOut) do
    pin.value = false

  self.pinOut.flow.value = self.pinIn.flow.value
  for key, val in pairs(self.flags) do
    if self.pinOut[key] then

  minExistingGearCoordinateIndex = 0
  for _, coordinate in pairs(gearCoordinateTable) do
    gearCoordinates[coordinate.gearIndex] = {x = coordinate.x, y = coordinate.y}

  vehicles = {}
  for k, v in pairs(data.vehicles) do
    vehicles[k] = lpack.decode(v)

  }
  for k, v in pairs(vehicles) do
    data.vehicles[k] = lpack.encode(v)

      if levelData then
        for k,v in pairs(levelData) do
          settings.setValue(k, v)

  local ngrcPreset = rallyPresets.NGRC
  for key, value in pairs(ngrcPreset) do
    if settings.getValue(key) ~= value then

          local leastUsedN = math.huge
          for id,n in pairs(usedVehicles) do
            if n < leastUsedN then

  slowStreamData.bestSegmentTimesFormatted = {}
  for segmentIndex, time in pairs(bestSegmentTimes) do
    local lap = bestSegmentLaps[segmentIndex] or 1

  if self.pinIn.file.value then
    for name, pin in pairs(self.pinIn) do
      if name ~= 'flow' and name ~= 'reset' and name ~= 'file' then

        -- find the corresponding route of the current parking spot
        for i, parkingSpotRoute in pairs(dealership.testDrive.parkingSpotRoutes) do
          if parkingSpotRoute.parkingSpotName == parkingSpot.name then

  for k, v in pairs(tab) do
    k = type(k) == 'number' and k or tostring(k)

  for i, paint in ipairs(vd.config.paints) do
    for attribute, value in pairs(paint) do
      if type(value) == "table" then

  local quads, ctr = {}, 1
  for _, road in pairs(roads) do
    local rData = road.renderData

  local buttons = {}
  for _, buttonInfo in pairs(buttonsInfos) do
    table.insert(buttons, buttonInfo)

  if not self.path then return end
  for _, n in pairs(self.path.pacenotes.objects) do
    n._drawMode = 'normal'

  for _, seg in pairs(self.path.segments.objects) do
    seg._drawMode = 'faded'

  --self:selectPacenote(nil)
  for _, n in pairs(self.path.pacenotes.objects) do
    n._drawMode = 'none'

  self.index = id
  for _, note in pairs(self.path.pacenotes.objects) do
    note._drawMode = (id == note.id) and 'highlight' or 'normal'

  else
    for _, seg in pairs(self.path.segments.objects) do
      seg._drawMode = 'faded'

  local closestNote = nil
  for idx, note in pairs(self.path.pacenotes.objects) do
    local distNoteToCam = (note.pos - self.mouseInfo.camPos):length()

      self:selector('Segment','segment', 'Associated Segment')
      for _, seg in pairs(self.path.segments.objects) do
        seg._drawMode = note.segment == -1 and 'normal' or (note.segment == seg.id and 'normal' or 'faded')

    for i = old, new+1, -1 do
      for _, lnk in pairs(self.graph.links) do
        if lnk.targetPin == self.pinInLocal['flow'..'_'..i] then

      self.configs = {}
      for k, v in pairs(modelData.configs) do
        table.insert(self.configs, v)

local function createMenu(subItems)
  for _, item in pairs(subItems) do
    if item.group then

local function drawAlwaysVisibleToolbars()
  for key, val in pairs(editor.editModes) do
    if val["toolbarAlwaysVisible"] and val.onToolbar then

local function toolbarAlwaysVisibleModeExists()
  for key, val in pairs(editor.editModes) do
    if val["toolbarAlwaysVisible"] and val.onToolbar then

  local list = {}
  for k, v in pairs(self.actionsByName) do
    table.insert(list, k)

  local mirrorCamPos = vec3()
  for _, m in pairs(vehicleMirrorData) do
    local id1 = vec3(veh:getNodePosition(m.id1))

  -- add some more stuff
  for _, m in pairs(vehicleMirrorData) do
    m.userCorrection = vec3()

function C:workOnce(args)
  for _, o in pairs({'flipMission','recoverMission','submitMission','restartMission'}) do
    if self.pinIn[o].value ~= nil then

local function selectMode(name)
  for k,v in pairs(paintModes) do
    if k == name then

local function setAllPaintModes(active)
  for name, tbl in pairs(materials.materialInfo) do
    tbl.paint[0] = active

local function setupTextures()
  for _, file in pairs(FS:findFiles(materialSettings.directory, "*.dds", -1, true, false)) do
    local fileWithoutExtension = string.sub(file, 1, string.len(file) - 4)

  for _, set in pairs(materialSettings.textureSets) do
    if set.d then set.tex = editor.texObj(set.d)

local function getGroundModelKeyByValue(groundmodel)
  for k, gm in pairs(materialSettings.groundModelNames) do
    if gm == groundmodel then return k end

    local i = 1
    for name, set in pairs(materialSettings.textureSets) do
      if im.ImageButton("##imageButton4", set.tex.texId, im.ImVec2(64,64), im.ImVec2Zero, im.ImVec2One, im.ImColorByRGB(0,0,0,255).Value, im.ImColorByRGB(255,255,255,255).Value) then print("Image") end

    local i = 1
    for name, glowMap in pairs(materialSettings.glowMaps) do
      if im.ImageButton("##imageButton5", glowMap.tex.texId, im.ImVec2(64,64), im.ImVec2Zero, im.ImVec2One, im.ImColorByRGB(0,0,0,255).Value, im.ImColorByRGB(255,255,255,255).Value) then print("Image") end

  local settings = {}
  for name,v in pairs(menuSettings) do
    if v.type == "bool" then

  if not settings then return end
  for name, v in pairs(settings) do
    if menuSettings[name] then

local function toolbarFromMenuItems(items,sorted)
  for _, v in pairs(sorted) do
    if items[v].icon then

    for _, name in pairs(paintModesSorted) do
      if paintModes[name].active[0] == true then

    if im.BeginMenu(translateLanguage("ui.trackbuilder.menus.windows","Windows")) then
      for k,v in pairs(menuItemsSorted) do
        if im.MenuItem2(menuItems[v].name, "", menuItems[v].isOpen) then

      im.Separator()
      for k,v in pairs(additionalMenuItemsSorted) do
        im.MenuItem2(additionalMenuItems[v].name, "", additionalMenuItems[v].isOpen)

local function showSubWindows()
  for k,v in pairs(menuItems) do
    if v.wasOpen == true and v.isOpen[0] == false then

  end
  for k,v in pairs(additionalMenuItems) do
    if v.wasOpen == true and v.isOpen[0] == false then

    local change = false
    for name,val in pairs(materials.materialInfo) do
      if val.paint[0] then

  local doPaint = false
  for name,val in pairs(materials.materialInfo) do
    doPaint = doPaint or val.paint[0]

    local change = false
    for name, borderPaint in pairs(clickInputModes) do
      if borderPaint[0] == true then

local function trackBuilderEditModeToolbar()
  -- for _, v in pairs(menuItemsSorted) do
  --   if menuItems[v].icon then

  -- im.Separator()
  -- for _, v in pairs(additionalMenuItemsSorted) do
  --   if additionalMenuItems[v].icon then

    local found = false
    for nm, pc in pairs(pieceInfo.free) do
      if pc.piece == info.piece then

      if pc.piece == info.piece then
        for key, val in pairs(pc) do
          if key ~= 'piece' then

  for key, mod in pairs(modifierValues) do
    if not mod.noFill then

  for nm, pc in pairs(pieceInfo.free) do
    if pc.piece == currentPieceName then

    if pc.piece == currentPieceName then
      for key, val in pairs(pc) do
        if key ~= 'piece' then

  if not to then return end
  for name, mat in pairs(materials.materialInfo) do
    mat.value[0] = indexOf(materials[mat.table].matNames,to[name])-1

  --TODO: this must be done everytime level changed? since scenetree will be different
  for i, matName in pairs(materials.matNames) do
    table.insert( materialSettings.materials.center, scenetree.findObject(matName .. 'center') )

      for nodeName, nodeData in pairs(mapData.nodes) do
        if nodeData.pos then

  local lowestRecentIdx = math.huge
  for _configKey, config in pairs(clusteredItems.configsByKey) do
    local favouriteIdx = ui_vehicleSelector_general.isFavourite(config.model_key, config.key) or 0

      local configsByConfigTypeName = {}
      for _, config in pairs(clusteredItems.configsByKey) do
        table.insert(configsByConfigTypeName, config)

  local allAuxiliary = true
  for _, config in pairs(clusteredItems.configsByKey) do
    if not config.isAuxiliary then

  local sourcesByIconCount = {}
  for _, config in pairs(clusteredItems.configsByKey) do
    local sources = getSources(config, model.model, true)

  local allAuxiliary = true
  for _, config in pairs(clusteredItems.configsByKey) do
    if not config.isAuxiliary then

  local sourcesByIconCount = {}
  for _, config in pairs(clusteredItems.configsByKey) do
    local sources = getSources(config, model.model, true)

  local clusteredItems = {}
  for _, config in pairs(configs) do
    local group = clusterModeFunctions[clusterMode](config) or "No Data"

  for fldName, field in pairs(ctx.fields) do
    if field.useCount == tableSize(valueInspector.selectedIds) then

  local fieldVal = nil
  for key, val in pairs(ctx.fields) do
    -- we start at the second object, since the first one we keep as reference

  -- set the sorted fields array and sort the array fields
  for _, field in pairs(ctx.fields) do
    if field.type == "beginArray" then

      field.sortedFields = {}
      for _, fld in pairs(field.fields) do table.insert(field.sortedFields, fld) end
      table.sort(field.sortedFields, function(a, b) return a.id < b.id end)

    if val then
      for k, v in pairs(inspectorFieldModifiers) do
        if v.callback then

    -- otherwise we skip it, since it would not make sense when not common
    for key, val in pairs(dynFieldUsage) do
      if val == #valueInspector.selectedIds then

  if guiInstancer.instances then
    for key, inspectorInfo in pairs(guiInstancer.instances) do
      local wndName = inspectorWindowNamePrefix .. key

          -- first lets check if we have multiple selection types
          for _, val in pairs(editor.selection) do
            if not tableIsEmpty(val) then

          imgui.Text("Multiple types selected:")
          for className, val in pairs(editor.selection) do
            imgui.Text(#val .. " " .. className .. "(s)")

          -- so we provide a function for the current mode, the default is object inspector objectInspectorGui function
          for typeName, typeHandler in pairs(inspectorTypeHandlers) do
            -- if we have a locked inspector, use its selection

  guiInstancer:deserialize("inspectorInstances", state)
  for key, val in pairs(guiInstancer.instances) do
    editor.registerWindow(inspectorWindowNamePrefix .. tostring(key), imgui.ImVec2(300, 500))

    if objFields then
      for fldName, field in pairs(objFields) do
        if sharedCtx.fields[fldName] == nil then

local function removeUnusedPlayerVehicles()
  for inventoryId, vehId in pairs(career_modules_inventory.getMapInventoryIdToVehId()) do
    if inventoryId ~= career_modules_inventory.getCurrentVehicle() then

  for partName, part in pairs(newParts) do
    part.year = vehicle.year

    if part.description.slotInfoUi then
      for slot, _ in pairs(part.description.slotInfoUi) do
        allSlotsInVehicle[slot] = true

  --[[ local slotsToRemove = {}
  for slot, partName in pairs(vehicle.config.parts) do
    if not allSlotsInVehicle[slot] then

  end
  for slot, _ in pairs(slotsToRemove) do
    vehicle.config.parts[slot] = nil

  -- in both cases we change the slot to a unified ""
  for slot, partName in pairs(vehicle.config.parts) do
    if not vehicle.originalParts[slot] then

  local inspectedVehicleInfo = career_modules_inspectVehicle.getSpawnedVehicleInfo()
  for shopId, status in pairs(vehicleWatchlist) do
    if status == "unsold" and (not inspectedVehicleInfo or inspectedVehicleInfo.shopId ~= shopId) then

for _,shape in pairs(shapes) do computeFaces(shape) end
M.getMeshes = getMeshes

if not pcall(require, "table.clear") then
  table.clear = function(tab) for k, _ in pairs(tab) do tab[k] = nil end end
end

  local values = {}
  for map, asset in pairs(bulkChange.textures) do
    if map == "b" then

          -- remove obsolete v1 fields from terrain materials
          for id, mtl in pairs(editor_terrainEditor.getMaterialsInJson()) do
            mtl.material:setDiffuseMap("")

      if im.CollapsingHeader1("Terrain Materials", im.TreeNodeFlags_DefaultOpen) then
        for id, mtl in pairs(editor_terrainEditor.getMaterialsInJson()) do
          if im.Selectable1(mtl.internalName .. "##Terrain Materials" .. id, name == mtl.internalName, nil,

local function showTerrainMaterialsEditor(internalName)
  for id, mtl in pairs(editor_terrainEditor.getMaterialsInJson()) do
    if mtl.internalName == internalName then

local function onEditorGui()
  for index, instance in pairs(guiInstancer.instances) do
    if instance.registerNameAsync then

  local removeList = {}
  for index, instance in pairs(guiInstancer.instances) do
    for _, objId in ipairs(objIds) do

local function onDeserialize(state)
  for index, instance in pairs(state) do
    newTextEditorInstance(instance.objIds, instance.fieldName)

  local instancesCopy = deepcopy(guiInstancer.instances)
  for key, instance in pairs(instancesCopy) do
    instance.textInput = nil

  for partName, part in pairs(activePartsData or {}) do
    if part.slotType then

      reset()
      for vName, vData in pairs(scenario.vehicles) do
        local vObj = scenetree.findObject(vName)

    local playersStoped = {}
    for vName, vObj in pairs(scenarioVehicles) do
        if not lastPosition[vName] then lastPosition[vName] = vObj:getPosition() end

local function foreachMaterial(matTable, cb)
  for file, mats in pairs(matTable) do
    for key, mat in pairs(mats) do

  for file, mats in pairs(matTable) do
    for key, mat in pairs(mats) do
      cb(file, key, mat)

  local out, count = {}, 0
  for file, mats in pairs(map) do
    local hasAny = false

    local hasAny = false
    for _, issues in pairs(mats) do
      if not tableIsEmpty(issues) then

      out[file] = {}
      for matName, issues in pairs(mats) do
        if not tableIsEmpty(issues) then

    local forestItem
    for k,v in pairs(forestContent) do
      if v.shapeFile == shape then

    for layer = 0, layers - 1 do
      for k,v in pairs(meta) do
        if v["type"] == "filename" then

  duplicatedM = {}
  for _,v in pairs(duplicatelist) do
    local name, mapTo = v[1], v[2]

    job.progress = 75
    for k,v in pairs(isOld) do
      job.yield()

      local duplicatelist = {}
      for file, mats in pairs(matTable) do
        for k, mat in pairs(mats) do

      for file, mats in pairs(matTable) do
        for k, mat in pairs(mats) do
          if mat and mat.name then

    job.sleep(0.001)
    for k,_ in pairs(duplicatedM) do
      countduplicate = countduplicate + 1

    job.sleep(0.001)
    for k,_ in pairs(outdatedFiles) do
      log('I', '', 'Saved materials to '..k )

              matData[fn][obj:getName()] = {}
              for k,v in pairs(texfields) do
                matData[fn][obj:getName()][k] = v

            local texfields = {}
            for k,v in pairs(obj:getFields()) do
              if v["type"] == "filename" then

            matData[fn][obj:getName()] = {}
            for k,v in pairs(texfields) do
              matData[fn][obj:getName()][k] = v

      local cases = {".color.png", ".normal.png", ".data.png", ".color.dds", ".normal.dds", ".data.dds", ".dds", ".png", ".bmp", ".jpg", ".jpeg", ".tga"}
      for e,t in pairs(matData) do
        fileIsMissing[e] = {}

        incorrectPathCooker[e] = {}
        for k,v in pairs(t) do
          if job.progress < 75 then job.progress = job.progress + 0.001 end

          incorrectPathCooker[e][k] = {}
          for m,d in pairs(v) do
            job.yield()

            if d and d ~= "" then
              for _,b in pairs(cases) do
                if d:find(b) then

    local sorted = {}
    for k,v in pairs(materialFiles) do
      if string.find(v, '/terrains/') and string.find(v, '/terrain/') then

              matData[fn][obj:getName()] = {}
              for k,v in pairs(texfields) do
                matData[fn][obj:getName()][k] = v

      end
      for e,t in pairs(matData) do
        pow2[e] = {}

        cooker[e] = {}
        for k,v in pairs(t) do
          if job.progress < 75 then

          cooker[e][k] = {}
          for m,d in pairs(v) do
            if abort(job) then return end

    job.sleep(0.001)
    for _,v in pairs(objmatTable) do
      if job.progress < 90 then job.progress = job.progress + 0.01 end

      if (luaType(v[1]) == "table") then
        for _,j in pairs(v[1]) do
          if not mapping[j] then

  local shapesprepare = {}
  for k,_ in pairs(shapeList) do
    if abort(job) then return end

  table.sort(shapesprepare, function(a,b) return tonumber(a[3]) > tonumber(b[3]) end)
  for _,v in pairs(shapesprepare) do
    local sizeS = string.format("%.2f", v[2] / 1048576)

  local shapesprepare = {}
  for k,_ in pairs(shapeList) do
    if abort(job) then return end

  table.sort(shapesprepare, function(a,b) return tonumber(a[3]) > tonumber(b[3]) end)
  for _,v in pairs(shapesprepare) do
    local sizeS = string.format("%.2f", v[2] / 1048576)

  local shapes = {}
  for k,_ in pairs(shapeList) do
    if abort(job) then return end

    job.sleep(0.001)
    for _,v in pairs(meshNames) do
      if abort(job) then return end

    job.sleep(0.001)
    for k,_ in pairs(shapeList) do
      if abort(job) then return end

    local meshNames2 = scenetree.findClassObjects('TSStatic')
    for _,v in pairs(meshNames2) do
      job.yield()

    job.sleep(0.001)
    for _,v in pairs(objmatTable) do
      job.yield()

      if (luaType(v) == "table") then
        for _,vv in pairs(v) do
          mats[vv] = true

    local meshNames3 = scenetree.findClassObjects('TerrainBlock')
    for _,v in pairs(meshNames3) do
      job.yield()

    job.sleep(0.001)
    for _,v in pairs(terrainMats) do
      job.yield()

      job.yield()
      for _,vv in pairs(v) do
        mats[vv:getInternalName()] = true

    local meshNames4 = scenetree.findClassObjects('GroundPlane')
    for _,v in pairs(meshNames4) do
      job.yield()

    local meshNames5 = scenetree.findClassObjects('GroundCover')
    for _,v in pairs(meshNames5) do
      job.yield()

    local meshNames6 = scenetree.findClassObjects('DecalRoad')
    for _,v in pairs(meshNames6) do
      job.yield()

    local meshNames7 = scenetree.findClassObjects('MeshRoad')
    for _,v in pairs(meshNames7) do
      job.yield()

    local meshNames8 = scenetree.findClassObjects('DecalData')
    for _,v in pairs(meshNames8) do
      job.yield()

      log('I', '', 'parsing all materials')
      for path, mats in pairs(matTable) do
        job.yield()

        job.yield()
        for k,v in pairs(mats) do
          local mat = v

    local tmpMats = {}
    for k,_ in pairs(mats) do
      job.yield()

    mats = tmpMats
    for k,v in pairs(materialFilesdata) do
      job.yield()

    job.sleep(0.001)
    for k,_ in pairs(unused) do
      job.yield()

    local toRemove = {}
    for k,_ in pairs(unused) do
      job.yield()

    local prefabInstances = scenetree.findClassObjects('Prefab')
    for _,v in pairs(prefabInstances) do
      job.yield()

    job.sleep(0.001)
    for _,v in pairs(meshNames) do
      if abort(job) then return end

    job.sleep(0.001)
    for k,_ in pairs(shapeList) do
      if abort(job) then return end

    local meshNames2 = scenetree.findClassObjects('TSStatic')
    for _,v in pairs(meshNames2) do
      job.yield()

    job.sleep(0.001)
    for _,v in pairs(objmatTable) do
      job.yield()

      if (luaType(v) == "table") then
        for _,vv in pairs(v) do
          mats[vv] = true

    local meshNames3 = scenetree.findClassObjects('TerrainBlock')
    for _,v in pairs(meshNames3) do
      job.yield()

    job.sleep(0.001)
    for _,v in pairs(terrainMats) do
      job.yield()

      job.yield()
      for _,vv in pairs(v) do
        mats[vv:getInternalName()] = true

    local meshNames4 = scenetree.findClassObjects('GroundPlane')
    for _,v in pairs(meshNames4) do
      job.yield()

    local meshNames5 = scenetree.findClassObjects('GroundCover')
    for _,v in pairs(meshNames5) do
      job.yield()

    local meshNames6 = scenetree.findClassObjects('DecalRoad')
    for _,v in pairs(meshNames6) do
      job.yield()

    local meshNames7 = scenetree.findClassObjects('MeshRoad')
    for _,v in pairs(meshNames7) do
      job.yield()

    local meshNames8 = scenetree.findClassObjects('DecalData')
    for _,v in pairs(meshNames8) do
      job.yield()

    if abort(job) then return end
    for k,_ in pairs(mats) do
      job.yield()

        if texfields then
          for _,h in pairs(texfields) do
            local file = h

        local countMat = 0
        for _,h in pairs(allMatsUsages) do
          if h == k then countMat = countMat + 1 end

    job.sleep(0.001)
    for k,v in pairs(mats) do
      job.yield()

    end
    for k,v in pairs(mats) do
      job.yield()

    table.sort(shapes, function(a,b) return tonumber(a[2]) > tonumber(b[2]) end)
    for k,v in pairs(shapes) do
      shapes[k] = v[1]

    sizeTotal = string.format("%.2f", sizeTotal/1048576)
    for k,v in pairs(matsInObjects) do
      if (luaType(v) == "table") then

      if (luaType(v) == "table") then
        for _,p in pairs(v) do
          if not usages[p] then usages[p] = {} end

    local prefabInstances = scenetree.findClassObjects('Prefab')
    for _,v in pairs(prefabInstances) do
      job.yield()

    end
    for _, fn in pairs(prefabs) do
      if abort(job) then return end

      job.yield()
      for _,v in pairs(forestObject:getData():getItems()) do
        if not staticInstances[v:getData():getShapeFile()] then

    local meshNames = scenetree.findClassObjects('TSStatic')
    for _,v in pairs(meshNames) do
      job.yield()

    end
    for k,v in pairs(staticInstances) do
      if abort(job) then return end

    end
    for k,v in pairs(staticInstances) do
      job.yield()

      if v and v.ColPolygons > 0 then
        for _,c in pairs(v.collision) do
          if c == "Collision Mesh" then colMeshInst = colMeshInst + 1 end

      if v and v.VisPolygons > 0 then
        for _,c in pairs(v.collision) do
          if (c == "Visible Mesh" or c == "Visible Mesh Final")  then visMeshInst = visMeshInst + 1 end

    table.sort(shapes, function(a,b) return tonumber(a[2]) > tonumber(b[2]) end)
    for k,v in pairs(shapes) do
      shapes[k] = v[1]

    local meshNames = scenetree.findClassObjects('TSStatic')
    for _,v in pairs(meshNames) do
      if abort(job) then return end

    local forestModels = {}
    for _,v in pairs(meshNames2) do
      job.yield()

    local forestFiles = FS:findFiles("/levels/"..levelname.."/forest/", "*forest4.json", -1, true, false)
    for _,v in pairs(forestFiles) do
      job.yield()

    local meshNames3 = scenetree.findClassObjects('GroundCover')
    for _,v in pairs(meshNames3) do
      job.yield()

    job.sleep(0.001)
    for k,v in pairs(forestModels) do
      job.yield()

    job.sleep(0.001)
    for k,_ in pairs(models) do
      job.yield()

    local tempMdl = {}
    for k,_ in pairs(models) do
      job.yield()

    local meshFiles = FS:findFiles("/levels/"..levelname.."/", "*.dae\t*.dts\t*.cdae", -1, true, false)
    for _,v in pairs(meshFiles) do
      job.yield()

    job.progress = 75
    for _,v in pairs(forestModels) do
      forestShapes[string.lower(v)] = true

    job.sleep(0.001)
    for k,_ in pairs(unused) do
      job.yield()

    local toRemove = {}
    for k,_ in pairs(unused) do
      job.yield()

    local meshNames = scenetree.findClassObjects('Material')
    for _,v in pairs(meshNames) do
      job.yield()

        if texfields then
          for _,vv in pairs(texfields) do
            textures[vv] = true

    local meshNames2 = scenetree.findClassObjects('TerrainMaterial')
    for _,v in pairs(meshNames2) do
      if abort(job) then return end

      else
        for k,f in pairs(m:getFields()) do
          job.yield()

    local meshNames3 = scenetree.findClassObjects('WaterPlane')
    for _,v in pairs(meshNames3) do
      job.yield()

      else
        for k,f in pairs(m:getFields()) do
          job.yield()

    local meshNames4 = scenetree.findClassObjects('WaterBlock')
    for _,v in pairs(meshNames4) do
      job.yield()

      else
        for k,f in pairs(m:getFields()) do
          job.yield()

    local meshNames5 = scenetree.findClassObjects('River')
    for _,v in pairs(meshNames5) do
      job.yield()

      else
        for k,f in pairs(m:getFields()) do
          job.yield()

    local meshNames6 = scenetree.findClassObjects('CloudLayer')
    for _,v in pairs(meshNames6) do
      job.yield()

    local meshNames7 = scenetree.findClassObjects('ScatterSky')
    for _,v in pairs(meshNames7) do
      job.yield()

      else
        for k,f in pairs(m:getFields()) do
          job.yield()

    local meshNames8 = scenetree.findClassObjects('CubemapData')
    for _,v in pairs(meshNames8) do
      job.yield()

      else
        for k,f in pairs(m:getFields()) do
          job.yield()

    if meshNames9 then
      for k,v in pairs(meshNames9) do
        job.yield()

        if k == "previews" then
          for _,t in pairs(v) do
            textures[t] = true

        if k == "spawnPoints" then
          for _,t in pairs(v) do
            for i,m in pairs(t) do

          for _,t in pairs(v) do
            for i,m in pairs(t) do
              if i == "preview" then

    local texTemp = {}
    for k,_ in pairs(textures) do
      job.yield()

    local blacklist = {"buslines", "quickrace", "scenarios", "scenarios", "lights", "export", "import", "minimap"}
    for _,v in pairs(texFiles) do
      job.yield()

    job.sleep(0.001)
    for k,_ in pairs(unused) do
      job.yield()

    local toRemove = {}
    for k,_ in pairs(unused) do
      job.yield()

      if not tableIsEmpty(selected) then
        for k,_ in pairs(selected) do
          local entry = k:gsub(' ','')

      if not tableIsEmpty(materialsToRemove) then
        for k,v in pairs(materialsToRemove) do
          if string.find(v, levelname) then

      if not tableIsEmpty(selected) then
        for k,_ in pairs(selected) do
          table.insert(shapesToRemove, k)

      if not tableIsEmpty(shapesToRemove) then
        for _,v in pairs(shapesToRemove) do
          local file

      if not tableIsEmpty(selected) then
        for k,_ in pairs(selected) do
          table.insert(texturesToRemove, k)

      if not tableIsEmpty(texturesToRemove) then
        for _,v in pairs(texturesToRemove) do
          log('I', '', 'Removing unused texture '..v )

    job.sleep(0.001)
    for file,mats in pairs(dummyMat) do
      if FS:fileExists(file) then

        local materialFile = jsonReadFile(file) or {}
        for key,_ in pairs(mats) do
          if materialFile[key] then materialFile[key] = nil end

    local prefabInstances = scenetree.findClassObjects('Prefab')
    for _,v in pairs(prefabInstances) do
      if abort(job) then return end

    local uniqueModels = {}
    for k,_ in pairs(prefabModels) do uniqueModels[k] = true end
    for k,_ in pairs(staticFiles)  do uniqueModels[k] = true end

    for k,_ in pairs(prefabModels) do uniqueModels[k] = true end
    for k,_ in pairs(staticFiles)  do uniqueModels[k] = true end

    local seen = {}
    for k,_ in pairs(uniqueModels) do
      if abort(job) then return end

        if type(names) == "table" then
          for _,n in pairs(names) do matsUsed[n] = true end
        end

      if o and o.getMaterials then
        for _,tm in pairs(o:getMaterials()) do
          matsUsed[tm:getInternalName()] = true

    local seenTex = {}
    for matName,_ in pairs(matsUsed) do
      if abort(job) then return end

        if texfields then
          for _,file in pairs(texfields) do
            local f = file

  local flag = false
  for _,i in pairs(tablee) do
    if id == i then flag = true end

  end
  for k, node in pairs(graph.nodes) do
    local status, err, res = xpcall(node.draw, debug.traceback, node, builder, style, drawType)

  local hiddenLinks = {}
  for _, link in pairs(graph.links) do
    if link.hidden then

    end
    for _,gr in pairs(self.mgr.graphs) do table.insert(allGraphs, gr) end
    -- graph tabs

                local nIds, boxes = {}, {}
                for _, g in pairs(self.mgr.graphs) do
                  for nid, _ in pairs(g.nodes) do

                for _, g in pairs(self.mgr.graphs) do
                  for nid, _ in pairs(g.nodes) do
                    local box = math.ceil(nid/100)

          -- DBEUG: draw all graphs:
          --for _, g in pairs(self.mgr.graphs) do self:drawGraph(g, builder, style) end
          -- draw current graph only:

            local lnks = {}
            for _, gr in pairs(self.mgr.graphs) do
              drawnThisFrame = false

              self:drawGraph(gr, builder, style)
              for k, node in pairs(gr.nodes) do
                for pinName, pin in pairs(node.pinInLocal) do

              for k, node in pairs(gr.nodes) do
                for pinName, pin in pairs(node.pinInLocal) do
                  if pin.type ~= "flow" then

                  else
                    for fName, flowPin in pairs(node._mInFlow[pinName] or {}) do
                      table.insert(lnks,{pin.id, flowPin.id, true})

            if globIn and globOut then table.insert(lnks,{globIn,globOut,true}) end
            for i,lnk in pairs(lnks) do
               ui_flowgraph_editor.Link(9999999+i, lnk[1],lnk[2], lnk[3] and virtualFlowPinLinkCol or virtualPinLinkCol,15, false, "...")

          --for _, node in pairs(gr.nodes) do
          --  node:overDraw()

              if self.fgEditor.delayedHistorySnapshot == nil and ui_flowgraph_editor.IsActive() then
                for _, node in pairs(graph.nodes) do
                  node:updateNodePosition()

      -- get unique names with their types
      for _, node in pairs(self.mgr.graph.nodes) do
        for _, p in pairs(node.pinList) do

      for _, node in pairs(self.mgr.graph.nodes) do
        for _, p in pairs(node.pinList) do
          if p.quickAccess and p.direction ~= pin.direction then

      self.quickConnectSortedNames = {}
      for name,_ in pairs(self.quickConnectPins) do
        table.insert(self.quickConnectSortedNames, name)

        local ffiName = ffi.string(self.quickAccessTextfield)
        for _, node in pairs(self.mgr.graph.nodes) do
          for _, p in pairs(node.pinList) do

        for _, node in pairs(self.mgr.graph.nodes) do
          for _, p in pairs(node.pinList) do
            if p.direction == pin.direction and p.quickAccess and p.accessName == ffiName then

        local lnkRemove = nil
        for _, lnk in pairs(self.mgr.graph.links) do
          if lnk.sourcePin == pin and lnk.targetPin == other or lnk.sourcePin == other and lnk.targetPin == pin then

                local toDelete = nil
                for _, lnk in pairs(self.mgr.graph.links) do
                  if lnk.targetPin.id == pin.id then

                local toDelete = nil
                for _, lnk in pairs(self.mgr.graph.links) do
                  if lnk.targetPin == other then

  -- Set impulse flags and reset them
  for pName, val in pairs(self.flags) do
    self.pinOut[pName].value = val

  local counts = {}
  for name, pin in pairs(self.pinInLocal) do
    if self.pinIn[name].value ~= nil and pin.type == 'number' then

      if origLayout.removedApps then
        for appName, appVersion in pairs(origLayout.removedApps) do
          local userAppIndex = getAppIndexByName(userLayout, appName)

local function onFilesChanged(files)
  for _,v in pairs(files) do
    local filename = v.filename

  end
  for k,v in pairs(layouts[layout]) do
    if v.directive == appDirective then

  if groups then
    for _,g in pairs(groups) do
      veh:queueLuaCommand("beamstate.breakBreakGroup('" .. g .. "')")

  dampBeams = {}
  for _, b in pairs(v.data.beams) do
    if b.name then

    if b.name then
      for _, name in pairs(dampBeamNames) do
        if b.name == name then

  beamModes = {}
  for _, mode in pairs(modeData) do
    beamModes[mode.name] = {

  gameplay_missions_progress.setSavePath(currentSavePath .. "/career/missions/")
  for id, dirtyDate in pairs(allMissionData) do
    if dirtyDate > oldSaveDate then

  if jbeamData.boostController then
    for k, v in pairs(jbeamData.boostController) do
      if type(k) == "number" then

  for k, _ in pairs(assignedEngine.torqueCurve) do
    if type(k) == "number" and k < assignedEngine.maxRPM then

        }
        for _, c in pairs(v.configs) do
          local passConfig = true

function C:_executionStarted()
  for _, p in pairs(self.pinOut) do
    p.value = nil

    local added = false
    for name, pin in pairs(self.pinIn) do
      if not pin.fixed then

  local avgWheelPos = vec3(0, 0, 0)
  for _, wd in pairs(wheels.wheels) do
    wheelCount = wheelCount + 1

  local propulsedWheelLocations = {fr = 0, fl = 0, rr = 0, rl = 0}
  for _, wd in pairs(wheels.wheels) do
    if wd.isPropulsed then

  local transmissions = powertrain.getDevicesByCategory("gearbox")
  for _, v in pairs(transmissions) do
    transmissionTypes[v.type] = true

  local fuelTypes = {}
  for _, v in pairs(energyStorages) do
    if v.type == "fuelTank" then

  local inductionTypes = {}
  for _, v in pairs(engines) do
    inductionTypes.naturalAspiration = true

  --iterate active recordings and execute the update method
  for recordingType, _ in pairs(activeRecordingTypes) do
    recordingUpdateMethods[recordingType](dt)

--     local torqueData = {}
--     for _, v in pairs(engines) do
--       local tData = v:getTorqueData()

--       local engineCurves = td.curves[td.finalCurveName]
--       for rpm, torque in pairs(engineCurves.torque) do
--         torqueCurve[rpm] = (torqueCurve[rpm] or 0) + torque

--       end
--       for rpm, power in pairs(engineCurves.power) do
--         powerCurve[rpm] = (powerCurve[rpm] or 0) + power

--     end
--     for _, torque in pairs(torqueCurve) do
--       maxTorque = max(maxTorque, torque)

--     end
--     for _, power in pairs(powerCurve) do
--       maxPower = max(maxPower, power)

    for k, v in pairs(objectsByType) do
      if not ignoredClasses[k] then

  moreData = moreData or {}
  for k, v in pairs(moreData) do data[k] = v end

  if data then
    for vid, val in pairs(data.originalVehicleTransforms or {}) do
      local veh = scenetree.findObjectById(vid)

  local vehicleTransforms = {}
  for k, _ in pairs(self.prefabs[id].originalVehicleTransforms) do
    local veh = scenetree.findObjectById(k)

  obj:delete()
  for k, v in pairs(vehicleTransforms) do
    --dump("Extracting object: " .. i)

  local total = 0
  for varName, value in pairs(changedVars) do
    local varData = tuningData[varName]

  local shoppingCartUI = {items = {}}
  for name, info in pairs(shoppingCart.items) do
    table.insert(shoppingCartUI.items, {varName = info.name, level = 1, title = info.title, price = info.price, type = info.type})

    table.insert(shoppingCartUI.items, {varName = info.name, level = 1, title = info.title, price = info.price, type = info.type})
    for name, info in pairs(info.items or {}) do
      table.insert(shoppingCartUI.items, {varName = info.name, level = 2, title = info.title, price = info.price, type = info.type})

      table.insert(shoppingCartUI.items, {varName = info.name, level = 2, title = info.title, price = info.price, type = info.type})
      for name, info in pairs(info.items or {}) do
        table.insert(shoppingCartUI.items, {varName = info.name, level = 3, title = info.title, price = info.price, type = info.type})

  local res = {}
  for varName1, value1 in pairs(vars1) do
    if vars2[varName1] ~= value1 then

  -- fill the vehicleVarsBefore with the missing default values
  for varName, varTuningData in pairs(tuningData) do
    if not vehicleVarsBefore[varName] then

    if type(relevantElectricsNames) == "table" then
      for _, electricsName in pairs(relevantElectricsNames) do
        table.insert(relevantElectrics, electricsName)

  local same = true
  for k, v in pairs(a) do
    same = same and a[k] == b[k]

  -- check loaner cut for cargo
  for organizationId, _ in pairs(cargo.loanerOrganisations or {}) do
    local organization = freeroam_organizations.getOrganization(organizationId)

  for _, bd in ipairs(breakdown) do
    for key, amount in pairs(bd.rewards) do
      adjustedRewards[key] = (adjustedRewards[key] or 0) + amount

  -- format each group individually
  for gId, group in pairs(cargoByGroupId) do
     -- this function is copied over from cargoscreen... TODO: cleanup