VE Lua Documentation

  level = level + 1
  for _, s in pairs(settingNode) do
    local newPath = path .. '/' .. tostring(s.name)

        s.valMap = {}
        for ck, cv in pairs(s.values) do
          s.valMap[cv] = ck

      if im.BeginCombo((s.title or s.name) .. '##' .. tostring(newPath), s.valMap[s.cVal]) then
        for ck, cv in pairs(s.values) do
          local selected = s.values

  local tabNames = {}
  for _, s in pairs(settings) do
    local tabTitle = s.name or ""

  if im.BeginTabBar("settings") then
    for _, tabName in pairs(tabNames) do
      local entry = settings[tabName]

    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

  if M.layerMap then
    for k, layer in pairs(M.layerMap) do
      if not layer.hidden then

M.getLayerByOrder = function(order, parentUid)
  for k, layerMapItem in pairs(M.layerMap) do
    if (not parentUid or parentUid == layerMapItem.parentUid) and layerMapItem.order == order then

  end
  for _, z in pairs(zones.objects) do
    local points = z.customFields:get('points') or 0

  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)

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

  local normalized = {}
  for k, v in pairs(t) do
    if type(k) == "string" and tonumber(k) then

  for k, v in pairs(t1) do
    if type(v) == "table" and type(t2[k]) == "table" then

  for k in pairs(t2) do
    if t1[k] == nil then return false end

  if data.boundary then
    for index, pos in pairs(data.old) do
      if data.boundary.vertices[index] then

  if data.boundary then
    for index, pos in pairs(data.new) do
      if data.boundary.vertices[index] then

  for idx, obj in pairs(objects) do
    local distNodeToCam = (obj.pos - mouseInfo.camPos):length()

  -- Check each graph node in turn.
  for key, node in pairs(nodes) do
    local a, b = intersectsRay_Sphere(rayPos, rayDir, node, mouseToNodetol) -- Get any intersection points between the ray and node sphere.

  -- Set impulse flags and reset them
  for pName, val in pairs(self.flags) do
    self.pinOut[pName].value = val

	local alib = {}
	for _,p in pairs(apth) do
		unrequire(p)

if editor.texObj then
    for key,p in pairs(aicon) do
        dicon[key] = editor.texObj('/lua/ge/extensions/editor/gen/assets/_icon/'..(aicon[key][3] or key)..(p.suf or '.png'))

    if im.BeginTable(id, #adim, cbsort and tableFlags or tableFlagsNoSort) then
        for i,c in pairs(adim) do
            im.TableSetupColumn(ahead and ahead[i] or 'C_'..i

        if data then
            for k,v in pairs(data) do
                cb(k,v)

        while next do
            for i,v in pairs(row) do
                if v.list then

    local cbg = im.GetColorU322(im.ImVec4(0.3, 0.3, 0.3, 0.8)) --im.GetColorU321(im.ImVec4(0.3, 0.3, 0.3, 1)) -- im.Col_FrameBg)
	for i,row in pairs(htree) do
        if #htree == 1 then

            im.SameLine()
            for _,c in pairs(row) do
                local k,v = c[1],c[2]

	local padding = 2
	for i,row in pairs(htree) do
--            im.Indent(10)

			local nextline = false
			for _,c in pairs(row) do
				if _ == 1 then

  local audioProviderName = TorqueScriptLua.getVar( '$pref::SFX::providerName' )
  for n, p in pairs(devices) do
    if n == audioProviderName then

    local firstProviderName = ''
    for n, d in pairs(devices) do
      if n ~= 'Null' then

    for n, d in pairs(providers) do
      if n ~= 'Null' then

  if spanMeshes[roadName] then
    for _, v in pairs(spanMeshes[roadName]) do
      v:delete()

  if singleMeshes[roadName] then
    for _, v in pairs(singleMeshes[roadName]) do
      v:delete()

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

  local wp, ctr = {}, 0
  for _, wheel in pairs(wheels.wheels) do
    ctr = ctr + 1

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

  for i, paint in ipairs(vd.config.paints) do
    for attribute, value in pairs(paint) do
      if type(value) == "table" then

        local tableKeys = tableKeysWeightSorted(v, tableWeights)
        for _, kk in pairs(tableKeys) do
          local vv = v[kk]

        self.red[3] = self.red[2]
        for _, zone in pairs(sites.zones.objects) do
          zone:drawDebug(nil, not isInside and self.red or self.white, 2, -0.5, isInside)

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

  if dragData.racers then
    for _,racer in pairs(dragData.racers) do
      table.insert(dials, {vehId = racer.vehId, dial = 0})

  dragData = dData
  for _, racer in pairs(dragData.racers) do
    racer.currentPhase = pIndex

    local isActivityFinished = true
    for vehId, racer in pairs(dragData.racers) do
      if not racer.isFinished then

    local dependenciesCompleted = true
    for _, r in pairs(dragData.racers) do
      if not r.phases[r.currentPhase].completed then

    --   for vehId, racer in pairs(dragData.racers) do
    --     funcPhases[phase.name](vehId, dtSim)

  for flexKey, flexbody in pairs(vehicle.flexbodies) do
    flexmeshMats[flexbody.mesh] = vehicleObj:getMeshsMaterialsTbl(flexbody.mesh)

      --if(not meshes or #meshes == 0 or (#meshes == 1 and meshes[1] == '')) then log('E', "material.init", "[glowmap] No meshes containing material " .. orgMat) end
      for meshi, mesh in pairs(meshes) do
        local gmat = deepcopy(gm)

            elseif type(gm.simpleFunction) == "table" then
              for fk, fc in pairs(gm.simpleFunction) do
                local s = "(" .. fk .. "*" .. fc .. ")"

          elseif gm.advancedFunction and gm.advancedFunction.triggers and gm.advancedFunction.cmd then
            for _, fc in pairs(gm.advancedFunction.triggers) do
              mv[fc] = 0

  -- debug helper: list all materials on a mesh:
  --for flexKey, flexbody in pairs(vehicle.flexbodies) do
  --    log('D', "material.init", "flexbody mesh '"..flexbody.mesh.."' contains the following materials: " .. dumps(vehicleObj:getMeshsMaterialsTbl(flexbody.mesh)))

  for flexKey, flexbody in pairs(vehicle.flexbodies) do
    if flexbody.deformGroup and flexbody.deformGroup ~= "" then

      for mati, matName in pairs(flexmeshMats[flexbody.mesh]) do
        if matName == "" then

    for i, b in pairs(vehicle.beams) do
      if b.deformGroup then

        local deformGroups = type(b.deformGroup) == "table" and b.deformGroup or {b.deformGroup}
        for _, g in pairs(deformGroups) do
          if switchTmp[g] ~= nil then

          if switchTmp[g] ~= nil then
            for sk, sv in pairs(switchTmp[g]) do
              if b.deformSwitches == nil then

  --log('I', "material.init", "available deformGroups:")
  --for k, va in pairs(assignStats) do
  --    log('I', "material.init", " * " .. k .. " on " .. va .. " beams")

  triggerList = {}
  for _, s in pairs(triggers) do
    matSet[s.msc] = s

  for tk, _ in pairs(triggerSet) do
    table.insert(triggerList, tk)

  for _, s in pairs(matSet) do
    if s.on then

  for _, va in pairs(switches) do
    switchMaterial(vehicleObj, va, nil, matState)

  local triggersCopy = deepcopy(triggers)
  for _, t in pairs(triggersCopy) do
    t.evalFunction = nil

      local i = 1
      for _, version in pairs(news) do
        if im.CollapsingHeader1(string.format("%s", version.title), i == 1 and im.TreeNodeFlags_DefaultOpen or nil) then

      local lastP
      for _, p in pairs(self.path.path) do
        debugDrawer:drawSphere(vec3(p), 0.1, ColorF(1,0,1,1))

local function tryRemoveAll()
  for k, _ in pairs(asphalts) do
    tryRemove(k)

  table.clear(asphalts)
  for k, _ in pairs(decals) do
    tryRemove(k)

  local elementNames = {}
  for _, element in pairs(elements) do
    if not element.name or element.name == "" then

    if im.Button("Save & Close##ctrlDefinitions") then
      for _, typeData in pairs(signalCtrlDefinitions.types) do
        if typeData.statesArraySize then

      for _, state in pairs(signalCtrlDefinitions.states) do
        if state._edited then

              local color = imColors.white
              for k, c in pairs(imColors) do
                if string.startswith(state.state, k) then -- can be green, yellow, or red

  for k, v in pairs(timedTexts) do
    if v[2] then

  for id, state in pairs(self.pinIn.raceData.value.states) do
    local veh = getObjectByID(id)

    local ctr = 0
    for i, s in pairs(activeUltrasonicSensors) do
      ctr = ctr + 1

    
    for k, v in pairs(sensorData) do
      print("ultrasonic reading: "..k.." reading value: "..v)

  local inv = players[player] or {}
  for k, v in pairs(inv) do
      callback(k, v)

  for k,v in pairs(data.rewards) do
    -- ignore all keys for medals

    earned[k] = earned[k] or {}
    for _,value in pairs(data) do
      table.insert(earned[k], value)

  if rewards then
    for k,data in pairs(rewards) do
      if statistics_statistics.getMedalRanking(k) >= 0 then

      if statistics_statistics.getMedalRanking(k) >= 0 then
        for subKey,value in pairs(data) do
          if subKey == 'choices' then

  local finalResultInfo = {}
  for k,v in pairs(earned) do
    finalResultInfo[k] = v

  for k,v in pairs(pendingChoice) do
    finalResultInfo[k] = v

  if choices then
    for k,v in pairs(choices) do
      core_inventory.addItem("$$$_"..k, v[selectionIndex])

  table.clear(self.sorted)
  for _, o in pairs(self.objects) do
    table.insert(self.sorted, o)

  local blacklistLookup = {}
  for _, v in pairs(vehicleBlacklist) do
    blacklistLookup[v] = true

  local filteredConfigs = {}
  for k, v in pairs(configs) do
    if (not vehicleToTest or v.model_key == vehicleToTest) and ((not pcFileToTest or pcFileToTest == "") or v.key == pcFileToTest) and not blacklistLookup[v.model_key] then

  local progressCount = 1
  for _, v in pairs(filteredConfigs) do
    local vehName = v.model_key

  log("I", logTag, "Vehicles that are skipped:")
  for _, value in pairs(vehicleBlacklist) do
    log("I", logTag, value)

    if isGroupMode or (div[lIdx][7]:squaredDistance(camPos) < innerCullLimSq) then
      for lane, _ in pairs(roadLanes) do
        local dL = div[lane]

  local objData = self:getSignalObjects(true)
  for _, objId in pairs(objData) do
    if scenetree.objectExists(objId) then

    self.targetPos = vec3()
    for _, v in pairs(vectors) do
      self.targetPos:setAdd(v)

    for k, _ in pairs(vectors) do -- sets the same intersection data for all matching instances
      instancesByName[k].targetPos = self.targetPos

  for k, v in pairs(data) do
    self[k] = v

function SignalController:onSerialize()
  for _, state in pairs(self.states) do
    if state.duration and state.duration < 0 then

  for k, v in pairs(data) do
    self[k] = v

function SignalSequence:resolveUpdates(forceUpdate) -- updates all linked signal states and lights
  for _, state in pairs(self.controllerStates) do
    if state._updated or forceUpdate then

      local stateBase = state.controller.states[state.stateIdx]
      for _, instance in pairs(state.instances) do
        if instance.active then

  for _, state in pairs(self.controllerStates) do
    state.stateIdx = state.controller.defaultIndex or 1

      local stateRef = state.controller:getStateData(stateBase.state)
      for _, instance in pairs(state.instances) do
        instance:setLights(stateRef and stateRef.lights)

  else
    for _, state in pairs(self.controllerStates) do
      for _, instance in pairs(state.instances) do

    for _, state in pairs(self.controllerStates) do
      for _, instance in pairs(state.instances) do
        signalUpdates[instance.name] = 'none'

  for k, v in pairs(data) do
    self[k] = v

  end
  for _, instance in pairs(instances) do
    if not instance._invalid then

  if instances[1] then
    for _, instance in pairs(instances) do
      instance.active = false

  if active then
    for stateName, stateDef in pairs(controllerDefinitions.states) do
      if stateDef.flashingActive and stateDef.flashingLights then -- process flashing lights

    for k, state in pairs(signalUpdates) do
      signalUpdateResults[k] = {state = state}

  for k, e in pairs({instances = instances, controllers = controllers, sequences = sequences}) do
    data[k] = {}

  _uid = 0
  for k, e in pairs({instances = instances, controllers = controllers, sequences = sequences}) do
    for i, v in ipairs(e) do

  for _, flexbody in pairs(vBundle.vdata.flexbodies) do
    if not flexbody._blinkTimer then

  --dumpz(part, 2)
  for _, flexbody in pairs(part.flexbodies or {}) do
    vehicle:setMeshAlpha(alpha, flexbody.mesh)

  for _, slot in pairs(part.slots or {}) do
    local chosenPartName = vBundle.chosenParts[slot.type]

  for key, val in pairs(attempt.unlockedStars or {}) do

  local bonusStarsUnlockedCount = 0
  for key, _ in pairs(mission.careerSetup._activeStarCache.defaultStarKeysByKey) do
    if attempt.unlockedStars[key] then

  end
  for key, _ in pairs(mission.careerSetup._activeStarCache.bonusStarKeysByKey) do
    if attempt.unlockedStars[key] then

  end
  for star, _ in pairs(attempt.unlockedStars or {}) do
    if mission.careerSetup.starsActive[star] then

    local sumChange = {}
    for key, amount in pairs(starRewards.sums) do
      sumChange[key] = (sumChange[key] or 0) + amount

  local rewardsByAttribute = {}
  for star, rewards in pairs(starRewards.originalRewardsPerStar) do
    for _, reward in ipairs(rewards) do

  -- Create single breakdown entry with total for each attribute
  for _, rewardData in pairs(rewardsByAttribute) do
    if rewardData.total > 0 then

  for progressKey, defaults in pairs(mission.defaultAggregateValues or {}) do
    if progressKey ~= "all" then

      end
      --for key, val in pairs(defaults) do
      --  prog[progressKey].aggregate[key] = val

    -- iterate over progressKeys
    for progressKey, progressData in pairs(saveData.progress) do

  -- iterate over progressKeys
  for progressKey, progressData in pairs(saveData.progress) do

      if saveData.unlockedStars then
        for k, v in pairs(saveData.unlockedStars) do
          if v == false then saveData.unlockedStars[k] = 0 end

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

  if career_career.isActive() then
    for key, starCount in pairs(mission.saveData.unlockedStars) do
      if mission.careerSetup.starsActive[key] then

  -- automaticData column headers
  for _, col in pairs(mission.autoUiAttemptProgress or {}) do
    local value = tryFormatValueForFunction(getValueForAttemptUiProgressType(attempt, col), col.formatFunction, mission)

  -- genericData column headers
  for _, col in pairs(genericUiAttemptProgress[leaderboardKey] or {}) do
    table.insert(res.labels, col.columnLabel)

  -- automaticData column headers
  for _, col in pairs(mission.autoUiAttemptProgress or {}) do
    table.insert(res.labels, col.columnLabel)

      -- genericData cells
      for _, col in pairs(genericUiAttemptProgress[leaderboardKey] or {}) do
        if col.customValue then

      -- automaticData cells
      for _, col in pairs(mission.autoUiAttemptProgress or {}) do
        table.insert(row, tryFormatValueForFunction(getValueForAttemptUiProgressType(attempt, col), col.formatFunction, mission))

    -- genericData cells
    for _, col in pairs(genericUiAttemptProgress[leaderboardKey] or {}) do
      if col.customValue then

    -- automaticData cells
    for _, col in pairs(mission.autoUiAttemptProgress or {}) do
      table.insert(row, tryFormatValueForFunction(getValueForAttemptUiProgressType(attempt, col), col.formatFunction, mission))

  -- genericData column headers
  for _, col in pairs(genericUiAggregateProgress or {}) do
    table.insert(res.labels, col.columnLabel)

  -- automaticData column headers
  for _, col in pairs(mission.autoUiAggregateProgress or {}) do
    table.insert(res.labels, col.columnLabel)

  -- build rows
  for _, m in pairs(missions) do
    if not onlySelf or (m == mission) then

        -- genericData cells
        for _, col in pairs(genericUiAggregateProgress or {}) do
          table.insert(row, tryFormatValueForFunction(getValueForAggregateUiProgressType(aggregateForProgressKey, col), col.formatFunction, m))

        -- automaticData cells
        for _, col in pairs(mission.autoUiAggregateProgress or {}) do
          local value = table.insert(row, tryFormatValueForFunction(getValueForAggregateUiProgressType(aggregateForProgressKey, col), col.formatFunction, m))

  local context = {}
  for key, value in pairs(data) do
    if type(value) == 'string' or type(value) == 'number' then

  for key, conf in pairs(bigmapConf.aggregates or {}) do
    local sd = mission.saveData.progress[conf.progressKey or mission.defaultProgressKey]

    for key, value in pairs(aConds) do
      count = count + 1

  local attempt = M.newAttempt(mission:getRandomizedAttempt())
  for k, v in pairs(addAttemptData) do
    attempt[k] = v

    for _, nid in pairs(wheel.nodes) do
      local n = v.data.nodes[nid]

  local children = {}
  for _, gr in pairs(self.mgr.graphs) do
    if gr.parentId == self.id then

  -- collect all nodes and additionally put all integrated nodes into a second list.
  for _, node in pairs(self.nodes) do
    if node.nodeType == 'macro/integrated' then

  -- gather all links which are not connected to neither an integrated node nor an IO node.
  for _, link in pairs(self.links) do
    if not (link.sourceNode.nodeType == 'macro/integrated' or link.sourceNode.nodeType == 'macro/io'

    for id, link in pairs(iNode.graph.links) do
      if link.targetNode == iNode then

    -- get links in target graph that connect from either i/o node
    for id, link in pairs(iNode.targetGraph.links) do
      if link.sourceNode == iNode.inputNode then

  local allLinks = {}
  for node, list in pairs(interInfo) do
    if node.nodeType == "macro/integrated" then

    if node.nodeType == "macro/integrated" then
      for pinName, lnkList in pairs(list.inLinks) do
        for _, link in ipairs(lnkList) do

    elseif node.nodeType == "macro/io" and node.ioType == "out" then
      for pinName, lnkList in pairs(list) do
        for _, link in ipairs(lnkList) do

  if self.mgr.gcprobe_enabled then
    for id, node in pairs(allNodes) do
      if gcprobe_grouping == 'type' then

  local nodeInFlows = {}
  for _, link in pairs(allLinks) do
    local tPin = link.targetPin

  for id, node in pairs(allNodes) do
    table.clear(node._flowColors)

        if not node.ignoreAsRoot then
          for _, pin in pairs(node.pinOut) do
            if pin.type == 'flow' then

    -- build dependency map
    for _, pin in pairs(node.pinIn) do
      local parentNode = pin.node

    for _, mPin in pairs(node._mInFlow) do
      for _, pin in ipairs(mPin) do

      local hasOutFlow = false
      for _, pin in pairs(node.pinOut) do
        if pin.type == 'flow' then

    prevOutCount = #outList
    for id, node in pairs(inNodes) do
      local depsOk = true

          local dnode = ndeps[i]
          for color, _ in pairs(dnode._flowColors) do
            node._flowColors[color] = 1

      local sourceColor = node._flowColors
      for _, p in pairs(node.pinOut) do
        if outNodeIdx[p] then

        if outNodeIdx[p] then
          for targetNode, _ in pairs(outNodeIdx[p]) do
            for color, _ in pairs(targetNode._flowColors) do

          for targetNode, _ in pairs(outNodeIdx[p]) do
            for color, _ in pairs(targetNode._flowColors) do
              if sourceColor[color] == nil then

    local n = outList[i]
    for pname, mPin in pairs(n._mInFlow) do
      if #mPin > 1 then

         { __index = {value = function()
           for _,v in pairs(mPin) do
             print(mPin.value)

    for color, _ in pairs(n._flowColors) do
      if rootWork[color] == nil then

        if next(n.pinIn) ~= nil then
          for _, mPin in pairs(n._mInFlow) do
            for _, pin in ipairs(mPin) do

            local hasFlowPin = false
            for _, pin in pairs(n.pinInLocal) do
              if pin.type == 'flow' then

  table.clear(self.hookList)
  for color, orderList in pairs(rootWork) do
    if string.sub(color.name, 1, 2) == 'on' then

    for _, p in pairs(color.pinOut) do
      if p.type == 'flow' then

        table.clear(tmp1)
        for _, p in pairs(cInDeps[node]) do
          local pnum = cInDepsDict[p]

          table.insert(fun, '\n    -- multi-inflow pins')
          for pname, dOutPin in pairs(node._mInFlowPins) do
            table.clear(tmp)

            table.clear(tmp)
            for _, p in pairs(node._mInFlow[pname]) do
              local pnum = cInDepsDict[p]

          table.clear(tmp)
          for p, _ in pairs(cOutDeps[node]) do
            if p.value == nil then

      if gcprobe_grouping == 'individual' then
        table.insert(fun, '\n  for k, v in pairs(currentGarbage) do\n    gcprobeTable.entries[k].total = (gcprobeTable.entries[k].total or 0) + v\n    gcprobeTable.entries[k].count = (gcprobeTable.entries[k].count or 0) + 1\n    gcprobeTable.entries[k].history[self.mgr.frameCount+1] = v\n    gcprobeTable.entries[k].totalHistory[self.mgr.frameCount+1] = gcprobeTable.entries[k].total end ')
        table.insert(fun, '\n  gcprobeTable.total = gcprobeTable.total + garbageTotal\n  gcprobeTable.history[self.mgr.frameCount+1] = garbageTotal\n  gcprobeTable.totalHistory[self.mgr.frameCount+1] = gcprobeTable.total')

  end
  --for id, node in pairs(self.nodes) do
  --  if node.nodeType == "macro/integrated" then

  --end
  for _, node in pairs(self.nodes) do
    node:_destroy()

  -- delete any links to it
  for linkId, link in pairs(self.links) do
    if link.sourceNode == node or link.targetNode == node then

  -- delete any links to it
  for linkId, link in pairs(self.links) do
    if link.sourceNode == node or link.targetNode == node then

  for nid, node in pairs(self.nodes) do
    nodes[nid] = node:__onSerialize()

  local orderedLinks = {}
  for _, link in pairs(self.links) do
    if pinOrder[link.targetPin] then

  --[[
  for childId, child in pairs(data.children) do
    local cid = tonumber(childId) + self.mgr:getGraphNodeOffset()

function C:linkExists(startPin, endPin)
  for k, link in pairs(self.links) do
    if link.sourcePin.id == startPin.id and link.targetPin.id == endPin.id then

function C:hasLink(pin)
  for k, link in pairs(self.links) do
    if pin.type ~= 'flow' and pin.type ~= 'state' and link.targetPin.id == pin.id then

  end
  for typeA, _ in pairs(sourceTypes) do
    if targetTypes['any'] then

function C:_executionStarted()
  for _, node in pairs(self.nodes) do
    if node._executionStarted then

function C:_onClear()
  for _, node in pairs(self.nodes) do
    node:_onClear()

function C:_executionStopped()
  for _, node in pairs(self.nodes) do
    if node._executionStopped then

  --print("Root ID " .. root.id)
  for _, m in pairs(self.mgr.macros) do
    if m.id == root.macroID then

function C:getRecursiveHooksAndDependencies(hooks, deps)
  for _, node in pairs(self.nodes) do
    table.insert(hooks, node)

  end
  for _, g in pairs(self:getChildren()) do
    g:getRecursiveHooksAndDependencies(hooks, deps)

function C:findNodeRecursive(id)
  for _, node in pairs(self.nodes) do
    if node.id == id then

  local ret = nil
  for _, child in pairs(self:getChildren()) do
    if not ret then

function C:forceRecursiveNodeUpdatePosition()
  for _, gr in pairs(self:getChildren()) do
    gr:forceRecursiveNodeUpdatePosition()

  end
  for _, nd in pairs(self.nodes) do
    nd:updateNodePosition()

    local state = nil
    for _, gr in pairs(self.mgr.graphs) do
      if gr.isStateGraph and state == nil then

      if gr.isStateGraph and state == nil then
        for _, node in pairs(gr.nodes) do
          if node:representsGraph() and node:representsGraph().id == self.id then

    local children = self:getChildren()
    for _, node in pairs(self.nodes) do
      if node:representsGraph() and not node:representsGraph().isStateGraph then

      local children = parent:getChildren()
      for _, node in pairs(parent.nodes) do
        if node:representsGraph() and not node:representsGraph().isStateGraph then

    local children = {}
    for _, gr in pairs(self.mgr.graphs) do
      if gr:getParentWithStates() == nil then

    local state = nil
    for _, gr in pairs(self.mgr.graphs) do
      --print(gr.isStateGraph)

      if gr.isStateGraph and state == nil then
        for _, node in pairs(gr.nodes) do
          if node:representsGraph() and node:representsGraph().id == last.id 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 :(

  if hydros then
    for _, h in pairs(hydros.hydros) do
      if h.inputSource == "steering_input" then --check if it's a steering hydro

    end
    for _, h in pairs(hydros.hydros) do
      if h.inputSource == "steering_input" then

    end
    for _, h in pairs(hydros.hydros) do
      if h.inputSource == "steering_input" then

  for wi, wd in pairs(wheels.wheels) do
    if wd.parkingTorque and wd.parkingTorque > 0 then

  local debug = false
  for wi1, wd1 in pairs(wheels.wheels) do
    local long1, side1 = getLongitudinalLateralPrefix(wd1.name)

      local rearWheels = {}
      for wi2, wd2 in pairs(wheels.wheels) do
        local long2, side2 = getLongitudinalLateralPrefix(wd2.name)

    vehicleMassCache = 0
    for _, n in pairs(v.data.nodes or {}) do
      vehicleMassCache = vehicleMassCache + n.nodeWeight

  local downforce = 0
  for _, wd in pairs(wheels.wheels or {}) do
    downforce = downforce + wd.downForce

    understeerAssistedSurfacesCache = {}
    for k, v in pairs(particles.getMaterialsParticlesTable()) do
      understeerAssistedSurfacesCache[k] = understeerAssistedSurfaces[v.name]

  -- map the values
  for k, e in pairs(M.state) do
    local ival = e.val or 0

  for k, e in pairs(M.state) do
    e.smootherKBD:reset()

  for _, fn in pairs(filenames or {}) do
    log('I', 'resaveCSFiles', 'converting ts script: ' .. tostring(fn) )

    local newKnownObjects = {}
    for k, v in pairs(knownObjects) do
      newKnownObjects[v] = 1

    local newObjects = {}
    for _, oName in pairs(knownObjects2) do
      if not knownObjects[oName] then

    for _, obj in pairs(newObjects) do
      log('I', '', ' * ' .. tostring(obj:getClassName()) .. ' - ' .. tostring(obj:getName()) )

    for _, obj in pairs(newObjects) do
      local className = obj:getClassName()

      -- dump(filenames)
      for _, fn in pairs(filenames) do
        log('I', 'resaveCSFiles', 'converting ts script: ' .. tostring(fn) )

        local newKnownObjects = {}
        for k, v in pairs(knownObjects) do
          newKnownObjects[v] = 1

        local newObjects = {}
        for _, oName in pairs(knownObjects2) do
          if not knownObjects[oName] then

        for _, obj in pairs(newObjects) do
          log('I', '', ' * ' .. tostring(obj:getClassName()) .. ' - ' .. tostring(obj:getName()) )

        for _, obj in pairs(newObjects) do
          local className = obj:getClassName()

  local fsInfo = Engine.Platform.getFSInfo()
  for k,v in pairs(fsInfo) do
    if v then

  for _,v in pairs(files) do
    --print("onFileChanged: " .. tostring(v.filename) .. ' : ' .. tostring(v.type))

      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

  local uniqueList = {}
  for path in pairs(uniquePaths) do -- Create a list of unique mesh paths.
    table.insert(uniqueList, path)

      local total = #mainMeshes
      for path, count in pairs(uniquePaths) do
        meshInfo[path] = count / total

    local sortedMeshes = {}
    for meshPath, freq in pairs(meshInfo) do
      table.insert(sortedMeshes, { path = meshPath, freq = freq })

  local missingCount = 0
  for id in pairs(originalIds) do -- Count the number of missing TSStatic objects.
    if not orderedIds[id] then

  local extraCount = 0
  for id in pairs(orderedIds) do -- Count the number of extra TSStatic objects.
    if not originalIds[id] then

  local meshesInPolygon = {}
  for _, meshName in pairs(scenetree.findClassObjects("TSStatic")) do
    local obj = scenetree.findObject(meshName)

M.initials = {}
for initial, probability in pairs(M.initialProbabilities) do
  for i = 1, math.ceil(probability * 100) do

  for keyEntry, entry in pairs(vehicle) do
    if type(entry) == "table" then

      local keysLen = 0
      for k, _ in pairs(entry) do
        keysLen = keysLen + 1

          else
            for cellKey,cellValue in pairs(rowValue) do
              --log('D', "jbeam.prepareLinksDestructive"," * key:"..tostring(cellKey).." = "..tostring(cellValue)..".")

  -- walk all sections
  for sectionName, section in pairs(vehicle) do
    if type(section) == "table" then

      local newSection = {}
      for rowKey, rowValue in pairs(section) do
        if vehicle.validTables[sectionName] == true and rowValue.cid then

  -- walk all sections
  for _, entry in pairs(vehicle) do
    -- walk all vehicle sections

    if type(entry) == "table" then
      for _, rowValue in pairs(entry) do
        if type(rowValue) == "table" then

          -- walk all cells
          for cellKey, groupvals in pairs(rowValue) do
            if str_byte(cellKey,1) == 91 then -- [

                -- Create groupvals index
                for _, gvalname in pairs(groupvals) do
                  groupindex[gvalname] = 1

                if sectioname == '' then sectioname = "nodes" end
                for _, val in pairs(vehicle[sectioname]) do
                  local vgn = val[groupname]

                    elseif typevgn == 'table' then
                      for _, gvalname in pairs(vgn) do
                        if groupindex[gvalname] ~= nil then

  str = string.rep("  ", indent).."<"..self.name
  for k,v in pairs(self.attribs) do
    str = str.." "..k.."=\""..v.."\""

  end
  for k, v in pairs(self.children) do
    str = str..v:toString(indent + 1)

    for vecname,v in pairs(res.tests) do
    for dynamicCol = 1, 2 do

        --local t = ''
        --for _,l in pairs(firstTest.logcache) do
          --if l.level then

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

  self.actions = {}
  for k, v in pairs(self.baseActions) do
    self.actions[k] = v

  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

  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

  local taxisToDiscard = {}
  for vehId, state in pairs(blinkerStates) do
    local veh = getObjectByID(vehId)

local function extractTaxiIds()
  for vehId, _ in pairs(map.objects) do
    if isTaxi(vehId) then

  local missingVehIds = {}
  for vehId, _ in pairs(taxiIdsList) do
    if not ignoreTaxiIdsList[vehId] then

  if apps then
    for _, app in pairs(apps) do
      if app.types then

  local commonFilters = {}
  for _, propName in pairs(filtersWhiteList) do
    if filterByProp[propName] then

      local options = {}
      for option, _ in pairs(filterByProp[propName]) do
        table.insert(options, option)

  local items = {}
  for _, app in pairs(apps) do
    if filterInstance.passesFilters(app) then

  local remainingCategories = {}
  for category, _ in pairs(categoryGroups) do
    table.insert(remainingCategories, category)

    local allButtons = buttonInstance.getAllButtonInfos()
    for buttonId, buttonInfo in pairs(allButtons) do
      if buttonInfo.meta and buttonInfo.meta.label == translateHelper.translate("ui.apps.selector.addToLayout") then

  if gameplayList then
    for _, item in pairs(gameplayList) do
      for _, propName in pairs(filtersWhiteList) do

    for _, item in pairs(gameplayList) do
      for _, propName in pairs(filtersWhiteList) do
        local propVal = item[propName:lower()]

        if type(propVal) == "table" then
          for _, val in pairs(propVal) do
            filterByProp[propName][val] = true

  local filters = {}
  for _, propName in pairs(filtersWhiteList) do
    local options = {}

    local options = {}
    for option, _ in pairs(filterByProp[propName] or {}) do
      table.insert(options, option)

    if not match then
      for _, propName in pairs(filtersWhiteList) do
        local propVal = item[propName:lower()] or item[propName]

    if filter.type == 'set' then
      for _, option in pairs(filter.options) do
        if propVal == option and not filter.currentFilterValues[option] then

  local validItems = {}
  for _, item in pairs(items) do
    if item.validBackends[M.backendName] then

      -- Check if at least one light object exists
      for _, light in pairs(laneTree.stageLights) do
        if light and light.obj then

      end
      for _, light in pairs(laneTree.countDownLights) do
        if light and light.obj then

  for _, laneTree in ipairs(dragData.strip.treeLights) do
    for _,group in pairs(laneTree) do
      if type(group) == "table" then

      if type(group) == "table" then
        for _,light in pairs(group) do
          if type(light) == "table" and light.obj and simObjectExists(light.obj) then

  if not dragData then return end
  for _, digitTypeData in pairs(dragData.strip.displayDigits) do
    for _,laneTypeData in ipairs(digitTypeData) do

  for vehId, racer in pairs(dragData.racers) do
    if racer.isPlayable then

  for vehId, racer in pairs(dragData.racers) do
    -- Send times to UI continuously if display signs are not available and racer is in race phase

      for _, laneTree in ipairs(dragData.strip.treeLights) do
        for _, group in pairs(laneTree) do
          if type(group) == "table" then

          if type(group) == "table" then
            for _, light in pairs(group) do
              if type(light) == "table" and light.obj and simObjectExists(light.obj) then

      end
      for _, digitTypeData in pairs(dragData.strip.displayDigits) do
        for _, laneTypeData in ipairs(digitTypeData) do

      for _, laneTree in ipairs(dragData.strip.treeLights) do
        for _, group in pairs(laneTree) do
          if type(group) == "table" then

          if type(group) == "table" then
            for _, light in pairs(group) do
              if type(light) == "table" and light.obj and simObjectExists(light.obj) then

      end
      for _, digitTypeData in pairs(dragData.strip.displayDigits) do
        for _, laneTypeData in ipairs(digitTypeData) do

      for _, laneTree in ipairs(dragData.strip.treeLights) do
        for _, group in pairs(laneTree) do
          if type(group) == "table" then

          if type(group) == "table" then
            for _, light in pairs(group) do
              if type(light) == "table" and light.obj and simObjectExists(light.obj) then

      end
      for _, digitTypeData in pairs(dragData.strip.displayDigits) do
        for _, laneTypeData in ipairs(digitTypeData) do

      for _, laneTree in ipairs(dragData.strip.treeLights) do
        for _, group in pairs(laneTree) do
          if type(group) == "table" then

          if type(group) == "table" then
            for _, light in pairs(group) do
              if type(light) == "table" and light.obj and simObjectExists(light.obj) then

      end
      for _, digitTypeData in pairs(dragData.strip.displayDigits) do
        for _, laneTypeData in ipairs(digitTypeData) do

  for groupName, wheelGroup in pairs(wheelGroups) do
    local groupPressure = 0

    local groupPressure = 0
    for _, wheelData in pairs(wheelGroup.wheelData) do
      wheelData.isWheelBrokenOff = wheels.wheels[wheelData.wheelId].isBroken

    for _, wheelData in pairs(wheelGroup.wheelData) do
      local pressureDiff = preSyncGroupPressure - wheelData.currentPressure

  local pressureChangeInflateDeflate = activeGroupPressureChange * dt
  for groupName, isActive in pairs(activeGroups) do
    local wheelGroup = wheelGroups[groupName]

    if isActive then
      for _, wheelData in pairs(wheelGroup.wheelData) do
        local pressureDiff = activeGroupAvgPressure - wheelData.currentPressure

            for groupName, wheelGroup in pairs(wheelGroups) do
              table.insert(

local function reset(jbeamData)
  for groupName, wheelGroup in pairs(wheelGroups) do
    activeGroups[groupName] = false

    activeGroups[groupName] = false
    for _, wheelData in pairs(wheelGroup.wheelData) do
      wheelData.currentPressure = 0

    local wheelGroupData = tableFromHeaderTable(jbeamData.wheelGroups or {})
    for _, wheelGroup in pairs(wheelGroupData) do
      local groupName = wheelGroup.groupName

        local wheelData = {}
        for _, wheelName in pairs(wheelNames) do
          local wheelId = wheels.wheelIDs[wheelName]

  if not self.path then return end
  for _, seg in pairs(self.path.segments.objects) do
    seg._drawMode = 'normal'

  --self:selectSegment(nil)
  for _, seg in pairs(self.path.segments.objects) do
    seg._drawMode = 'faded'

  self.capsuleIndex = nil
  for _, seg in pairs(self.path.segments.objects) do
    seg._drawMode = (index == seg.id) and 'highlight' or 'normal'

  for _, n in pairs(self.path.pacenotes.objects) do
    if index and index ~= -1 and n.segment == index then

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

      if receiveResult == M.errorCodes.OK then
        for _, callback in pairs(canMessageCallbacks) do
          callback(msg)

  M.errorCodeLookup = {}
  for key, value in pairs(M.errorCodes) do
    M.errorCodeLookup[value] = key

  for cautionVal,cautionText in pairs(mapping.caution) do
    if cautionText == '' then

  if gameplayList then
    for _, item in pairs(gameplayList) do
      for _, propName in pairs(filtersWhiteList) do

    for _, item in pairs(gameplayList) do
      for _, propName in pairs(filtersWhiteList) do
        local propVal = item[propName:lower()]

        if type(propVal) == "table" then
          for _, val in pairs(propVal) do
            filterByProp[propName][val] = true

  local filters = {}
  for _, propName in pairs(filtersWhiteList) do
    local options = {}

    local options = {}
    for option, _ in pairs(filterByProp[propName] or {}) do
      table.insert(options, option)

    if not match then
      for _, propName in pairs(filtersWhiteList) do
        local propVal = item[propName:lower()] or item[propName]

    if filter.type == 'set' then
      for _, option in pairs(filter.options) do
        if propVal == option and not filter.currentFilterValues[option] then

  local validItems = {}
  for _, item in pairs(items) do
    if item.validBackends[M.backendName] then

    if vData and vData.vdata and vData.vdata.nodes then
      for nodeId, node in pairs(vData.vdata.nodes) do
        if (node.couplerTag and node.couplerTag:find('fifthwheel')) or (node.tag and node.tag:find('fifthwheel')) then

      end
      for name, c in pairs(fromGroup) do
        for j = 1, numSignals do

  local avgWheelNodePos, numOfWheels, maxWheelRadius = vec3(), 0, -math.huge
  for _, wheel in pairs(wheels.wheels) do
    avgWheelNodePos:setAdd(obj:getOriginalNodePositionRelative(wheel.node1))

    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 sortedKeys = {}
  for key, mode in pairs(editor.editModes) do
    if key ~= "objectSelect" and key ~= "createObject" and mode.icon then table.insert(sortedKeys, key) end

      -- Check if any option for this property is locked
      for _, _ in pairs(lockedFiltersByProp[propName]) do
        return true

          -- Fallback to iterating through keys if no options structure in filterList
          for key, _ in pairs(filterOptions) do
            if key ~= 'min' and key ~= 'max' then

    -- Preserve locked filters when updating
    for propName, lockedOptions in pairs(lockedFiltersByProp) do
      if newFilters[propName] then

          -- For set filters, preserve locked options
          for option, lockedValue in pairs(lockedOptions) do
            if newFilters[propName][option] ~= nil then

        if filterByProp[propName] then
          for option, value in pairs(filterByProp[propName]) do
            lockedFiltersByProp[propName][option] = value

      local hasLockedOptions = false
      for _, _ in pairs(lockedFiltersByProp[propName]) do
        hasLockedOptions = true

      if options then
        for option, enabled in pairs(options) do
          if filterByProp[propName][option] ~= nil then

  local layout = {}
  for tmp, _ in pairs(layout_options) do
    table.insert(layout, {value = tmp})

  local menu = {}
  for tmp, _ in pairs(layout_options) do
    table.insert(menu, {value = tmp})

    local allLevels = core_levels.getList()
    for _, value in pairs(allLevels) do
        if levelsToLoad[string.lower(value.levelName)] == true then

  if n.childs then
    for _, c in pairs(n.childs) do
      for ck, _ in pairs(recurseFindAttribute(c, className, attributeName)) do

    for _, c in pairs(n.childs) do
      for ck, _ in pairs(recurseFindAttribute(c, className, attributeName)) do
          res[ck] = 1

  local dir, filename, ext = path.split(sourceFile)
  for k, fn in pairs(fileList) do
    local dir2, filename2, ext2 = path.split(fn)

  if not fileList then return end
  for k, fn in pairs(fileList) do
    local dir, filename, ext = path.split(fn)

  for k, _ in pairs(rootNode.instances) do
    add(entity.deps, 'simobject', k)

  if n.childs then
    for _, c in pairs(n.childs) do
      processSimObject(c, sourceFile)

  local filenames = findFiles('*.level.json\t*.material.json\t*.datablock.json')
  for _, filename in pairs(filenames) do
    processSimObject(jsonReadFile(filename), filename)

  for _, shapeInfoFn  in pairs(shapeInfoFiles) do
    local rootNode = jsonReadFile(shapeInfoFn)

      local entity = { deps = { material = {}}, provides = { shape = shapeInfoFn:sub(1, -13) }}
      for _, m in pairs(rootNode.materials) do
        table.insert(entity.deps.material, m)

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

    function* pairs() { // [type, string, query, isMod]
      if (query.name) yield ["slot", slot.chosenPartName, query.name]

    let lastType
    for (const [type, string, query, isMod = false] of pairs()) {
      if (query && match(string, query)) {

function C:onUpdate()
  for _, callbackData in pairs(self.callbacks) do
    if callbackData.ttl > 0 then

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

local disableAllActionMaps = function()
  for key, value in pairs(ACTION_MAPS) do
    popActionMap(value)

    for i = old, new+1, -1 do
      for _, lnk in pairs(self.graph.links) do
        if lnk.sourcePin == self.pinInLocal['value_'..i] 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') )

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

  self.broadcast = function(self,...)
    for client in pairs(clients[protocol]) do
      if client ~= self then

  if opts.protocols then
    for protocol in pairs(opts.protocols) do
      clients[protocol] = {}

    if not keep_clients then
      for protocol,clients in pairs(clients) do
        for client in pairs(clients) do

      for protocol,clients in pairs(clients) do
        for client in pairs(clients) do
          coroutine.resume(coroutine.create(function ()

local function switchBrokenMaterial(beam)
  for msc, g in pairs(beam.deformSwitches) do
    --log('D', "material.switchBrokenMaterial", "mesh broke: "..g.mesh.. " with deformGroup " .. g.deformGroup)

  for msc, newMat in pairs(changedMats) do
    if newMat ~= matState[msc] then

  brokenSwitches = {}
  for mid, _ in pairs(matState) do --do not change
    matState[mid] = false

local function reset()
  for mid, _ in pairs(matState) do --do not change
    switchMaterial(mid)

  local funTab = {"return function () ", nil, " end"}
  for _, t in pairs(triggers) do
    local str = t.evalFunctionString or ""

  local modeId = 1
  for _, coordinate in pairs(modeCoordinateTable) do
    modeCoordinates[coordinate.modeName] = {x = coordinate.x, y = coordinate.y, position = modeId}

  local impulseModeCoordinateTable = tableFromHeaderTable(jbeamData.impulseModeCoordinates or {})
  for _, impulseMode in pairs(impulseModeCoordinateTable) do
    --we only support modes here with a length of at least 2

  for _, modeChange in pairs(modeChangesTable) do
    local index1 = modeChange.mode1 .. modeChange.mode2

    modeChanges[index2] = {}
    for _, pos in pairs(modeChange.intermediateCoordinates) do
      --normal order as per jbeam

    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

-- function printFields(obj)
--   for k, v in pairs(obj) do
--     -- if type(v) == "function" then

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

  device.actuatorBeams = {}
  for _, tag in pairs(beamTags) do
    local beamCids = beamstate.tagBeamMap[tag]

    if beamCids then
      for _, beamCid in pairs(beamCids) do
        table.insert(device.actuatorBeams, beamCid)

function C:afterTrigger()
  for id, timer in pairs(self.timers) do
    -- finalize the pauseFlag

      local numOfTrapsTriggered = 0
      for name, velocityMilestone in pairs(velocityMilestonesByTrapName) do
        if milestones.saveData.general[velocityMilestone.id].notificationStep > 0 then

function C:work()
  for k, pin in pairs(self.pinInLocal) do
    if pin.type == 'color' then

  device.consumerJbeamData = {}
  for _, ph in pairs(v.data.powertrainHydros or {}) do
    if ph.connectedPump == device.name then

  local ptoConsumerNodeNames = jbeamData.hydraulicPTOConsumerCouplerNodeNames or {}
  for _, nodeName in pairs(ptoConsumerNodeNames) do
    if beamstate.nodeNameMap[nodeName] then

  for spotName, spot in pairs(sitesData.parkingSpots.byName) do
    if spot.zones then

  M.updateGFX = debugEnabled and updateGFXDebugEnabled or updateGFXDebugNotEnabled
  for _, c in pairs(subControllerLookup) do
    if c.typeName ~= "drivingDynamics/CMU" and c.setDebugMode then

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

      local children = {}
      for id, branch in pairs(remaining) do
        if branch.parentId == parentId then

    -- Now that all branches are loaded, handle color inheritance
    for _, branch in pairs(branchesById) do
      branch.color = branch.color or getInheritedColor(branch, 'color')

        if mission.careerSetup.showInCareer then
          for branchKey, _ in pairs(mission.unlocks.branchTags) do
            if branchKey == skill.id then

  local saveData = { }
  for id, branch in pairs(getBranches()) do
    saveData[id] = {}

  local data = (savePath and not outdated and jsonReadFile(savePath .. "/career/"..saveFile)) or {}
  for id, branch in pairs(getBranches()) do
    for k, v in pairs(data[id] or {}) do

  for id, branch in pairs(getBranches()) do
    for k, v in pairs(data[id] or {}) do
      --branch[k] = v

local function checkUnlocks()
  for id, branch in pairs(getBranches()) do
    branch.unlocked = true

  for id, branch in pairs(getBranches()) do
    -- for levels

    -- for levels
    for lvl, lvlData in pairs(branch.levels or {}) do
      local unlockFlags = lvlData.unlockFlags or {}

local newAttributeNamesToOldNames = {}
for oldName, newName in pairs(oldAttributeNamesToNewNames) do
  newAttributeNamesToOldNames[newName] = oldName

    local ctr = 0
    for i, s in pairs(activeLidarSensors) do
      ctr = ctr + 1

    local ctr = 0
    for i, s in pairs(lidarPointCloud) do
      ctr = ctr + 1

  -- Find bounds from all navgraph nodes
  for nodeId, node in pairs(mapData.nodes) do
    if node.pos 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)

  end
  for key, poisInCluster in pairs(poisByPath) do
    local pm = poisInCluster[1].markerInfo.parkingMarker

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)

      --  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 lIdx = 1
    for nid, n in pairs(map.getMap().nodes) do
      for lid, data in pairs(n.links) do

    for nid, n in pairs(map.getMap().nodes) do
      for lid, data in pairs(n.links) do
        if data.hiddenInNavi then goto continue end

  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

      for key, value in pairs(cleaned.values) do
        if value == true then

  -- Convert map to array
  for _, vehicleModel in pairs(modelsMap) do
    if #vehicleModel.configs > 0 then

      local selectedOptions = {}
      for option, selected in pairs(filter.values) do
        if selected and option ~= 'Other...' then

          if filterInfo then
            for key, _ in pairs(filterInfo) do
              if key ~= 'Other...' and not filter.values[key] then

  local modelList, configList = {}, {}
  for modelName, _ in pairs(core_vehicles.getModelsData()) do
    table.insert(modelList, core_vehicles.getModel(modelName).model)

    table.insert(modelList, core_vehicles.getModel(modelName).model)
    for _, config in pairs(core_vehicles.getModel(modelName).configs or {}) do
      table.insert(configList, config)

        end
        for _, value in pairs(values) do
          filterByProp[propName][value] = true

  for _, model in ipairs(modelList) do
    for _, propName in pairs(filtersWhiteList) do
      local propVal = model[propName]

  -- Then scan configs (for config-level properties like Drivetrain, Config Type, etc.)
  for _, config in pairs(configList) do
    for _, propName in pairs(filtersWhiteList) do

  for _, config in pairs(configList) do
    for _, propName in pairs(filtersWhiteList) do
      local propVal = config[propName]

  local filterUiData = {}
  for _, propName in pairs(filtersWhiteList) do
    if filterByProp[propName] then

        local selectedCount = 0
        for _, selected in pairs(filter.values) do
          if selected then selectedCount = selectedCount + 1 end

        local selectedCount = 0
        for _, selected in pairs(filter.values) do
          if selected then selectedCount = selectedCount + 1 end

          local selectedCount = 0
          for _, selected in pairs(filter.values) do
            if selected then selectedCount = selectedCount + 1 end

          local selectedCount = 0
          for _, selected in pairs(filter.values) do
            if selected then selectedCount = selectedCount + 1 end

  local currentRemovalsCount = 0
  for _ in pairs(e.manualRemovals) do
    currentRemovalsCount = currentRemovalsCount + 1

      e._cachedRemovalsNested = {}
      for configKey, _ in pairs(e.manualRemovals) do
        local model, config = configKey:match("^([^/]+)/(.+)$")

  local allModels = {}
  for modelName, _ in pairs(core_vehicles.getModelsData()) do
    local model = core_vehicles.getModel(modelName)

      local configs = {}
      for configName, _ in pairs(model.configs) do
        table.insert(configs, configName)

  local matFiles = FS:findFiles( path, 'materials.cs', -1, true, false)
  for k,v in pairs(matFiles) do
    TorqueScriptLua.exec(v)

  local matFiles = FS:findFiles( path, '*materials.json', -1, true, false)
  for k,v in pairs(matFiles) do
    loadJsonMaterialsFile(v)

  local jFiles = FS:findFiles(mapFolder.."/buslines/", '*.buslines.json', -1, true, false)
  for _,jFilename in pairs(jFiles) do
    local data = jsonReadFile(jFilename)

      if data.version == 1 then
        for k,v in pairs(data.routes) do table.insert( busLines.routes, v ) end
      end

  --checking triggers exist
  for _,route in pairs(busLines.routes) do
    local task_data = {}

    local task_data = {}
    for i,task in pairs(route.tasklist) do
      if triggerPos[task] then

local function setLine(vehId, routeID, variance)
  for k,v in pairs(busLines.routes) do
    if (v.routeID == routeID and v.variance == variance) then

  for id, veh in pairs(policeVehs) do
    if getObjectByID(id):getActive() then

    for id, veh in pairs(traffic) do
      if id ~= targetId and veh.pursuit.mode >= 1 and veh.pos:squaredDistance(targetVeh.pos) < 6400 then -- during active arrest, clear pursuit level of nearby suspects

  local tempIds = {}
  for pid, p in pairs(policeVehs) do
    if p.role.targetId == id then

  local tempIds = {}
  for pid, p in pairs(policeVehs) do
    if p.role.targetId == id then

  local tempIds = {}
  for pid, p in pairs(policeVehs) do
    if p.role.targetId == id then

  for id, veh in pairs(gameplay_traffic.getTrafficData()) do
    local pursuit = veh.pursuit

                for otherId, otherVeh in pairs(policeVehs) do -- first, check for police vehicles that are out of sight
                  if getObjectByID(otherId):getActive() and otherVeh.role.validTargets[id] and otherVeh.role.validTargets[id].dist > 10000

local function updateGFX(dtSim)
  for sensorId, _ in pairs(roadsSensors) do
    updateRoadsSensorGFXStep(dtSim, sensorId, false, nil)

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

      local fuelTranslations = {}
      for fuelType, _ in pairs(fuelTypes) do
        if fuelType ~= "unknown" then

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

local function debugDraw(focusPos)
  for _, v in pairs(debugVectors) do
    obj.debugDrawProxy:drawNodeVector3d(v.thickness or 0.05, v.cid, v.vector, v.color)

  isTouchingGround = false
  for nodeCid, _ in pairs(ballNodes) do
    isTouchingWater = isTouchingWater or obj:inWater(nodeCid)

  for _, beam in pairs(v.data.beams) do
    if beam.tag == jbeamData.stabilizationBeamFront then

  for _, node in pairs(v.data.nodes) do
    if node.tag == "ball" then

  -- convert keys of the table to string, because js doesnt support number keys
  for inventoryId, computerFunction in pairs(computerFunctions.vehicleSpecific) do
    computerFunctionsForUI.vehicleSpecific[tostring(inventoryId)] = computerFunction

  for i, levelInfo in ipairs(organization.reputationLevels) do
    for attributeKey, attributeValue in pairs(levelDefaults[i-2]) do
      if levelInfo[attributeKey] then

        if type(levelInfo[attributeKey]) == "table" then
          for key, value in pairs(attributeValue) do
            levelInfo[attributeKey][key] = levelInfo[attributeKey][key] or value

  for vecname, v in pairs(res.tests) do
    for i, test in ipairs(v.tests) do

  table.insert(rCurve, 1, {0,0})
  for i, p in pairs(rCurve) do
    p[1] = p[1]/maxx

  for k, f in pairs(inputFlex) do
    local eval = electrics.values[k]

  if v.data.hydros then
    for _, h in pairs(v.data.hydros) do
      h.fIsBroken = obj.beamIsBroken

  if v.data.torsionHydros then
    for _, h in pairs(v.data.torsionHydros) do
      h.fIsBroken = obj.torsionbarIsBroken

  for _, h in pairs(M.hydros) do
    h.inputCenter = h.inputCenter * h.inputFactor

  table.clear(poweredWheelIndices)
  for index, wheel in pairs(wheels.wheels) do
    if poweredWheelNames[wheel.name] then

  for _,h in pairs(M.hydros) do
    h.state = h.center + 1e-28 -- so as it initializes correctly

  unlockedStars.completeTraffic = false
  for id, v in pairs(gameplay_traffic.getTrafficData()) do
    if be:getObjectActive(id) and v.roleName == 'standard' then

    }
    for gearIndex, _ in pairs(device.gearRatios) do
      integrityState.synchroWear[gearIndex] = 0

  for k, v in pairs(device.initialGearRatios) do
    device.gearRatios[k] = v

  local reverseGears = {}
  for _, v in pairs(jbeamData.gearRatios) do
    table.insert(v >= 0 and forwardGears or reverseGears, v)

    local gearIndex = device.minGearIndex
    for _, v in pairs(gearWhineCoefsOutput) do
      device.gearWhineCoefsOutput[gearIndex] = v

    local gearIndex = device.minGearIndex
    for _, v in pairs(gearWhineCoefsInput) do
      device.gearWhineCoefsInput[gearIndex] = v

  local synchroSettingLookup = {}
  for _, settings in pairs(synchroSettings) do
    if settings.gearIndex then

  device.synchroWearCoef = {}
  for i, _ in pairs(device.gearRatios) do
    local gearSettings = synchroSettingLookup[i] or {}

  if not jbeamData.synchronizerSettings then
    for i, _ in pairs(device.gearRatios) do
      if i >= 0 then

    -- traversal of hidden values
    hidden = function() return pairs(mt.__index) end,
    -- traversal of table ordered: returning index, key

    -- traversal of table
    pairs = function(self) return pairs(self) end,
    -- traversal of table ordered: returning key,value

  -- walk and merge all sections
  for sectionKey, section in pairs(source) do
    if sectionKey == 'slots' or sectionKey == 'slots2' or sectionKey == "information" then

        local slotOptionReset = {}
        for k4, v4 in pairs(localSlotOptions) do
          slotOptionReset[k4] = ""

      local localSlotOptions = nil
      for k3, v3 in pairs(section) do
        if tonumber(k3) ~= nil then

        local slotOptionReset = {}
        for k4, v4 in pairs(localSlotOptions) do
          slotOptionReset[k4] = ""

    local valid = true
    for k, v in pairs(filters) do -- optional filters by traffic vehicle properties
      if veh[k] ~= nil and veh[k] ~= v then

  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]

  -- for k, v in pairs(tagsWithRefs) do
  --   print(string.format("%s : %d", k, #v))

  if insuranceModule.doesInsuranceExist(insuranceId) then
    for _, choiceData in pairs(data.repairOptions.insuranceRepairData.repairTimeOptions.choices) do
      if choiceData.id == defaultRepairTimeChoiceData.currentValueId then

  for _, choiceData in pairs(data.repairOptions.noInsuranceRepairData.repairTimeOptions.choices) do
    local totalPrice = choiceData.premiumInfluence + data.vehicleData.damageCost

  for _, stepScoreData in ipairs(scoringDataPerStep) do
    for _, scoreData in pairs(stepScoreData) do
      totalScore = totalScore + scoreData.score

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

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

  for _, screen in pairs(screens) do
    local queueString = string.format("extensions.tech_multiscreen.addVehicleView(%q, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %d, %d, %.2f, %.2f, %.2f, %.2f, %d, %d, %d, %s)",

  if #offset then
    for k,v in pairs(offset) do
      M.setAngleOffset(k,v.angleOffset.x,v.angleOffset.z, veh)

  local mytable = {}
  for k,v in pairs(vdata.vdata.mirrors ) do
    if v.mesh then

  local mid = -1
  for i in pairs(vdata.vdata.mirrors) do
    if vdata.vdata.mirrors[i].mesh == mirrorName then

      imguiSliderData = {}
      for k,v in pairs(imguiMirrordata) do
        imguiSliderData[k] = {im.FloatPtr(v.angleOffset.x or 0), im.FloatPtr(v.angleOffset.z or 0)}

      if im.Button("save") then
        for k,v in pairs(imguiMirrordata) do
          setAngleOffset(k,imguiSliderData[k][1][0], imguiSliderData[k][2][0], nil, true)

      local focusedAny = false
      for k,v in pairs(imguiMirrordata) do
        im.TextUnformatted(dumps(k))

  local viewFrustum = Engine.sceneGetCameraFrustum()
  for i in pairs(vdata.vdata.mirrors) do
    if vdata.vdata.mirrors[i].mesh == mirror_name then

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

local function getMass()  -- !!!!!!!!!!!!!!!!!!
  for _, n in pairs(v.data.nodes) do
    mass = mass + n.nodeWeight

  local sum = 0
  for _,v in pairs(t) do
    sum = sum + v

  local vehicles, ctr = {}, 1
  for k, v in pairs(mapmgr.getObjects()) do
    if k == tonumber(vehicleInfront) then -- for dmpc key

    for i, vehicles in ipairs(relayVehicles) do 
      for k, v in pairs(mapmgr.getObjects()) do
        if k == tonumber(vehicles) then

  if next(simData) ~= nil then  -- simData contains the data of the closest vehicles
    for k, v in pairs(simData) do
      if type(v) == "table" then

        if k =="closestVehicles1" then  -- closest detected vehicle
          for k2,v2 in pairs(v) do
            if k2 == "distToPlayerVehicleSq" then

  for partName, part in pairs(activePartsData or {}) do
    if part.slotType then

  if not self.done and self.pinIn.flow.value and self.pinIn.name.value and self.message then
    for name, pin in pairs(self.pinOut) do
      self.pinOut[name].value = self.message[name] or nil

    local newTable = {}
    for _, v in pairs(vehicle.soundscape) do
      newTable[v.name] = v

  local name = initialName .. (counter or "")
  for k, mtl in pairs(materialsInJson) do
    if mtl.internalName == name then

  for uniqueID, jsonMtl in pairs(jsonMaterials) do
    if jsonMtl.class ~= "TerrainMaterialTextureSet" then

local function selectPaintMaterialByName(internalName)
  for _, mtl in pairs(paintMaterialProxies) do
    if mtl.internalName == internalName then

  -- attach all terrain blocks
  for tbName, tbData in pairs(terrainBlockProxies) do
    local tb = scenetree.findObjectById(tbData.id)

  -- check if the TerrainBlock with the given name already exist
  for tbName, tbData in pairs(terrainBlockProxies) do
    if string.lower(tbName) == string.lower(terrBlockName) then

  local success = false
  for tbName, tbData in pairs(terrainBlockProxies) do
    local tb = scenetree.findObjectById(tbData.id)

  else
    for name, tbData in pairs(terrainBlockProxies) do
      if tbData then tbData.selected = false end

  if im.BeginCombo("##availableMaterials", "") then
    for id, mat in pairs(materialsInJson) do
      if not hasPaintMaterial(mat.internalName) then

      end
      for id, notification in pairs(notifications) do
        im.TextColored(im.ImVec4(1.0, 0.73, 0.04, 1.0), notification)

    if im.CollapsingHeader1("Select Terrain(s)", im.TreeNodeFlags_DefaultOpen) then
      for tbName, tbData in pairs(terrainBlockProxies) do
        im.Spacing()

  profilerPushEvent("terrainEditor terrainToolsEditModeUpdate")
  for tbName, tbData in pairs(terrainBlockProxies) do
    local tb = scenetree.findObjectById(tbData.id)

M.deleteMaterialInJson = function (name)
  for id, value in pairs(materialsInJson) do
    if value.internalName == name then

M.getTerrainBlockMaterialIndex = function (name)
  for id, value in pairs(paintMaterialProxies) do
    if value.internalName == name then

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

    extensions.load("cruiseControl")
    for _, wheel in pairs(wheels.wheels) do
      if wheel.name == "FR" then

local function saveBrushesToFile()
  for _, brush in pairs(brushes) do
    if brush["dirty"] then

M.initDefaultFields = function(fields)
  for fieldName, _ in pairs(M.schema) do
    fields[fieldName] = M.schema[fieldName].default

      for _, p in ipairs(pinsPerStat) do
        for _, lnk in pairs(self.graph.links) do
          if lnk.targetPin == self.pinInLocal[p[1]..'_'..i] 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)

  engines = powertrain.getDevicesByType("combustionEngine")
  for _, v in pairs(engines) do
    for _, j in pairs(v.registeredEnergyStorages) do

  for _, v in pairs(engines) do
    for _, j in pairs(v.registeredEnergyStorages) do
      table.insert(fuelTanks, j)

local function resetLights()
  for _,group in pairs(lights) do
    for _,light in pairs(group) do

  for _,group in pairs(lights) do
    for _,light in pairs(group) do
      if light.obj then

  local vehicleConfigs = {}
  for i,v in pairs(configs.configs) do
    local model = core_vehicles.getModel(v.model_key).model

    for _,v in pairs(vehicleConfigs) do
      if currentConfig == (v.model_key .. " " .. v.key) then

    for i,v in pairs(vehicleConfigs) do
      if (v["0-100 km/h"] and zeroToHundred)then

    for i,v in pairs(similarVehicles) do
      similarVehicleCount = similarVehicleCount + 1

    local vehiclesConfigs = {}
    for _,v in pairs(vehicleConfigs) do
      table.insert(vehiclesConfigs, v)

    if started == true then
      for i,v in pairs(vehicles) do
        if v.lane == "right" and v.id == data.subjectID then

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

  local messages = server:receiveData()
  for _, msg in pairs(messages or {}) do
    onData(msg[1], msg[2])

  for connection, subs in pairs(subscriptions) do
    for _, sub in ipairs(subs) do

        local vPos = veh:getPosition()
        for _, node in pairs(vData.vdata.nodes) do
          local name = node.name or tostring(node.cid)

local function hideAllWindows()
  for key, val in pairs(windowsState) do
    if val.visible[0] then

local function setWindowGroupVisibility(groupName, visible)
  for key, val in pairs(windowsState) do
    if val.groupName == groupName then

  state.version = WindowsStateFileFormatVersion
  for key, val in pairs(windowsState) do
    -- we do this because we cant serialize ffi and C++ objects

  for key, val in pairs(windowsState) do
    val.isVisible = false

  -- copy over the state for each window
  for key, val in pairs(wstate.windowsState or {}) do
    windowsState[key] = val

  -- resolve the size, pos and visibility
  for key, val in pairs(windowsState) do
    val.visible = imgui.BoolPtr(val.isVisible or false)

local function callShowWindowHookForVisibleWindows()
  for key, val in pairs(windowsState) do
    if val.visible[0] then

local function defocusFocusedWindow()
  for key, val in pairs(windowsState) do
    if val.focused then

  table.clear(kingpinTimeoutsToDelete)
  for obj2Id, _ in pairs(kingpinRequestTimeouts) do
    kingpinRequestTimeouts[obj2Id] = kingpinRequestTimeouts[obj2Id] - dt

    local minDistanceNodeCid
    for objId, nodeData in pairs(kingpinCache) do
      for nodeCid, data in pairs(nodeData) do

    for objId, nodeData in pairs(kingpinCache) do
      for nodeCid, data in pairs(nodeData) do
        if data.distance < minDistance 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

  local uniquePointZones = {}
  for _, zone in pairs(zones.objects) do
    for _, uniqueZone in ipairs(uniquePointZones) do

  local string = "Hitting the colored zones gives you points:
"
  for _, z in pairs(uniquePointZones) do
    string = string.."
"..z.customFields:get('points').." Points for Zones
"

  context.profiler:add("setupValidFilters")
  for _, config in pairs(data.configs) do
    -- VEHICLE-SPECIFIC: Uses vehicle-specific filter logic

  local favouriteGroup, recentGroup = {tiles = {}}, {tiles = {}}
  for _, config in pairs(validConfigs) do
    -- GENERIC: Get groups for item (could work for any item type)

    local groupsForConfig = context.groupingModule.getGroupsForConfig(config, data.displayData.groupMode, data.displayData)
    for _, group in pairs(groupsForConfig) do
      local groupName, groupOrder = group.groupName, group.groupOrder

  -- GENERIC: Process each group to create tiles
  for _, group in pairs(groups) do
    -- Skip clustering for special groups in unclustered mode

      -- Convert configs directly to tiles without clustering
      for _, config in pairs(group.unclusteredConfigs) do
        local tile = context.itemToTileConverter(config, true)

      -- GENERIC: Create tiles for each cluster
      for _, clusteredItems in pairs(itemsClustered) do
        local tiles = context.processClusteredItems(clusteredItems, group, data.displayData.clusterMode)

        -- GENERIC: Add tiles to groups and handle special groups (favourites/recent)
        for _, tile in pairs(tiles) do
          table.insert(group.tiles, tile)

  -- GENERIC: Automatic sorting based on group type and display settings
  for _, group in pairs(groups) do
    --print(string.format("sorting group %s with mode %s %s (in handleAllModelsPath)", group.key, data.displayData.sortMode, data.displayData.groupMode))

  -- VEHICLE-SPECIFIC: Iterate through vehicle configurations
  for _, config in pairs(model.configs) do
    -- VEHICLE-SPECIFIC: Filter by vehicle submodel

function Event.call(self, ...)
  for f, _ in pairs(self.__subscribers) do f(...) end
end

            }
            for key, _ in pairs(autoPrefabs) do
              for i, p in ipairs(mission.missionTypeData[key] or {}) do

            -- add automatic prefabs only if they exist
            for list, suf in pairs(autoPrefabs) do
              for _, ext in ipairs(prefabExt) do

  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

    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

  if vehicle.events ~= nil then
    for _, ab in pairs(vehicle.events) do
      _cleanupRows(ab)

    for _, ab in pairs(vehicle.triggers) do
      _cleanupRows(ab)

    for _, lnk in pairs(vehicle.triggerEventLinks) do
      if not lnk.targetEventId then

    for _, lnk in pairs(vehicle.triggerEventLinks2) do
      if not lnk.triggerId then

  device.consumerJbeamData = {}
  for _, ph in pairs(v.data.powertrainHydros) do
    if ph.connectedPump == device.name then

  local ptoSupplyNodeNames = jbeamData.hydraulicPTOSupplyCouplerNodeNames or {}
  for _, nodeName in pairs(ptoSupplyNodeNames) do
    if beamstate.nodeNameMap[nodeName] then

  local ptoConsumerNodeNames = jbeamData.hydraulicPTOConsumerCouplerNodeNames or {}
  for _, nodeName in pairs(ptoConsumerNodeNames) do
    if beamstate.nodeNameMap[nodeName] then

  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

  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 node.children then
        for _, childNode in pairs(node.children) do
          recGetPart(childNode, outPartsHighlighted, outPartsHighlightedIdxs, outPartNameToIdx)

  -- enrich the data a bit for the UI
  for partName, uiPartInfo in pairs(availableParts) do
    local richPartInfo = {}

      if not node then return end
      for slotId, child in pairs(node.children or {}) do
        legacySlotMap[child.path] = {

    -- now simplify it
    for path, slotData in pairs(legacySlotMap) do
      if not legacySlotMapSimple[slotData.slotId] then

    -- now discard the complex data
    for key, slotData in pairs(legacySlotMapSimple) do
      if slotData ~= "COLLISION" then

    if not node then return end
    for slotId, child in pairs(node.children or {}) do
      legacySlotMap[child.path] = {

  -- now simplify it
  for path, slotData in pairs(legacySlotMap) do
    if not legacySlotMapSimple[slotData.slotId] then

  -- now discard the complex data
  for key, slotData in pairs(legacySlotMapSimple) do
    if slotData ~= "COLLISION" then

      if node.children then
        for _, childNode in pairs(node.children) do
          if setPaintDesignSlotRec(childNode) then

  for _, file in pairs(files) do
    local basename = string.sub(file, string.len(playerVehicle.vehicleDirectory) + 1, -1)

  if vdata.flexbodies then
    for _, flexbody in pairs(vdata.flexbodies) do
      if flexbody.mesh and flexbody.mesh ~= "" and flexbody.meshLoaded then

  if vdata.props then
    for _, prop in pairs(vdata.props) do
      if prop.mesh and prop.mesh ~= "" and prop.mesh ~= "SPOTLIGHT" and prop.mesh ~= "POINTLIGHT" then

    if node.children then
      for _, childNode in pairs(node.children) do
        highlightNode(childNode)

    if node.children then
      for _, childNode in pairs(node.children) do
        recHighlightNode(childNode, highlight)

for _,shape in pairs(shapes) do computeFaces(shape) end
M.getMeshes = getMeshes

M.clearLeagueUnlockCache = function()
  for _, league in pairs(leaguesById) do league._unlocked = nil end
  starsBySkillCache = {}

  local ret = {}
  for id, _ in pairs(leaguesById) do
    ret[id] = M.isLeagueUnlocked(id)

        local validSkills = {}
        for _, skill in pairs(career_branches.getBranches()) do
          if skill.parentBranch == condition.branchId then

  local ret = {}
  for id, l in pairs(leaguesById) do
    local league = formatLeague(l)

  local ret = {}
  for id, l in pairs(leaguesById) do
    if not before[id] and after[id] then

  local ret = {}
  for id, l in pairs(leaguesById) do
    if tableContains(l.missions, missionId) then

  local leaguesBySkill = {}
  for id, league in pairs(leaguesById) do
    if not leaguesBySkill[league.skillId] then

  -- Sort leagues within each skill group
  for skillId, skillLeagues in pairs(leaguesBySkill) do
    -- First sort by skill stars and file order

  local dirtyFilesById = {}
  for id, league in pairs(leaguesById) do
    local validMissionIds = {}

  end
  for mId, m in pairs(missionsById) do
    local lMap = {}

  for skillId, list in pairs(missionIdsBySkillWithoutLeague) do
    local fallbackLeagueId = "fallback_"..skillId

    log("W","","Some ("..tostring(dirty)..") missions were not set up properly for leagues.")
    for mId, count in pairs(dirtyFilesById) do
      log("W","","Mission " .. mId .. " was not set up properly for leagues " .. count .. " times.")

  loadLeagues()
  for _, spot in pairs(spotsById) do
    spot._isInLeague = nil

  end
  for id, league in pairs(leaguesById) do
    for _, dsId in ipairs(league.driftSpots) do

      -- for k,v in pairs(logFiltered) do
      --   lines_count = lines_count+1

          --   local tmp
          --   for k,v in pairs(logFiltered) do
          --     if type(v) == number and (i+logsHead+offset) >k and (i+logsHead+offset)<=v then tmp = true; print("brk");break; end

function C:work(args)
  for _, pin in pairs(self.pinOut) do
    if pin.type == "flow" then

  end
  for flag, act in pairs(self.flags) do
    self.pinOut[flag].value = act

  for id, v in pairs(self.pinIn.raceData.value.states) do
    if self.pinIn.vehId.value ~= id and map.objects[id] 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)

  --Walk through the groups until we find a valid object
  for i,v in pairs(spawnDefaultGroups) do
    if scenetree.findObject(spawnDefaultGroups[i]) then

local function updateGFX(dtSim)
  for sensorId, _ in pairs(idealRADARs) do
    updateIdealRADARsGFXStep(dtSim, sensorId, false, nil)

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

local function analyzeJBeamFile(filePath, fileName, jbeamFileData)
  for parts, partData in pairs(jbeamFileData) do
    for section, sectionData in pairs(partData) do

  for parts, partData in pairs(jbeamFileData) do
    for section, sectionData in pairs(partData) do
      --if section == 'beams' or section == 'nodes' or section == 'triangles' or section == 'flexbodies' or section == 'props' or section == 'torsionbars' then

          if mods then
            for modifier, _ in pairs(mods) do
              if not allSections[section][modifier] then

          if mods then
            for modifier, _ in pairs(mods) do
              if not allSections.beams[modifier] then

      im.BeginChild1("DynamicDecals_Notification_NotificationsChild", im.ImVec2(0, im.GetContentRegionAvail().y - (math.ceil(im.GetFontSize()) + 2*style.ItemSpacing.y)), true)
      for sectionName, sectionData in pairs(notifications) do

    local sorted = {}
    for key, layout in pairs(layouts) do
      if type(layout) == "table" and #layout > 0 then

  local reverseGears = {}
  for _, v in pairs(jbeamData.gearRatios) do
    table.insert(v >= 0 and forwardGears or reverseGears, v)

    if hooks then
        for id,f in pairs(hooks) do
            if f(...) then

            if (type(t)=="table") then
                for pos,val in pairs(t) do
                    if (type(val)=="table") then

  local blacklistLookup = {}
  for _, v in pairs(vehicleBlacklist) do
    blacklistLookup[v] = true

  local filteredConfigs = {}
  for k, v in pairs(configs) do
    if (not vehicleToTest or v.model_key == vehicleToTest) and ((not pcFileToTest or pcFileToTest == "") or v.key == pcFileToTest) and not blacklistLookup[v.model_key] then

  local progressCount = 1
  for _, v in pairs(filteredConfigs) do
    local vehName = v.model_key

  log("I", logTag, "Vehicles that are skipped:")
  for _, value in pairs(vehicleBlacklist) do
    log("I", logTag, value)

  -- Preload items: Populates the self.items table
  for id, item in pairs(self.racePathAiPath) do
    kdT:preLoad(id, item.x, item.y, item.z)

--   -- Preload items: Populates the self.items table
--   for id, item in pairs(self.pacenoteWaypoints) do
--     kdT:preLoad(id, item.x, item.y, item.z)

  for id, item in pairs(self.routeWaypointsIndex) do
    kdT:preLoad(id, item.pos.x, item.pos.y, item.pos.z)

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

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

  local targetPins = {}
  for _, link in pairs(self.graph.links) do
    if link.sourcePin == sourcePin then

    local foundName = false
    for _, node in pairs(self.graph.nodes) do
      for _, pin in pairs(node.pinList) do

    for _, node in pairs(self.graph.nodes) do
      for _, pin in pairs(node.pinList) do
        if pin.quickAccess and pin.accessName == name then

  sourcePin.accessName = name
  for _,pin in pairs(targetPins) do
    pin.quickAccess = true

  local result = {}
  for levelName, data in pairs(getStats().levels) do
    table.insert(result, { levelName = levelName, count = data.count, lastUsed = data.lastUsed })

  local result = {}
  for spawnPointName, data in pairs(getStats().levels[levelName] and getStats().levels[levelName].spawnPoints or {}) do
    table.insert(result, { spawnPointName = spawnPointName ~= "__default__" and spawnPointName or nil, count = data.count, lastUsed = data.lastUsed })

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

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

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

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

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

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

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

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

local function updateEnergyStorageRatios(device)
  for _, s in pairs(device.registeredEnergyStorages) do
    local storage = energyStorage.getStorage(s)

  local remainingFuelRatio = 0
  for _, s in pairs(device.registeredEnergyStorages) do
    local storage = energyStorage.getStorage(s)

  local nodeCids = {}
  for _, nodePair in pairs(exhaustNodeIDPairs) do
    table.insert(nodeCids, nodePair[2])

  local nodeCids = {}
  for _, nodePair in pairs(exhaustNodeIDPairs) do
    table.insert(nodeCids, nodePair[2])

      endNodeIDPairs = {}
      for _, v in pairs(endNodes) do
        maxExhaustAudioOpennessCoef = min(max(maxExhaustAudioOpennessCoef, v.exhaustAudioOpennessCoef), 1)

  bdebug.clearTypeNodeDebugText("CombustionEngine " .. device.name)
  for _, soundData in pairs(device.soundLocations) do
    for _, nodeCid in ipairs(soundData.nodes) do

          endNodeIDPairs = {}
          for _, v in pairs(device.thermals.exhaustEndNodes) do
            maxExhaustAudioOpennessCoef = min(max(maxExhaustAudioOpennessCoef, v.exhaustAudioOpennessCoef), 1)

          endNodeIDPairs = {}
          for _, v in pairs(exhaustEndNodes) do
            maxExhaustAudioOpennessCoef = min(max(maxExhaustAudioOpennessCoef, v.exhaustAudioOpennessCoef), 1)

    local hasValidReactioNodes = true
    for _, v in pairs(torqueReactionNodes_nodes) do
      if type(v) ~= "number" then

  local maxAvailableRPM = 0
  for _, v in pairs(baseTorqueTable) do
    maxAvailableRPM = max(maxAvailableRPM, v.rpm)

    local rawTorqueMultPoints = {}
    for _, v in pairs(multTorqueTable) do
      maxAvailableRPM = max(maxAvailableRPM, v.rpm)

    local rawIntakePoints = {}
    for _, v in pairs(intakeTorqueTable) do
      maxAvailableRPM = max(maxAvailableRPM, v.rpm)

    local rawExhaustPoints = {}
    for _, v in pairs(exhaustTorqueTable) do
      maxAvailableRPM = max(maxAvailableRPM, v.rpm)

    local rawPoints = {}
    for _, v in pairs(compressionBrakeTorqueTable) do
      maxAvailableRPM = max(maxAvailableRPM, v.rpm)

  tempBurnEfficiencyTable = {}
  for k, v in pairs(copy) do
    if type(k) == "number" then

  device.invBurnEfficiencyCoef = 1
  for k, v in pairs(tempBurnEfficiencyTable) do
    device.invBurnEfficiencyTable[k] = 1 / v

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

local function getLastElement(dragData)
  for vehId,_ in pairs(dragData.racers) do
    selectedVehicle = vehId

      for nameType, p in pairs(dragData.prefabs) do
        im.Text("Prefab: " .. nameType)

      end
      for vehId, _ in pairs(dragData.racers or {}) do
        if im.Selectable1(string.format("Racer ID: %d Lane: %d", vehId, dragData.racers[vehId].lane), vehId == selectedVehicle) then

          im.Text("(Click to dump, hover to preview)")
          for key, laneData in pairs(dragData.strip.lanes[dragData.racers[selectedVehicle].lane]) do
            if im.Button("Lanedata: " .. key) then

  for k, nativeLaneType in pairs(lNew) do
    profile[k] = {

  for k, filter in pairs(params.filters) do -- each inner table pair should have a coefficient: {Type = {car = 1, truck = 0.4}}
    local configValue = config[k] or 'default' -- unsure about this actually

      local filterKeyFound = false
      for k, v in pairs(configValue) do
        if type(filter[k]) == 'number' then -- filter value

  for _, model in pairs(core_vehicles.getModelList().models) do
    local officialModel = isOfficialSource(model)

      for _, config in pairs(core_vehicles.getModel(model.key).configs) do
        local officialConfig = isOfficialSource(config)

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

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

  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

  local colors
  for partPath, partCondition in pairs(partConditions) do
    if not colors then

    vehicle.config.paints = deepcopy(chosenPaints)
    for partPath, partCondition in pairs(vehicle.partConditions) do
      if partCondition.visualState and partCondition.visualState.paint.originalPaints then

  for _, g in pairs(beamGroups) do
    g.averagePressure = 0

  -- first, initialize the pressure and group count to 0
  for _, g in pairs(crossFlowGroups) do
    g.bufferPressure = 0

  -- now calculate the sum of all beam groups' pressures and the number of beam groups in each cross-flow group
  for _, g in pairs(beamGroups) do
    local crossFlowGroup = crossFlowGroups[g.crossFlowTag]

  -- finally, normalize the sum to an average using the beam group count, and calculate the stored energy
  for _, g in pairs(crossFlowGroups) do
    g.bufferPressure = g.beamGroupCount == 0 and 0 or g.bufferPressure / g.beamGroupCount

  -- now calculate the sum of all beam groups' pressures and the number of beam groups in each cross-flow group
  for _, bg in pairs(beamGroups) do
    if bg.crossFlowTag == crossFlowTag then

local function setBeamGroupsValveState(groupNames, valveState)
  for _, g in pairs(groupNames) do
    setBeamGroupValveState(g, valveState)

local function toggleBeamGroupsValveState(groupNames)
  for _, g in pairs(groupNames) do
    toggleBeamGroupValveState(g)

local function setBeamGroupsMaximumSupplyPressure(groupNames, maxSupplyPressure)
  for _, g in pairs(groupNames) do
    setBeamGroupMaximumSupplyPressure(g, maxSupplyPressure)

  for _, g in pairs(beamGroups) do
    local crossFlowGroup = crossFlowGroups[g.crossFlowTag]

    for _, v in pairs(g.beams) do
      local beamLength = max(obj:getBeamLength(v.cid) - v.lengthOffset, 0)

local function updateGFX(dt)
  for _, g in pairs(crossFlowGroups) do
    if g.enableDebug then

  for _, g in pairs(beamGroups) do
    if g.enableDebug then

    for _, v in pairs(g.beams) do
      if v.enableDebug then

local function reset()
  for _, g in pairs(beamGroups) do
    for _, v in pairs(g.beams) do

  for _, g in pairs(beamGroups) do
    for _, v in pairs(g.beams) do
      local beamLength = obj:getBeamLength(v.cid)

  local pressuredBeamNames = {}
  for _, v in pairs(pressureBeamData) do
    local name = v.beamName

  crossFlowGroups = {}
  for _, crossFlowData in pairs(crossFlowGroupData) do
    local groupTag = crossFlowData.crossFlowTag

  beamGroups = {}
  for _, pressureData in pairs(pressureBeamData) do
    local name = pressureData.beamName

  for _, v in pairs(pressureBeamSoundData) do
    local groupData = beamGroups[v.groupName]

local function resetSounds()
  for _, g in pairs(beamGroups) do
    if g.soundLoopIncrease then

  -- draw edges
  for nid, n in pairs(m.nodes) do
    for lid, dif in pairs(n.links) do

  for nid, n in pairs(m.nodes) do
    for lid, dif in pairs(n.links) do
      local p1 = transformPoint(n.pos - terrainPosition)

  local nodes = svg.Group()
  for nid, n in pairs(m.nodes) do
    local p = transformPoint(n.pos - terrainPosition)

  --for k,v in pairs(map.objects) do
  --  heatSVG:drawIcon(pos - terrainPosition, 'x', ColorI(255, 0, 0, 255))

  if heatSVG and terrainPosition then
    for mk, mv in pairs(map.objects) do
      -- {active = isactive, pos = pos, vel = vel, dirVec = dirVec, damage = damage}

  for _, child in ipairs(layer.children) do
    for _, property in pairs(properties) do

  if im.BeginPopup(string.format("%s_%s_AddPropertyPopup", layer.uid, guiId)) then
    for cat, properties in pairs(api.properties) do
      im.TextColored(editor.color.beamng.Value, cat)

  }
  for k,_ in pairs(self.partConfig.parts) do
    table.insert(keys.parts, k)

  end
  for k,_ in pairs(self.partConfig.vars) do
    table.insert(keys.vars, k)

  local cloudValues = {}
  for k, v in pairs(values) do
    if values[k] == M.impl.defaultValues[k] then -- TODO do a deep table compare instead

  if withValue then
    for k,o in pairs(options) do
      if type(o.get) == 'function' then

  end
  for k,o in pairs(options) do
    if type(o.getModes) == 'function' then

  for _, l in pairs(locales) do
    local key = string.match(l, 'locales/(.*).json')

  local sortedKeys = {}
  for k,_ in pairs(newState) do
    if not tableContains(graphicQualityGroups, k) then

 -- fix the options up and combine the keys and values into the dict
  for k,v in pairs(options) do
    if v.keys and v.values and not v.dict then

  -- add C++ propagation wherever possible
  for k,v in pairs(M.impl.defaults) do
    if CppSettings[k] ~= nil then -- check if C++ side cares about this setting

  local settingFileChanged = false
  for _,v in pairs(files) do
    if (v.filename == M.impl.pathLocal or v.filename == M.impl.pathCloud) and (os.clock()-lastSavedTime) > 5 then

function C:findExamples(match)
  for _, info in pairs(examplesLookup.lookup) do
    self.search:queryElement({

    local sortedExamples = {}
    for k, v in pairs(element.examples) do if k ~= folderName then table.insert(sortedExamples, k) end end

  local sortedKeys = {}
  for k, v in pairs(element) do if k ~= folderName then table.insert(sortedKeys, k) end end
  table.sort(sortedKeys, function(a,b)

    local anyRopeHasDebugNodes = false
    for _, settings in pairs(ropeDebugSettings) do
      if settings.debugNodes then

  for ropeId, _ in pairs(perfStats.ropeSimTimes) do
    if not activeRopeIds[ropeId] then

  else
    for _, settings in pairs(ropeDebugSettings) do
      if settings.debugNodes then

  local soundTable={}
  for k,v in pairs(soundFile) do
    soundTable[k]=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 listByKey = {}
  for key, active in pairs(self.activeTemplates) do
    if active then

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

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

  debugPacket.absControl.wheelData = debugPacket.absControl.wheelData or {}
  for k, v in pairs(absWheelData) do
    debugPacket.absControl.wheelData[k] = debugPacket.absControl.wheelData[k] or {}

local function registerWheelBrakeUpdates()
  for wheelName, _ in pairs(absWheelData) do
    wheels.setWheelBrakeUpdate(wheelName, updateBrakeNoABS, updateBrakeABS)

local function applyControlParameters()
  for k, v in pairs(controlParameters.tractionControl.wheelGroupSettings) do
    wheelGroupControlData[k].slipThreshold = v.slipThreshold

  if controlParameters.tractionControl.wheelBrakingPID then
    for k, v in pairs(controlParameters.tractionControl.wheelBrakingPID) do
      if wheelControlData[k].tractionControlBrakingPID then

  for k, v in pairs(controlParameters.absControl.wheelSettings) do
    absWheelData[k].slipThreshold = v.slipThreshold

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

    for _, wheel in pairs(CMU.vehicleData.wheelAccess) do
      if not wheelControlData[wheel.name] then

    local wheelSettings = tableFromHeaderTable(jbeamData.absControl.wheelSettings or {})
    for _, wheelSetting in pairs(wheelSettings) do
      if absControl.absControlledWheels[wheelSetting.wheelName] then

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

  --ABS Control
  for k, _ in pairs(absWheelData) do
    CMU.applyParameter(controlParameters, initialControlParameters, parameters, "absControl.wheelSettings." .. k .. ".kP")

  end
  for k, _ in pairs(self.tags) do
    table.insert(self.sortedTags, k)

  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

    if im.BeginCombo("Selector",tostring(self.currentID)) then
      for id, rec in pairs(editor_scriptAIManager.getCurrentRecordings()) do
        if im.Selectable1(tostring(id), tostring(id) == self.currentID) then

  local dedup = {}
  for i, beam in pairs(vehicle.beams) do
    if beam.breakGroup == '' then beam.breakGroup = nil end

  local cids = {}
  for _, rail in pairs(vehicle.rails) do
    if rail["links:"] ~= nil then

      if rail["broken:"] ~= nil then
        for _, nid in pairs(rail["broken:"]) do
          brokenmap[nid] = 1

  if vehicle.slidenodes == nil then return end
  for _, snode in pairs(vehicle.slidenodes) do
    local attached = 1

  local tbi = tableEndC(vehicle.torsionbars)
  for i, hydro in pairs(vehicle.torsionHydros) do
    vehicle.torsionbars[tbi] = hydro; tbi = tbi + 1

  if vehicle.torsionbars == nil then return end
  for _, tb in pairs(vehicle.torsionbars) do
    local spring = tb.spring

  local n = vehicle.nodes
  for _, triangle in pairs(vehicle.triangles) do
    if triangle.breakGroup == '' then triangle.breakGroup = nil end

  if campaign.meta and campaign.meta.subsections then
    for _, subsection in pairs(campaign.meta.subsections) do
      if subsection.locations then

      if subsection.locations then
        for _ in pairs(subsection.locations) do
          scenarioCount = scenarioCount + 1

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

  end
  for key, poisInCluster in pairs(poisByObjectNames) do
    local wm = poisInCluster[1].markerInfo.walkingMarker

    for _,spawnPoint in pairs(levelInfo.spawnPoints) do
      if not M.isSpawnPointDiscovered(currentLevel, spawnPoint.objectname) then

  local files = FS:findFiles(folderPath, '*.json', 0, false, false)
  for _, filePath in pairs(files) do
    local leaderboardFileData = jsonReadFile(filePath)

  log("I", logTag, "Saving leaderboards to " .. folderPath)
  for levelName, levelLeaderboards in pairs(leaderboards) do
    if dirtyLevels[levelName] or forceOverwrite then

  self.pinOut.closed.value = false
  for flag, act in pairs(self.flags) do
    self.pinOut[flag].value = act

  local t1Len = 0
  for k, v in pairs(t1) do
    t1Len = t1Len + 1

  local t2Len = 0
  for k in pairs(t2) do
    t2Len = t2Len + 1

   local mt = getmetatable(conn.sock).__index
   for name, method in pairs(mt) do
      if type(method) == "function" then

   -- Default settings
   for k, v in pairs(cfg) do 
      params[k] = params[k] or v

    }
    for k, v in pairs(electrics.values.wheelThermals) do
      table.insert(header, 'BrakeCoreTemp' .. k)

    end
    for k, v in pairs(powertrain.getDevicesByType('combustionEngine')) do
      if v.thermals ~= nil then

    }
    for k, v in pairs(electrics.values.wheelThermals) do
      table.insert(dataRow, v.brakeCoreTemperature or 0)

    end
    for k, v in pairs(powertrain.getDevicesByType('combustionEngine')) do
      table.insert(dataRow, v.thermals.engineBlockTemperature)

    buf:put('{')
    for k, v in pairs(states) do
      buf:putf('[%q]=%s,', k, v)

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

          end
          for name, list in pairs(spotsByName) do
            if #list > 1 then

    local emptyLevelNamesSorted = {}
    for level, sites in pairs(levelSites) do
      if #sites > 0 then

  end
  for key, poisInCluster in pairs(poisByObjectNames) do
    local cm = poisInCluster[1].markerInfo.crawlMarker

  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

  --include all math functions and constants
  for k, v in pairs(math) do
    customElectricsEnv[k] = v

  keyworkdWhiteListLookup = {}
  for _, v in pairs(keywordWhiteList) do
    keyworkdWhiteListLookup[v] = true

  --TODO invesitgate if we maybe only want to update the values that are actually used within the custom value functions
  for electricsName, electricsValue in pairs(electrics.values) do
    customElectricsEnv.electrics[electricsName] = electricsValue

local function updateElectrics(dt)
  for electricsName, customValue in pairs(customElectricsEnv.electrics) do
    electrics.values[electricsName] = customValue

  --dump(customDefaultValues)
  for electricsName, value in pairs(customDefaultValues) do
    electrics.values[electricsName] = value

    -- 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 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 count = 0
  for _ in pairs(ignoredObjects) do
    count = count + 1

  local sortedFields = {}
  for field, _ in pairs(data) do
    table.insert(sortedFields, field)

  -- Check which sceneObjectNodes are planted
  for i, node in pairs(sceneObjectNodes) do
    if node.planted then

  for i, node in pairs(forestItemNodes) do
    if node.planted then

  for id, node in pairs(sceneObjectNodes) do
    if not node.planted then

  job.yield()
  for _, node in pairs(forestItemNodes) do
    if not node.planted then

        local foundDuplicate = false
        for id2, hash2 in pairs(objectHashes) do
          if hash == hash2 then

        local filterFunctions = {}
        for logLevel, _ in pairs(logLevelFilters) do
          table.insert(filterFunctions, filterLogLevel(logLevel))

  }
  for type, idx in pairs(types) do
    aggregatedElements.elementsByType[idx] = { elements = {}, count = 0, type = type }

  if im.BeginCombo("File##file" , self.fnShort) then
    for _, fileName in pairs(self.files) do
      local fnShort = string.sub(fileName, string.len(trackFilePath) + 1)

  local meshRoadsInSelection = {}
  for _, v in pairs(editor.selection.object) do
    local sel = scenetree.findObjectById(v)

  for _, pathNode in pairs(self.pinIn.pathData.value.pathnodes.sorted) do
    table.insert(self.extractedWaypoints, pathNode.pos)

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

  local res = {}
  for _, l in pairs(locales) do
    local key = string.match(l, 'locales/(.*).json')

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

  for k,info in pairs(mergedInfo) do
    local entry = {}

  local materialsClean = {}
  for i, m in pairs(materials) do
    table.insert(materialsClean, m.name) -- {m.colorR, m.colorG, m.colorB}

      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 counts = {}
  for name, pin in pairs(self.pinInLocal) do
    if self.pinIn[name].value ~= nil and pin.type == 'number' then

    local h = "\r\n"
    for f, v in base.pairs(tosend) do
        h = (canonic[f] or f) .. ": " .. v .. "\r\n" .. h

    -- override with user headers
    for i,v in base.pairs(reqt.headers or lower) do
        lower[string.lower(i)] = v

    -- explicit components override url
    for i,v in base.pairs(reqt) do nreqt[i] = v end
    if nreqt.port == "" then nreqt.port = 80 end

  for k, v in pairs(newData) do
    --print(k .. ": " .. v)

  --dump(data)
  for _, v in pairs(whiteList) do
    data[v] = nil

    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 rpm, torque in pairs(torqueCurve) do
      if torque > maxTorque then

    end
    for rpm, power in pairs(powerCurve) do
      if power > maxPower then

  local motors = powertrain.getDevicesByCategory("engine")
  for _, v in pairs(motors) do
    if v.type == "combustionEngine" then

  local engines = powertrain.getDevicesByType("combustionEngine")
  for _, v in pairs(engines) do
    if v.turbocharger.isExisting then

  local energyStorages = energyStorage.getStorages()
  for _, v in pairs(energyStorages) do
    if v.type == "fuelTank" then

  local transmissions = powertrain.getDevicesByCategory("gearbox")
  for _, v in pairs(transmissions) do
    if v.type == "automaticGearbox" then

  end
  -- for _, wd in pairs(adjustedWheels) do
  --   print(wd.name)

  local avgWheelPos = vec3(0, 0, 0)
  for _, wd in pairs(adjustedWheels) do
    wheelCount = wheelCount + 1

    local propulsedWheelLocations = {fr = 0, fl = 0, rr = 0, rl = 0}
    for _, wd in pairs(adjustedWheels) do
      if wd.isPropulsed then

      local centerDiff
      for _, v in pairs(orderedDevices) do
        if centerDiff then

        end
        for _, w in pairs(actualDiffs) do
          if w.name == v.name then

  for _, diff in pairs(powertrain.getDevicesByType("differential")) do
    if diff.mode ~= "locked" then

  for _, shaft in pairs(powertrain.getDevicesByType("shaft")) do
    if shaft.mode ~= "connected" then

  for _, rangebox in pairs(powertrain.getDevicesByType("rangeBox")) do
    if rangebox.mode ~= "high" then

  for _, diff in pairs(powertrain.getDevicesByType("differential")) do
    if diff.mode ~= "locked" then

  for _, shaft in pairs(powertrain.getDevicesByType("shaft")) do
    if shaft.mode ~= "connected" then

  for _, rangebox in pairs(powertrain.getDevicesByType("rangeBox")) do
    if rangebox.mode ~= "high" then

  for _, diff in pairs(powertrain.getDevicesByType("differential")) do
    if diff.mode ~= "locked" then

  for _, shaft in pairs(powertrain.getDevicesByType("shaft")) do
    if shaft.mode ~= "connected" then

  for _, rangebox in pairs(powertrain.getDevicesByType("rangeBox")) do
    if rangebox.mode ~= "low" then

  end
  for _, pref in pairs(prefs) do
    -- we only have a single pair in the table, the table is used to keep the item order like it was written in the code

  -- check the current preferences.json items if they still exist in the registry
  for catName, cat in pairs(self.preferences) do
    if type(cat) ~= "table" then

    else
      for subcatName, subcat in pairs(cat) do
        if type(subcat) ~= "table" then

        else
          for itemName, item in pairs(subcat) do
            local itemPath = catName .. "." .. subcatName .. "." .. itemName

    if json[categoryName] then
      for subCatName, subCat in pairs(json[categoryName]) do
        for itemName, itemValue in pairs(subCat) do

      for subCatName, subCat in pairs(json[categoryName]) do
        for itemName, itemValue in pairs(subCat) do
          local path = categoryName .. "." .. subCatName .. "." .. itemName

  local val = nil
  for subcatName, subcat in pairs(self.preferences[categoryName]) do
    for itemName, item in pairs(subcat) do

  for subcatName, subcat in pairs(self.preferences[categoryName]) do
    for itemName, item in pairs(subcat) do
      local itemPath = categoryName .. "." .. subcatName .. "." .. itemName

  -- prune prefs that have default values, no need to be in the file
  for catName, cat in pairs(self.preferences) do
    for subcatName, subcat in pairs(cat) do

  for catName, cat in pairs(self.preferences) do
    for subcatName, subcat in pairs(cat) do
      for itemName, _ in pairs(subcat) do

    for subcatName, subcat in pairs(cat) do
      for itemName, _ in pairs(subcat) do
        local itemPath = catName .. "." .. subcatName .. "." .. itemName

    if not cat then return false end
    for _, subCat in pairs(cat.subcategories) do
      for _, item in pairs(subCat.items) do

    for _, subCat in pairs(cat.subcategories) do
      for _, item in pairs(subCat.items) do
        self:set(item.path, deepcopy(item.defaultValue))

      couplerNodePairData.availableCid2 = {}
      for _, cid2 in pairs(cnp.cid2) do
        table.insert(couplerNodePairData.availableCid2, beamstate.nodeNameMap[cid2])

    for _, nodeID in pairs(vertLocNodes) do
      if nodeID ~= -1 then

    -- Go through each vertex's locator nodes to render lines
    for _, nodeID in pairs(vertLocNodes) do
      if nodeID ~= -1 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)

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

  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 arrayidx, prefix = 1, "{"
      for kk, vv in pairs(v) do
        if kk == arrayidx then

      buf:put('\0'):put(char(min(#v, 250)))
      for kk, vv in pairs(v) do
        if kk == arrayidx then

        for kk, vv in pairs(v) do
          if kk == arrayidx then

        for kk, vv in pairs(v) do
          dictlen = dictlen + 1

		local alib = {}
		for _,p in pairs(apth) do
			unrequire(p)

	if U.out.agraph then
		for _,g in pairs(U.out.agraph) do
			Render.graph(g.list, g.c, g.w)

	end
	for _,s in pairs(U.out.aset) do
--			lo('?? U_draw_set:')

	end
	for _,o in pairs(U.out.atext) do
		Render.label(o.list, o.c)

		else
			for o,e in pairs(t) do
	--            lo(type(o)..':'..type(e)..':'..o..':'..tostring(e))

		if not lvlma or lvl < lvlma then
			for o,e in pairs(t) do
	--            lo(type(o)..':'..type(e)..':'..o..':'..tostring(e))

	if not list then return end
	for _,p in pairs(list) do
		local r = rma * math.sqrt((p - core_camera.getPosition()):length())

	local out = {}
	for _,v in pairs(list) do
		out[#out + 1] = v + plus

	local s = ''
	for _,step in pairs(path) do
		s = s..step..'/'

	local s = ''
	for _,v in pairs(arr) do
		s = s..tostring(v)..delim

	if not list then return apos end
	for i,_ in pairs(list) do
--    for i = 1,#list do

	local isprop = type(cb) == 'string'
	for k,v in pairs(list) do
		ret[#ret+1] = isprop and v[cb] or cb(k,v)

	local tnew = {}
	for k,v in pairs(arr) do
		tnew[k] = v

	if not b then return a end
	for j,q in pairs(b) do
		if #index(a, q) == 0 then

	local c = vec3(0,0,0)
	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)

		if type(ai) == 'table' then
			for o,i in pairs(ai) do
				ai[o] = (i - 1) % n + 1

	local mi = math.huge
	for i,p in pairs(aplane) do
		local d = intersectsRay_Plane(line[1], line[2]-line[1], p[1], (p[2]-p[1]):cross(p[3]-p[1]))

  sence = sence or 0
  for _,p in pairs(list) do
    if (a-p):cross(b-p):length() > sence then

  local L,d = (a-b):length()
  for _,p in pairs(list) do
	d = math.abs((p-a):length()+(p-b):length()-L)

	local dmi,imi = math.huge
	for i,v in pairs(base) do
		local d = p:distance(v)

	local pleft,pright
	for i,p in pairs(ahit) do
		local dp = p[2]-a

	local mi,ma = vec3(math.huge,math.huge,math.huge),-vec3(math.huge,math.huge,math.huge)
	for i,v in pairs(set) do
		if v.x < mi.x then

	local imap12 = {}
	for k,v in pairs(map) do
		imap12[#imap12+1] = imap[v]

	local imap21 = {}
	for k,v in pairs(map) do
		imap21[#imap21+1] = imap[v]

	-- initial objects linking
	for i,loop in pairs(aeref) do
--            nvert = nvert + #loop

			local c,d
			for i,e in pairs(ae) do
--                isend = false

					lo('??______________________________________ is_3_5:')
					for i,_ in pairs(estamp) do
						lo('?? if_STAMP:'..i..':'.._)

		local ama,ima = -math.huge
		for _,iv in pairs(astar) do
			local u = (v4e[iv[1].ind].p - v4e[n2].p):normalized()

		local rc = {}
		for i,list in pairs(e4v) do
				lo('?? for_edge:'..i)

				local pth = {}
				for _,p in pairs(rc) do
					pth[#pth+1] = v4e[p].p

--[[
		for _,rc in pairs(arc) do
			local pth = {}

			local pth = {}
			for _,p in pairs(rc) do
				pth[#pth+1] = v4e[p].p

	local morig,mscale = mrc[1],mrc[2] --{0,0},{1,1}
	for _,n in pairs(v4e) do
		av[#av+1] = n.p

	local e4v,v4e = {},{}
	for i,pth in pairs(aeref) do
		for j=2,#pth do

	local iep = 0
	for i,loop in pairs(aloop) do
		for j,p in pairs(loop) do

	for i,loop in pairs(aloop) do
		for j,p in pairs(loop) do
			iep = iep + 1

			local ie = 0
			for ir,pth in pairs(aeref) do
--                cmi = nil

	end
	for i,pth in pairs(aeref) do
--            dump(pth, '?? for_pth:'..i..'/'..#aloop)

	local dmi,imi,cmi = math.huge
	for i,e in pairs(ae) do
	--            lo('?? for_edge:'..i..':'..tostring(e[1])..':'..tostring(e[2]))

	local ae = {}
	for i,loop in pairs(aloop) do
		for j = 1,#loop-1 do

	for i,loop in pairs(aloop) do
			dump(loop, '?? for_loop:'..i..'/'..#loop)

			dump(loop, '?? for_loop:'..i..'/'..#loop)
		for j,p in pairs(loop) do
--                lo('?? for_p:'..j..':'..tostring(p))

	for i = fr,to,-dir do
--    for i,e in pairs(ae) do
		if (ae[i][1][axis] - p[axis])*dir <= 0 then

	local aex,aey = {},{} --clone(ahole)
	for i,h in pairs(ahole) do
--        aex[#aex+1] = {h[1],{h[1].x,h[2].y},i,1}

	for i,e in pairs(aex) do
			U.dump(e, '??======================== for_E_VERT:'..i)

	local aflag = {}
	for _,c in pairs(astem) do
		local lst = ard[c[1]].list

	local av = {}
	for _,p in pairs(apos) do
		local pproj = U.proj2D(p)

	for i=1,#list do
--    for i,rc in pairs(list) do
		local rc = prop == nil and list[i] or list[i][prop]

  if vehicleObj and vehicle.triangles then
    for _, triangle in pairs(vehicle.triangles) do
      -- skip denormalized tris

    local prop_count = 0
    for propKey, prop in pairs(vehicle.props) do
      if disableSteeringProp and prop.func == 'steering' then

  if vehicle.flexbodies ~= nil and vehicleObj then
    for flexKey, flexbody in pairs(vehicle.flexbodies) do
      local flexnodeCount = #flexbody['_group_nodes']

    profilerPushEvent('flexmesh_rotate')
    for _, v in pairs(vehicle.flexbodies) do
      local x, y, z, rx, ry, rz = jbeamUtils.getFlexbodyPosRotAfterNodeRotateOffsetMove(v, v.pos and v.pos.x or 0, v.pos and v.pos.y or 0, v.pos and v.pos.z or 0, v.rot and v.rot.x or 0, v.rot and v.rot.y or 0, v.rot and v.rot.z or 0)

    if vehicle.props ~= nil then
      for _, prop in pairs(vehicle.props) do
        if prop.mesh ~= "SPOTLIGHT" and prop.mesh ~= "POINTLIGHT" then

    if vehicle.flexbodies ~= nil then
      for _, flexbody in pairs(vehicle.flexbodies) do
        vehicleObj:requestMesh(flexbody.mesh)

  local nodes = navGraph.nodes
  for _, v in pairs(nodes) do
    if hoverNode and v == hoverNode then

    local passed = true
    for key, fun in pairs(filterFunctions) do
      passed = passed and ( filterFunctions[key](mission, filter[key]))

  table.sort(result.sortedKeys)
  for key, list in pairs(result.missions) do
    table.sort(list, idSort)

    else
      for key, list in pairs(mission.careerSetup.starRewards) do
        local newRewards = {}

  -- if the value didn't exist in the preferences, use the default bool by skipping the item
  for k, v in pairs(_showWindows) do
    if v ~= nil 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
    if tableContains(self.oldOptions, pn.name) then

  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

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

  -- Try to match the category as a lua pattern
  for category, _ in pairs(missionData.elements) do
    if string.match(category, args.category) then

  local newOrder = {}
  for category, element in pairs(missionData.elements) do
    table.insert(newOrder, {

  im.Indent()
  for k, v in pairs(section.children) do
    checkSection(v, string.format("%s/%s", id, k))

  local status = {}
  for tag, info in pairs(vehicleTags) do
    status[tag] = isVehicleTagUnlocked(tag)

    local tagsByTier = {}
    for key, info in pairs(vehicleTags) do
      local tier = 1

    end
    for tier, list in pairs(tagsByTier) do
      table.sort(list)

    local tagsByTier = {}
    for key, info in pairs(vehicleTags) do
      local tier = 1

    end
    for tier, list in pairs(tagsByTier) do
      table.sort(list)

  local same = true
  for k, v in pairs(a) do
    same = same and a[k] == b[k]

  key = string.lower(key)
  for pattern, annotation in pairs(tab) do
    pattern = string.lower(pattern)

  local pcfiles = FS:findFiles("/vehicles/" .. vehicleName .. "/", "*.pc", 0, true, false)
  for _, fn in pairs(pcfiles) do
    local dir, filename, ext = path.split(fn)

local function _fillAggregates(data, destination)
  for key, value in pairs(data) do
    if tableContains(range, key) then

      if type(value) == 'table' then
        for value, active in pairs(value or {}) do
          if active then

local function _mergeAggregates(data, destination)
  for key, value in pairs(data) do
    if tableContains(range, key) or tableContains(convertToRange, key) then

      end
      for value, active in pairs(value or {}) do
        if active then

      else
        for key2, _ in pairs(value) do
          destination[key][key2] = true

local shouldBeDict = { "Region" }
for key, _ in pairs(displayInfo.units) do table.insert(shouldBeNumber, key) end
for key, _ in pairs(displayInfo.predefinedUnits) do table.insert(shouldBeNumber, key) end

for key, _ in pairs(displayInfo.units) do table.insert(shouldBeNumber, key) end
for key, _ in pairs(displayInfo.predefinedUnits) do table.insert(shouldBeNumber, key) end
local shouldBeStringLookup = tableValuesAsLookupDict(shouldBeString)

  local newData = deepcopy(data)
  for key, value in pairs(data) do
    if shouldBeStringLookup[key] and type(value) ~= "string" then

        newData[key] = tableValuesAsLookupDict(newData[key])
        for k, v in pairs(newData[key]) do
          newData[key][k] = true

        if fileData then
          for partName, part in pairs(fileData) do
            if part.slotType == 'main' then

  local paints = {}
  for name, data in pairs(info.colors or {}) do
    if type(data) == 'string' then

  for configFilename, configName in pairs(vehFiles.configs) do
    local contentSource = getSourceAttr(configFilename)

      local validatedPaints = {}
      for name, data in pairs(readData.paints or {}) do
        if type(data) ~= 'table' then

    local validatedPaints = {}
    for name, data in pairs(data.paints or {}) do
      if type(data) ~= 'table' then

    missingInfoConfigs = data.configs
    for mConfigName, mConfig in pairs(missingInfoConfigs) do
      mConfig.is_default_config = false

  local aggHelper = {}
  for _, config in pairs(cache[key].configs) do
    _mergeAggregates(config.aggregates, aggHelper)

  if list then
    for _, value in pairs(list) do
      for propName, propVal in pairs(value.aggregates) do

    for _, value in pairs(list) do
      for propName, propVal in pairs(value.aggregates) do
        if tableContains(finalRanges, propName) then

          end
          for key,_ in pairs(propVal) do
            if type(key) == 'table' then

            if type(key) == 'table' then
              for _, key2 in pairs(key) do
                filter[propName][key2 .. ''] = true

  local models = {}
  for modelName, _ in pairs(getModelsData()) do
    local model = getModel(modelName)

  local configList = {}
  for modelName, _ in pairs(getModelsData()) do
    local model = getModel(modelName)

    if model.configs and not tableIsEmpty(model.configs) then
      for _, config in pairs(model.configs) do
        if array then

  if not model.configs then return end
  for _, config in pairs(model.configs) do
    if configKey == config.key then

  local modelList, configList = {}, {}
  for modelName, _ in pairs(getModelsData()) do
    if p then p:add("model begin") end

    if p then p:add("model insert") end
    for _, config in pairs(model.configs or {}) do
      table.insert(configList, config)

    configList = {}
    for id, vehicle in pairs(vehicles) do
      -- configList

  local vehicles = {}
  for i,m in pairs(models) do
    local vehicle = getModel(m.key)

    for childVehId, initChildVehData in pairs(initVehData.children or {}) do
      buildInitVehCollectionCacheRec(initVehData, initChildVehData, vehData, vehData.children[childVehId])

    for childVehId, childVehData in pairs(vehData.children or {}) do
      buildVehCollectionCacheRec(vehData, childVehData)

local function removeVehicleCollection(collection)
  for vehId, vehData in pairs(collection.vehsData) do
    M.vehIdToVehCollection[vehId] = nil

  collection.vehsData[vehData.vehId] = vehData
  for childVehId, childVehData in pairs(vehData.children or {}) do
    addVehicleToNewCollectionRec(collection, childVehData)

  -- Add the remaining vehicles to new collections
  for childVehId, childVehData in pairs(vehData.children or {}) do
    local newCollection = initVehicleCollection()

    M.vehIdToVehCollection[vehId] = nil
    for childVehId, childVehData in pairs(vehData.children or {}) do
      removeVehicleFromCollectionRec(collection, childVehData)

    for childVehId, childVehData in pairs(vehData.children or {}) do
      local childVeh = getObjectByID(childVehId)

local function getNodeByCid(vehicleData, nodeCid)
  for nodeId, node in pairs(vehicleData.vdata.nodes) do
    if node.cid == nodeCid then

  if not vdata or not vdata.nodes then return end
  for nodeId, node in pairs(vdata.nodes) do
    if node.name == nodeName then

  local couplerOffset = {}
  for _, c in pairs(couplerCache) do
    if c.couplerTag == couplerTag or c.tag == couplerTag or couplerTag == "" or not couplerTag then

    -- get all vehicles to reuse from the other vehicle collection
    for vehId, _ in pairs(otherVehCollection.vehsData) do
      table.insert(state.vehsToReuse, vehId)

--       -- Remove the vehicles from the other collections
--       for otherMainVehId, otherCollection in pairs(M.vehCollections) do
--         for vehId, vehData in pairs(collection.vehsData) do

--       for otherMainVehId, otherCollection in pairs(M.vehCollections) do
--         for vehId, vehData in pairs(collection.vehsData) do
--           if otherCollection.vehsData[vehId] then

--   for mainVehId, vehCollection in pairs(M.vehCollections) do
--     buildVehCollectionCache(vehCollection)

    for k,fn in pairs(designData.gen.patternData) do
      if type(fn) == "table" then

    end
    for _,curFormat in pairs(formats) do
      designData={}; designData.data=design.data.format[curFormat]

  for _, n in pairs(vdata.nodes) do
    if n.couplerTag or n.tag then

    local players = M.vehiclePlayersMap[vid]
    for player, _ in pairs(players) do
      M.playerVehicleMap[player] = nil

    -- Place the children vehicles relative to us
    for childVehId, childVehData in pairs(vehData.children or {}) do
      local childVeh = getObjectByID(childVehId)

  --     local parentVehData = parentCollection.vehsData[parentVehicleId]
  --     for vehId, vehData in pairs(parentVehData.children or {}) do
  --       if vehData.offsetData and vehData.offsetData.type == "coupledNodes" then

--   for childVehId, childVehData in pairs(vehData.children or {}) do
--     if childVehData.offsetData and childVehData.offsetData.type == "coupledNodes" then

  -- Don't serialize the vehsData list in the vehicle collections
  for mainVehId, initVehCollection in pairs(M.initVehCollections) do
    for vehId, vehData in pairs(initVehCollection.vehsData) do

  for mainVehId, initVehCollection in pairs(M.initVehCollections) do
    for vehId, vehData in pairs(initVehCollection.vehsData) do
      vehData.parent = nil

  end
  for mainVehId, collection in pairs(M.vehCollections) do
    for vehId, vehData in pairs(collection.vehsData) do

  for mainVehId, collection in pairs(M.vehCollections) do
    for vehId, vehData in pairs(collection.vehsData) do
      vehData.parent = nil

  for mainVehId, initVehCollection in pairs(M.initVehCollections) do
    buildVehCollectionCache(initVehCollection)

  end
  for mainVehId, collection in pairs(M.vehCollections) do
    buildVehCollectionCache(collection)

--     im.Text('  -' .. vehData.vehId)
--     for childVehId, childVehData in pairs(vehData.children or {}) do
--       drawVehicleCollectionRec(childVehData)

--   if im.Begin("Vehicle Collections Debug") then
--     for mainVehId, collection in pairs(M.vehCollections) do
--       im.Text('Main Veh ID: ' .. mainVehId)

  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"

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

  local matFiles = FS:findFiles( path, 'materials.cs', -1, true, false)
  for k,v in pairs(matFiles) do
    TorqueScriptLua.exec(v)

  local matFiles = FS:findFiles( path, '*materials.json', -1, true, false)
  for k,v in pairs(matFiles) do
    loadJsonMaterialsFile(v)

  log('I', 'work', 'Will process .dae meshes in following dirs: ')
  for k,v in pairs(compilePaths) do
	log('I', 'work', v )

  -- we need to load the separate folders isolated, as the names of materials and objects will clash otherwise
  for _, baseDir in pairs(compilePaths) do
    local dirs = getDirectories(baseDir)

    for _, dir in pairs(dirs) do
      local inited = false

  else
    for i, f in pairs(allFilesCheckOnly) do
      if not compiledFiles[f] and not isPathIgnored(f) then

        local msg = msgBuffer[i]
        for _, callback in pairs(linMessageCallbacks) do
          callback(msg)

  M.errorCodeLookup = {}
  for key, value in pairs(M.errorCodes) do
    M.errorCodeLookup[value] = key

  local clrSelected = ColorF(0.91, 0.49, 0.24, 0.75)
  for idx, obj in pairs(objects) do
    local distNodeToCam = (obj.pos - mouseInfo.camPos):length()

local function draggingUndo(actionData)
  for idx, pos in pairs(actionData.oldPos) do
    actionData.self.current.vertices[idx].pos = pos

local function draggingRedo(actionData)
  for idx, pos in pairs(actionData.newPos) do
    actionData.self.current.vertices[idx].pos = pos

  local minDistance = math.huge
  for _, obj in pairs(objects) do
    if obj.vertices then

  for k,filename in pairs(roadTemplateFiles) do
    local jsonData = jsonReadFile(filename)

  local allRoadsCopy = shallowcopy(editor.getAllRoads())
  for roadID, _ in pairs(allRoadsCopy) do
    local road = scenetree.findObjectById(roadID)

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

  local context = {}
  for key, value in pairs(data) do
    if type(value) == 'string' or type(value) == 'number' 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

local function findPropIdByName(vehicle, propName)
  for _, prop in pairs(vehicle.props) do
    if prop.name == propName then

    -- After tableSchema processing, ropes is now a dictionary/object
    for ropeName, ropeConfig in pairs(vehicle.vropes) do
      --dump({"ropeName", ropeName, "ropeConfig", ropeConfig})

  if decalsBySpline then
    for material, v in pairs(decalsBySpline) do
      local numDecalsByShape = #v

  -- Now check if any templates are no longer needed, and remove them.
  for material, numInstances in pairs(instanceCounters) do
    if numInstances < 1 then

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

  else
    for _, graph in pairs(self.graphs) do
      if graph.nodes[i] then

    if not occupied then
      for _, macro in pairs(self.macros) do
        if macro.nodes[i] then

    else
      for _, graph in pairs(self.graphs) do
        if graph.nodes[i] then

      if not occupied then
        for _, macro in pairs(self.macros) do
          if macro.nodes[i] then

  local max = 0
  for grId, graph in pairs(self.graphs) do
    max = math.max(max, grId)

    max = math.max(max, grId)
    for nId, node in pairs(graph.nodes) do
      max = math.max(max, nId)

  end
  for mId, macro in pairs(self.macros) do
    max = math.max(max, mId)

    max = math.max(max, mId)
    for nId, node in pairs(macro.nodes) do
      max = math.max(max, nId)

    local occupied = false
    for _, graph in pairs(self.graphs or {}) do
      if graph.pins[i] or graph.links[i] then

    end
    for _, graph in pairs(self.macros or {}) do
      if graph.pins[i] or graph.links[i] then

  self.moduleOrder = {}
  for k, _ in pairs(self.modules) do
    table.insert(self.moduleOrder, k)

  if self.graph then
    for _, node in pairs(self.graph.nodes) do
      node._isSelected = nil

    end
    for _, link in pairs(self.graph.links) do
      link._isSelected = nil

  -- find all links that are connected to this node.
  for lid, link in pairs(graph.links) do
    if link.sourceNode.id == node.id then

  local pins = {}
  for _, pin in pairs(node.pinList) do
    table.insert(pins, pin)

  -- remove all links and pins.
  for _, link in pairs(inLinks) do
    graph:deleteLink(link)

  end
  for _, link in pairs(outLinks) do
    graph:deleteLink(link)

  end
  for _, pin in pairs(pins) do
    node:removePin(pin)

  local inPins, outPins = node:gatherPins()
  for name, vals in pairs(hardCoded) do
    if node.pinInLocal[name] ~= nil then

  end
  for name, _ in pairs(hidden.p_in) do
    if node.pinInLocal[name] ~= nil then

  end
  for name, _ in pairs(hidden.p_out) do
    if node.pinOut[name] ~= nil then

  if #inLinks > 0 then
    for _, link in pairs(inLinks) do
      local newPin = nil

  if #outLinks > 0 then
    for _, link in pairs(outLinks) do
      local newPin = nil

  if graph:getParent() then
    for _, n in pairs(graph:getParent().nodes) do
      if n.nodeType == 'macro/integrated' then

  --print("Update Subgraphs is called.")
  for id, node in pairs(graph.nodes) do
    if (node.nodeType == "macro/integrated") then

    local graphIds = {}
    for id, graph in pairs(self.graphs) do
      table.insert(graphIds, graph.id)

  ui_flowgraph_editor.SetCurrentEditor(self.fgEditor.ectx)
  for id, graph in pairs(self.graphs) do
    if graph.type == "instance" then

  --[[local oldGraph
  for id,graph in pairs(self.macros) do
    if graph.macroPath == savedata.filepath then

    local graphIds = {}
    for id, graph in pairs(self.graphs) do
      table.insert(graphIds, graph.id)

  --ui_flowgraph_editor.SetCurrentEditor(self.fgEditor.ectx)
  for id, macro in pairs(self.macros) do
    if macro.macroPath == path then

  local contained = false
  for _, gr in pairs(self.graphs) do
    contained = contained or gr == graph

  end
  for _, gr in pairs(self.macros) do
    contained = contained or gr == graph

    local iNode = nil
    for nId, node in pairs(graph:getParent().nodes) do
      if node:representsGraph() and node:representsGraph().id == graph.id then

    -- check all graphs, there is probably be one in the state graphs.
    for _, g in pairs(self.graphs) do
      for nId, node in pairs(g.nodes) do

    for _, g in pairs(self.graphs) do
      for nId, node in pairs(g.nodes) do
        --dump(g.id.."/"..nId)

  local dir = originPin.direction
  for _, node in pairs(self.graph.nodes) do
    self._creationWorkflowInfo[node.id] = { allowed = true }

    local nextEdge = {}
    for nId, _ in pairs(edge) do
      local node = self.graph.nodes[nId]

            for _, v in pairs(self.graph.links) do
              if self.graph:linkExists(startPin, v.targetPin) then

            --[[
            for _, v in pairs(self.graph.links) do
              if self.graph:linkExists(v.sourcePin, endPin) then

            local p2 = self.graph:findPin(ui_flowgraph_editor.PtrToId(endPinId))
            for k, v in pairs(self.graph.links) do
              if v.targetPin.id == p2.id then

  if ui_flowgraph_editor.BeginDelete() then
    for lId, _ in pairs(self.linksToRemove) do
      ui_flowgraph_editor.DeleteLink(lId)

    end
    for nId, _ in pairs(self.nodesToRemove) do
      ui_flowgraph_editor.DeleteNode(nId)

  end
  for id, node in pairs(self.graph.nodes) do
    node._isSelected = self.selectedNodes[node.id]

  end
  for id, link in pairs(self.graph.links) do
    link._isSelected = self.selectedLinks[link.id]

function C:findLinkIdFromHiddenLinkId(hiddenId)
  for _, link in pairs(self.graph.links) do
    if link.hiddenId == hiddenId then

  }
  for id, _ in pairs(self.selectedNodes) do
    self.copyData.minId = math.min(id, self.copyData.minId)

  for id, link in pairs(self.graph.links) do
    if self.selectedNodes[link.targetNode.id] ~= nil and self.selectedNodes[link.sourceNode.id] ~= nil

  --dumpz(self.copyData,2)
  --for _, gr in pairs(self.copyData.graphs) do
  --  dumpz(gr.nodes,1)

  local center = im.ImVec2(0, 0)
  for _, nodeData in pairs(self.copyData.nodes) do
    center.x = center.x + nodeData.pos[1]--.x

  --local oldIdMap = {}
  for id, nodeData in pairs(self.copyData.nodes) do
    if nodeData then

  end
  for id, node in pairs(ids) do
    if node.nodeType == 'macro/integrated' then

  end
  for id, linkData in pairs(self.copyData.links) do
    local sourceNode = ids[linkData[1]]

  if self.allowEditing then
    for id, _ in pairs(self.selectedNodes) do
      local node = self.graph.nodes[id]

    for id, _ in pairs(self.selectedLinks) do
      local link = self.graph.links[id]

  end
  for k, node in pairs(graph.nodes) do
    ui_flowgraph_editor.DeleteNode(node.id)

  end
  for k, link in pairs(graph.links) do
    ui_flowgraph_editor.DeleteLink(link.id)

function C:deleteGraphs()
  for k, graph in pairs(self.graphs) do
    self:deleteGraph(graph)

  end
  for k, macro in pairs(self.macros) do
    self:deleteGraph(macro)

        local newGraphs = {}
        for gId, g in pairs(currentGraphs) do
          for cId, c in pairs(g.children or {}) do

        for gId, g in pairs(currentGraphs) do
          for cId, c in pairs(g.children or {}) do
            --dump(cId)

    end
    --for k, v in pairs(oldIdMap) do print(k .. "=>" .. (v.nodeType ~= nil and "Node" or "Graph") .. dumps(v.name)) end
    -- rebuild stategraph or create new one

    for _, graph in pairs(self.graphs) do
      for _, node in pairs(graph.nodes) do

    for _, graph in pairs(self.graphs) do
      for _, node in pairs(graph.nodes) do
        node:_postDeserialize()

    ui_flowgraph_editor.SetCurrentEditor(self.fgEditor.ectx)
    for _, gr in pairs(self.graphs) do
      for _, node in pairs(gr.nodes) do

    for _, gr in pairs(self.graphs) do
      for _, node in pairs(gr.nodes) do
        node:updateEditorPosition()

    end
    for _, gr in pairs(self.macros) do
      for _, node in pairs(gr.nodes) do

    for _, gr in pairs(self.macros) do
      for _, node in pairs(gr.nodes) do
        node:updateEditorPosition()

    ui_flowgraph_editor.SetCurrentEditor(self.fgEditor.ectx)
    for _, gr in pairs(self.graphs) do
      for _, node in pairs(gr.nodes) do

    for _, gr in pairs(self.graphs) do
      for _, node in pairs(gr.nodes) do
        node:updateNodePosition()

function C:findMacrosUsedInChildren(graph, list)
  for id, child in pairs(graph.children or {}) do
    if child.macroID then

  for id, macro in pairs(serializedMacros) do
    local list = {}

    local resolved = {}
    for id, list in pairs(map) do
      if next(list) == nil then

    for _, res in ipairs(resolved) do
      for id, list in pairs(map) do
        if arrayFindValueIndex(list, res) then

local function revertMacroInstanceToSubgraph(self)
  for nodeId, _ in pairs(self.selectedNodes) do
    local oldNode = self.graph.nodes[nodeId]

  local hooks = {}
  for h, ms in pairs(moduleHooks) do
    hooks[h] = function(mh, ...)

  -- put all the nodes in there (if not in there already)
  --[[for _, graph in pairs(self.graphs) do
    if graph.type ~= 'macro' then

    if graph.type ~= 'macro' then
      for _, node in pairs(graph.nodes) do
        table.insert(hookList, node)

  local depKeys = {}
  for _, graph in pairs(self.graphs) do
    if graph.type ~= 'macro' then

    if graph.type ~= 'macro' then
      for _, node in pairs(graph.nodes) do
        for _, dep in ipairs(node.dependencies or {}) do

  end
  for _, m in pairs(self.modules) do
    for _, dep in ipairs(m.dependencies or {}) do

  local deps = {}
  for k, _ in pairs(depKeys) do
    table.insert(deps, k)

  local dualColorChecked = {}
  for _, graph in pairs(self.graphs) do
    for _, node in pairs(graph.nodes) do

  for _, graph in pairs(self.graphs) do
    for _, node in pairs(graph.nodes) do
      local chk = node._flowColors

      local triggerNodes = {}
      for i, c in pairs(chk) do
        table.insert(insert, i.id)

    self.garbageData = nil
    for _, g in pairs(self.graphs) do
      if g.parentId == nil then

      --[[
      for _, graph in pairs(self.graphs) do
        for _, node in pairs(graph.nodes) do

      for _, graph in pairs(self.graphs) do
        for _, node in pairs(graph.nodes) do
          if node.changedRunningState then

  for _, graph in pairs(self.graphs) do
    graph:_executionStarted()

  for _, graph in pairs(self.graphs) do
    graph:_onClear()

    }
  for grId, graph in pairs(self.graphs) do
    graph:_executionStopped()

    self.garbageData.graphs[grId] = graph.gcprobeTable
    for nId, entry in pairs(graph.gcprobeTable.entries or {}) do
      self.garbageData.nodes[nId] = entry

function C:getGraphByName(name)
  for _, gr in pairs(self.graphs) do
    if gr.name == name then

  self.variables:finalizeChanges()
  for _, graph in pairs(self.graphs) do
    graph.variables:finalizeChanges()

  -- Loop through all spinners and update their timers
  for id, timer in pairs(spinnerTimers) do
    timer = timer + dtSim

  if type(tbl) ~= 'table' then return tbl end
  for k, v in pairs(tbl) do
    local newV = tableToVec3OrQuat(v)

  if type(tbl) ~= 'table' then return tbl end
  for k, v in pairs(tbl) do
    if migrateKeysMapping[k] ~= nil then

  active = false
  for _, o in pairs(buttonOptions) do o.active = false end
end

  active = true
  for _, o in pairs(buttonOptions) do o.active = false end
  buttonOptions.towToRoad.active = true

  active = true
  for _, o in pairs(buttonOptions) do o.active = false end
  buttonOptions.towToRoad.active = true

  active = true
  for _, o in pairs(buttonOptions) do o.active = true end
end

local function deactivateAllButtons() for _, o in pairs(buttonOptions) do o.active = false end end

  local highest = 0
  for _, o in pairs(buttonOptions) do
    highest = math.max(highest, o.order)

  local orders = {}
  for _, o in pairs(buttonOptions) do
    if orders[o.order] then log("E","Order Collision for buttons: " .. orders[o.order] .. "/"..o.id) end

local function setButtonLimits(limits)
  for _, o in pairs(buttonOptions) do o.limit = nil end
  for id, limit in pairs(limits or {}) do

  for _, o in pairs(buttonOptions) do o.limit = nil end
  for id, limit in pairs(limits or {}) do
    if limit == -1 then

local function resetButtonLimitCounters(onlyFor)
  for id, o in pairs(buttonOptions) do
    if not onlyFor or onlyFor[id] then

  local ret = {}
  for id, o in pairs(buttonOptions) do
    ret[id] = {limit = o.limit, count = o.count}

  }
  for id, btn in pairs(buttonOptions) do
    ret.buttons[id] = btn.active or false

  active = data.active
  for id, btnActive in pairs(data.buttons or {}) do
    setButtonActiveById(id, btnActive)

  local buttons = {}
  for id, option in pairs(buttonOptions) do
    if (option.type or "none") == target.type and option.active then

  local recoveryOptions = {}
  for recoveryOptionId, recoveryOptionData in pairs(buttonOptions) do
    recoveryOptions[recoveryOptionId] = {

local function emitInputs()
  for buttonName, buttonValue in pairs(hardwareState.buttons) do
    if lastHardwareState.buttons[buttonName] ~= buttonValue then

  for axisName, axisValue in pairs(hardwareState.axes) do
    if lastHardwareState.axes[axisName] ~= axisValue then

  buttonStateLookup = {}
  for key, value in pairs(buttonTypes) do
    buttonTypeLookup[value] = key

  end
  for key, value in pairs(buttonStates) do
    buttonStateLookup[value] = key

  if meshesBySpline then
    for _, v in pairs(meshesBySpline) do
      local numMeshesByShape = #v

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

  self.timerData = timers
  for timerId, data in pairs(self.timerData) do
    self:createPin("out", "flow", 'flow_' .. timerId).impulse = true

  for timerId, data in pairs(self.timerData) do
    if data.type ~= "timer" and data.isSet then

  local payload = {counter + counterHighBits}
  for _, dataByte in pairs(data) do
    table.insert(payload, dataByte)

  local payload = {counter}
  for _, dataByte in pairs(data) do
    table.insert(payload, dataByte)

  local payload = {counter}
  for _, dataByte in pairs(data) do
    table.insert(payload, dataByte)

  local payload = {firstByte, (counter + lshift(counterHighBits, 4))}
  for _, dataByte in pairs(data) do
    table.insert(payload, dataByte)

    local parsed = {}
    for i,v in base.pairs(default or parsed) do parsed[i] = v end
    -- empty url is parsed to nil

  slowStreamData.bestSegmentTimesFormatted = {}
  for segmentIndex, time in pairs(bestSegmentTimes) do
    local lap = bestSegmentLaps[segmentIndex] or 1

  for _, d in pairs(level_dirs) do
    -- check if its a valid folder really

  for _, l in pairs(found_levels) do
    -- so, enrich the data of the levels for the user interface below

      local newPreviews = {}
      for _, img in pairs(info["previews"]) do
        table.insert(newPreviews, l.dir..'/' .. img)

    if type(info.spawnPoints) == 'table' then
      for _, point in pairs(info.spawnPoints) do
        if not point.previews then point.previews = {} end

        local newPreviews = {}
        for _, img in pairs(point.previews) do
          table.insert(newPreviews, l.dir..'/' .. img)

  local jsonLevels = {}
  for _, level in pairs(levels) do
    if string.find(level.fullfilename, ".json") then

  local newLevels = {}
  for _, level in pairs(levels) do
    -- check if there is a json version of this, thus hide the old .mis file format

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

  local counter = 0
  for _, s in pairs(registeredEnergyStorages) do
    local storage = energyStorage.getStorage(s)

local function updateEnergyStorageRatios()
  for _, s in pairs(registeredEnergyStorages) do
    local storage = energyStorage.getStorage(s)

  local previousTankCount = storageWithEnergyCounter
  for _, s in pairs(registeredEnergyStorages) do
    local storage = energyStorage.getStorage(s)

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

                local delItems = {}
                for _, item in pairs(deletedItems) do
                  table.insert(delItems, item)

                -- make sure old and new transforms are in the same order as items
                for itemKey, item in pairs(itemsUnique) do
                  table.insert(itemsTbl, item)

                  table.insert(itemsTbl, item)
                  for sKey, transformTbl in pairs(snappedItems) do
                    if sKey == itemKey then

                  end
                  for newTransformKey, transform in pairs(newTransforms) do
                    if newTransformKey == itemKey then

      local modes = o.GraphicDisplayDriver.getModes()
      for _,v in pairs(modes.keys) do
        if current == v then

      -- log('I','','Overall quality to be applied is '..value..' : '..dumps(levelData))
      for k,v in pairs(levelData) do
        o[k].set(v)

      local temp = {}
      for index, group in pairs(overallQualityPresets) do
        for key, presetValue in pairs(group) do

      for index, group in pairs(overallQualityPresets) do
        for key, presetValue in pairs(group) do
          temp[key] = true

      presetKeys = {}
      for k,v in pairs(temp) do
        table.insert(presetKeys, k)

      local matchedGroupIndex = nil
      for index, group in pairs(overallQualityPresets) do
        -- log('I','','  Checking group: '..tostring(index))

  for k,v in pairs(data) do
    if graphicsOptions[k] and type(graphicsOptions[k].init) == 'function' then

    data.GraphicFullscreen = true
    for k, v in pairs(data) do
      settings.setValue(k, v)

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

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

    local dF = child:getDynamicFields()
    for _, value in pairs(dF or {}) do
      if type(value) == "string" and value == self.pinIn.dynamicName.value then

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

    end
    for _, node in pairs(parentNode.children) do
      local child = findNodeById(instance, node, objId)

    if node.children then
      for childId,child in pairs(node.children) do
        cacheGroupNodeInternal(instance, child, groupsToChildren, nestingLevel + 1)

  if node.children then
    for _, child in pairs(node.children) do
      removeNodeByObjectId(child, objId)

  if node.children and tableSize(node.children) then
    for _, child in pairs(node.children) do
      applyFilterRecursive(instance, child)

  if node.children then
    for _, child in pairs(node.children) do
      getNodeOpenStatus(child, res)

  if node.children then
    for _, child in pairs(node.children) do
      applyNodeOpenStatus(child, openStatus)

  for index, instance in pairs(guiInstancer.instances) do
    local openStatus

    node.parent.open = true
    for index, instance in pairs(guiInstancer.instances) do
      instance.rootNodeSizeCache = nil

  if node.children then
    for _, child in pairs(node.children) do
      updateNodeSelection(instance, child)

local function onEditorObjectSelectionChanged()
  for index, instance in pairs(guiInstancer.instances) do
    if instance.selectedNodes then

    if instance.selectedNodes then
      for _, node in pairs(instance.selectedNodes) do
        node.selected = false

        if group then
          for _, instance in pairs(guiInstancer.instances) do
            local groupNode = findNodeByObject(instance, nil, group)

    editingNodeName = nil
    for index, instance in pairs(guiInstancer.instances) do
      instance.rootNodeSizeCache = nil

local function moveSelectionIndex(up)
  for index, instance in pairs(guiInstancer.instances) do
    if instance.focused and instance.currentListIndex then

  if parent then
    for _, node in pairs(instance.selectedNodes) do
      if parent.id == node.id then

local function refreshAllNodes(incomingObjectIds)
  for _, instance in pairs(guiInstancer.instances) do
    cacheGroupNode(instance, instance.rootNode, incomingObjectIds, 0)

    if recursive then
      for _, child in pairs(node.children) do
        sortGroupNode(instance, child, recursive)

  if not node.children then return end
  for _, child in pairs(node.children) do
    child.open = false

local function removeObjectFromSet(object, simset)
  for _, instance in pairs(guiInstancer.instances) do
    removeNodesByObjectIds(instance, {object:getID()})

  refreshAllNodes()
  for index, instance in pairs(guiInstancer.instances) do
    refreshNodeCache(instance)

      local group = scenetree.findObjectById(groupId)
      for _, instance in pairs(guiInstancer.instances) do
        local groupNode = findNodeByObject(instance, nil, group)

    elseif operation == opRemoveObject then
      for _, instance in pairs(guiInstancer.instances) do
        removeNodesByObjectIds(instance, batchedData)

    for index, instance in pairs(guiInstancer.instances) do
      refreshNodeCache(instance)

  for _, instance in pairs(guiInstancer.instances) do
    if instance.rootNode then

local function selectChildrenRecursive(instance, parent, objectIDs)
  for _, node in pairs(parent.children) do
    if node.isGroup then

  table.insert(objectIDs, node.id)
  for _, n in pairs(node.children or {}) do
    setFieldRec(n, v, objectIDs)

    end
    for _, n in pairs(node.children or {}) do
      setFieldRec(n, newValue, objectIDs)

  entrySize = round(math.max(imgui.CalcTextSize("W").y, smallIconSize.y * imgui.uiscale[0]) + imgui.GetStyle().FramePadding.y + 1) + 4
  for index, instance in pairs(guiInstancer.instances) do
    currentSceneTreeInstanceIndex = index

          instance.selectionRange = {}
          for nodeListIndex, _ in pairs(dragSelectionList) do
            instance.selectionRange[nodeListIndex] = true

  recacheAllNodes()
  for key, instance in pairs(guiInstancer.instances) do
    instance.nameFilter = imgui.ImGuiTextFilter()

  local instancesCopy = deepcopy(guiInstancer.instances)
  for key, instance in pairs(guiInstancer.instances) do
    instance.nameFilter = nil

  recacheAllNodes()
  for index, instance in pairs(guiInstancer.instances) do
    instance.selectedNodes = {}

  recacheAllNodes()
  for index, instance in pairs(guiInstancer.instances) do
    instance.selectedNodes = {}

  editor.hideAllSceneTreeInstances = function()
    for _, wnd in pairs(guiInstancer.instances) do
      editor.hideWindow(wnd.windowName)

  editor.showAllSceneTreeInstances = function()
    for _, wnd in pairs(guiInstancer.instances) do
      editor.showWindow(wnd.windowName)

local function onWindowGotFocus(windowName)
  for index, instance in pairs(guiInstancer.instances) do
    if windowName == sceneTreeWindowNamePrefix .. index then

  local allLostFocus = true
  for index, instance in pairs(guiInstancer.instances) do
    if windowName == sceneTreeWindowNamePrefix .. index then

  recacheAllNodes(true)
  for index, instance in pairs(guiInstancer.instances) do
    refreshNodeCache(instance)

  if not objectIds then return end
  for index, instance in pairs(guiInstancer.instances) do
    local renamer = function(func, node, objectIds)

      if node.isGroup then
        for _, child in pairs(node.children) do
          func(func, child, objectIds)

  for index, instance in pairs(guiInstancer.instances) do
    for _, id in ipairs(selectedIds) do

local function closeAllInstances()
  for index, instance in pairs(guiInstancer.instances) do
    local wndName = instance.windowName

  if object then
    for index, instance in pairs(guiInstancer.instances) do
      local node = findNodeByObject(instance, nil, object)

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

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

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

	local alib = {}
	for _,p in pairs(apth) do
		unrequire(p)

        local dparam = {}
        for i,s in pairs(cnt[nm].beams) do
            if not s[1] then

            if not s[1] then
                for k,v in pairs(s) do
                    dparam[k] = v

--        dump(aflex, '?? AFLEX:')
    for key,p in pairs(pvd.vdata.activePartsData) do
        local p,f = jbeamIO.getPart(vehData.ioCtx, key)

--        dump(pvd.vdata.beams,'?? beams:',nil,2)
    for i,b in pairs(pvd.vdata.beams) do
        if p2f[b.partOrigin] then

      -- Iterate over the first children.
      for _, v1 in pairs(d[2]) do

          local pred, succ, geom, elev, sElev, lanes, laneOffsets = nil, nil, {}, {}, {}, {}, {}
          for _, v2 in pairs(v1) do

            if v2.label == 'link' then
              for _, v3 in pairs(v2) do
                if v3.label == 'predecessor' then

            elseif v2.label == 'planView' then
              for _, v3 in pairs(v2) do
                local gInner = {}

                if v3.label == 'geometry' then
                  for _, v4 in pairs(v3) do
                    if v4.label == 'line' then

            elseif v2.label == 'elevationProfile' then
              for _, v3 in pairs(v2) do
                if v3.label == 'elevation' then

            elseif v2.label == 'lateralProfile' then
              for _, v3 in pairs(v2) do
                if v3.label == 'superelevation' then

            elseif v2.label == 'lanes' then
              for _, v3 in pairs(v2) do
                if v3.label == 'laneSection' then

                  local lSecData = { s = tonumber(v3.xarg.s) }
                  for _, v4 in pairs(v3) do
                    if v4.label == 'left' or v4.label == 'right' then

                    if v4.label == 'left' or v4.label == 'right' then
                      for _, v5 in pairs(v4) do
                        if v5.label == 'lane' then

                          lSecData[laneId] = { type = tonumber(lD.type), dir = lD.direction, widths = {}, heights = {} }
                          for _, v6 in pairs(v5) do
                            local lA = v6.xarg

                            elseif v6.label == 'link' then
                              for _, v7 in pairs(v6) do
                                if v7.label == 'predecessor' then

          local jId, jType, conn = tonumber(v1.xarg.id), v1.xarg.type, {}
          for _, v2 in pairs(v1) do
            if v2.label == 'connection' then

              local links = {}
              for _, v3 in pairs(v2) do
                if v3.label == 'laneLink' then

        log('I', "lua.test", "* loading jbeam files:")
        for k,v in pairs(jbeamFiles) do
            local content = readFile(v)

    if im.BeginPopup(string.format("WidgetTypePopup_%s", widgetId)) then
      for name, id in pairs(api.widgetTypes[propType]) do
        if im.Selectable1(name, id == (property.widgetType or 0)) then

local function editModeUpdate(dtReal, dtSim, dtRaw)
  for id, _ in pairs(highlightedWidgets) do
    highlightedWidgets[id].time = highlightedWidgets[id].time - dtReal

  table.clear(wheelInfo)
  for i, wd in pairs(wheels.wheelRotators) do
    local w = wheelCache[i] or {}

local function update()
  for k, _ in pairs(streamControl) do
    local handler = streamsHandlers[k]

  table.clear(streamControl)
  for _, streamName in pairs(state) do
    streamControl[streamName] = true

  local roadArray, ctr = {}, 1
  for _, v in pairs(roads) do
    roadArray[ctr] = v

  local reverseGears = {}
  for k, v in pairs(jbeamData.gearRatios) do
    if type(k) == "number" then

    local gearIndex = device.minGearIndex
    for _, v in pairs(gearWhineCoefsOutput) do
      device.gearWhineCoefsOutput[gearIndex] = v

    local gearIndex = device.minGearIndex
    for _, v in pairs(gearWhineCoefsInput) do
      device.gearWhineCoefsInput[gearIndex] = v

}
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

  local brakeLName = jbeamData.leftBrakeName or "brake_L"
  for _, wd in pairs(wheels.wheelRotators) do
    if wd.name == brakeLName then

  local idx = 1
  for _, container in pairs(v.data.cargoStorage or {}) do
    -- generate an entry for the list that will be sent back to geLua.

  -- store all nodes for groups
  for _, node in pairs(v.data.nodes) do
    if node.cargoGroup and cargoContainerGroupIdToCacheIndex[node.cargoGroup .. node.partPath] then

      local hasValidFunction = true
      for functionName, _ in pairs(functionFieldNames) do
        if node[functionName] then

  -- store all beams for groups
  for _, beam in pairs(v.data.beams) do
    if beam.cargoGroup and cargoContainerGroupIdToCacheIndex[beam.cargoGroup .. beam.partPath] then

      local hasValidFunction = true
      for functionName, _ in pairs(functionFieldNames) do
        if beam[functionName] then

local function clearFunctionResults()
  for _, data in pairs(functionCache) do
    data.result = nil

  anyContainerNeedsUpdate = false
  for _, container in pairs(cargoContainerById) do
    if not container.reachedTarget then

  -- set all container weights according to the params data.
  for _, setContainerData in pairs(params[1] or {}) do
    -- first check if all containers have proper data

  anyContainerNeedsUpdate = false
  for id, _ in pairs(cargoContainerById) do
    local setContainerData = (params[1] or {})[id]

  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

  for _, location in pairs(damageLocationNames) do
    textualDamageLocations.damagedLocations[location.name] =

  -- for _, location in pairs(damageLocationNames) do
  --   if textualDamageLocations.damagedLocations[location.name] then

  local highestScore = 0
  for locationName, locationData in pairs(textualDamageLocations.damagedLocations) do
    if locationData.damageLocationScore > highestScore then

  else
    for cellId, cellDamageInfo in pairs(data.oldSectionsDamageRaw) do
      data.oldSectionsDamageRaw[cellId] = cellDamageInfo[damageType]

    data.newSectionsDamageInfoRaw = {}
    for cellId, cellDamageInfo in pairs(getSectionsDamageInfoRaw(data.vehId)) do
      data.newSectionsDamageInfoRaw[cellId] = cellDamageInfo[damageType]

  else
    for cellId, cellDamageInfo in pairs(data.newSectionsDamageInfoRaw) do
      data.newSectionsDamageInfoRaw[cellId] = cellDamageInfo[damageType]

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

local all = {}
for _, rList in pairs(rooms) do
  for _, r in ipairs(rList) do

    local allChildrenIds = {}
    for type, list in pairs(data.allChildrenIds) do
      if type ~= "Prefab" then

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

      local hasDefaultUnlockedStar = false
      for starKey, _ in pairs(attempt.unlockedStars) do
        if self.mgr.activity.careerSetup._activeStarCache.defaultStarKeysByKey[starKey] then

    self.pinOut.change.value = totalChange or {}
    for key, val in pairs(aggregateChange) do
      if self.pinOut[key] then

    local allModels = core_vehicles.getModelList().models
    for model, _ in pairs(allModels) do
        if vehiclesToLoad[string.lower(model)] == true then

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

      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

        -- find the corresponding route of the current parking spot
        for i, parkingSpotRoute in pairs(dealership.testDrive.parkingSpotRoutes) do
          if parkingSpotRoute.parkingSpotName == parkingSpot.name then

	local alib = {}
	for _,p in pairs(apth) do
		unrequire(p)

--            dump(g, '?? for_g:'..N)
        for i,c in pairs(ac) do
            ac[i] = ac[i] + g[i]*1

--            dump(g, '?? for_g:'..N)
        for i,c in pairs(ac) do
            ac[i] = ac[i] + g[i]*5

        local s = 0
        for i,p in pairs(set) do
            local ds = (p - (a + u*(p-a):dot(u))):length()

--    local c = vec3(0,0,0)
--    for i,p in pairs(set) do
--        c = c + p

  self.pinOut.vehicleSpawned.value = false
  for flag, act in pairs(self.flags) do
    self.pinOut[flag].value = act

		local res = {}
		for k, v in pairs(value) do
			if type(k) == "number" then

	local res = {}
	for k, v in pairs(packet) do
		res[#res + 1] = str_format("%s=%s", k, value_tostring(v))

		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

      self.positions = {}
      for id, val in pairs(prefabData.originalVehicleTransforms) do
        if getObjectByID(id) and not string.find(getObjectByID(id):getInternalName() or "",'ignore') then

        local modes = {}
        for id, val in pairs(self.originalVehicleTransforms) do
          if getObjectByID(id) and not string.find(getObjectByID(id):getInternalName() or "",'ignore') then

    local change, changed  = {}, false
    for id, val in pairs(self.originalVehicleTransforms) do
      change[id] = 'hidden'

function C:onDrawOnMinimap(td)
  for id, pos in pairs(self.positions) do
    if not self.vehicleHit[id] then

local sortedString = {}
for name, val in pairs(mergeFunctionsAll) do
  mergeFunctionsAny[name] = val

end
for name, val in pairs(mergeFunctionsNumber) do
  mergeFunctionsAny['num_'.. name] = val

end
for name, val in pairs(mergeFunctionsBool) do
  mergeFunctionsAny['bool_'.. name] = val

end
for name, val in pairs(mergeFunctionsVec) do
  mergeFunctionsAny['vec_'.. name] = val

end
for name, val in pairs(mergeFunctionsString) do
  mergeFunctionsAny['any_'.. name] = val

  for _, model in pairs(core_vehicles.getModelList().models) do
    local modelType = model.Type or "Unknown"

    if (modelType == "Car" or modelType == "Truck") and not checkFilter(modelFilter, model.key, invertedFilters.modelFilter) then
      for _, config in pairs(core_vehicles.getModel(model.key).configs) do
        local modelConfigKey = string.format("%s/%s", model.key, config.key)

  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

  --include all math functions and constants
  for k, v in pairs(math) do
    env[k] = v

  --dumpz(self.graph.links,2)
  for _, l in pairs(self.graph.links) do
    if l.targetNode.id == self.id then

  self.keyworkdWhiteListLookup = {}
  for _, v in pairs(keywordWhiteList) do
    self.keyworkdWhiteListLookup[v] = true

  local t, n = {}, 0
  for k in pairs(count1) do
    n = n + 1

  local ms = 0
  for k, v in pairs(count1) do
    local pct = floor(v*100/samples + 0.5)

  }
  for id, offer in pairs(markedForSpawningLoaners) do
    -- spawn vehicle and trigger initialization

  local result = {}
  for inventoryId, vehInfo in pairs(career_modules_inventory.getVehicles()) do
    if vehInfo.owningOrganization then

local function onUpdate(dtReal, dtSim, dtRaw)
  for inventoryId, vehId in pairs(career_modules_inventory.getMapInventoryIdToVehId()) do
    local vehInfo = career_modules_inventory.getVehicles()[inventoryId]

  for inventoryId, loanedVehInfo in pairs(loanedVehiclesInfo) do
    local vehInfo = career_modules_inventory.getVehicles()[inventoryId]

  local counter = 0
  for inventoryId, vehicleInfo in pairs(career_modules_inventory.getVehicles()) do
    if vehicleInfo.owningOrganization == organizationId then

  local numberNonTrailers, numberTrailers = 0, 0
  for id, offer in pairs(markedForSpawningLoaners) do
    local configInfo = core_vehicles.getConfig(offer.model, offer.config)

  end
  for sceneViewName, view in pairs(sceneViews) do
    if editor.beginWindow(sceneViewName, sceneViewName) and view.control.renderView  then

    sceneViews = {}
    for name, view in pairs(deserializedData.sceneViews or {}) do
      createNewSceneView(name, view)

  local viewsSerialized = {}
  for sceneViewName, view in pairs(sceneViews) do
    viewsSerialized[sceneViewName] = {

  for _, o in pairs(self.objects) do
    for _, tag in ipairs(o.customFields.sortedTags) do

  end
  for _, o in pairs(self.objects) do
    o._drawMode = 'normal'

  for _, o in pairs(self.objects) do
    o._drawMode = 'faded'

  for _, o in pairs(self.objects) do
    o._drawMode = 'normal'

  else
    for t, _ in pairs(self.sharedSelectedTags or {}) do
      if im.GetCursorPosX() + im.CalcTextSize(t).x + 10 > totalWidth then

    if im.BeginCombo("##tagSelect", "...") then
      for tag, _ in pairs(self.currTags) do
        if im.Selectable1(tag) then

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

  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

  }
  for fp, site in pairs(sitesCache) do
    ret.sitesCache[fp] = site:onSerialize()

  currentLevel = data.currentLevel or getCurrentLevelIdentifier()
  for fp, s in pairs(data.sitesCache) do
    local site = require('/lua/ge/extensions/gameplay/sites/sites')()

  if saveData.linearStep == -1 then
    for key, _ in pairs(saveData.flags) do
      saveData.flags[key] = true

  for k, v in pairs(gameplay_traffic.getTrafficData()) do
    if v.role.name == "police" then

  for k, v in pairs(gameplay_traffic.getTrafficData()) do
    if v.role.name == "police" then

for key, values in pairs(introPopupTable) do
  M[key] = function()

  M.showNonTutorialWelcomeSplashscreen()
  for key, values in pairs(introPopupTable) do
    M[key]()

    if o.track_users then
        for channel, v in pairs(o.channels) do
            v.users[user.nick] = nil

    if o.track_users then
        for channel, v in pairs(o.channels) do
            local users = v.users

  self.pinOut.beforeGarageVehicleSelected.value = false
  for flag, act in pairs(self.flags) do
    self.pinOut[flag].value = act

  local groups = {}
  for keyEntry, entry in pairs(vehicle) do
    if type(entry) == "table" then

    if type(entry) == "table" then
      for rowKey, row in pairs(entry) do
        if type(row) == "table" then

    --log('D', "jbeam.postProcess"," - processed "..tableSize(vehicle.groups).." groups")
    --for k, g in pairs(vehicle.groups) do
    --    log('D', "jbeam.postProcess","  - "..k.." : "..g)

function C:workOnce()
  for id, v in pairs(gameplay_traffic.getTrafficData()) do
    if v.isAi then

    local cluster = {}
    for level, locations in pairs(locationsByLevel) do
      local qt = quadtree.newQuadtree()

  if not self.path then return end
  for _, sp in pairs(self.path.startPositions.objects) do
    sp._drawMode = 'normal'

  --self:selectStartPosition(nil)
  for _, sp in pairs(self.path.startPositions.objects) do
    sp._drawMode = 'faded'

  self.index = id
  for _, sp in pairs(self.path.startPositions.objects) do
    sp._drawMode = (id == sp.id) and 'highlight' or 'normal'

  local closestSP = nil
  for idx, sp in pairs(self.path.startPositions.objects) do
    local distToCam = (sp.pos - self.mouseInfo.camPos):length()

  wheelNamesString = ""
  for _, v in pairs(jbeamData.lockedLines or {}) do
    lockedLines[v] = true

  local blanks = 0
  for k, v in pairs(self.materialsToTextureMaps) do
    if not v then -- if material to texture map entry is still false

    local h = "\r\n"
    for f, v in base.pairs(tosend) do
        h = (canonic[f] or f) .. ": " .. v .. "\r\n" .. h

    -- override with user headers
    for i,v in base.pairs(reqt.headers or lower) do
        lower[string.lower(i)] = v

    -- explicit components override url
    for i,v in base.pairs(reqt) do nreqt[i] = v end
    if nreqt.port == "" then nreqt.port = 80 end

        for name2, _ in pairs(sMeshes) do
          if name2 ~= name then

      local i = 1
      for name, _ in pairs(sMeshes) do
        if im.ImGuiTextFilter_PassFilter(meshesFilter, name) then

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

  local result = {}
  for originalSetting,v in pairs(settings) do
    local setting = upgradeSetting(originalSetting)

    M.internalValues = upgradeSettings(internalValues)
    for k,v in pairs(M.internalValues) do
      local definition = M.defaults[k]

  steamdeckValues = upgradeSettings(steamdeckValues)
  for k,v in pairs(steamdeckValues) do
    local definition = M.defaults[k]

M.defaultValues = {}
for k,v in pairs(M.defaults) do
  M.defaultValues[k] = v[2]

    if CppSettings then
      for k,value in pairs(values) do
        if CppSettings[k] ~= nil then

local function doesVehiclePassFiltersList(vehicleInfo, filters)
  for filterName, parameters in pairs(filters) do

  local popList = {}
  for model_key, pop in pairs(modelPops) do
    table.insert(popList, {model_key = model_key, pop = pop})

  local configData = deepcopy(core_vehicles.getConfigList())
  for _, vehicleInfo in pairs(configData.configs) do
    if vehicleInfo.aggregates.Type

  vehicleLuaSpecific()
  for streamName, data in pairs(cache) do
    queueStreamDataJS(streamName, jsonEncodeWorkBuffer(data))

    local d = stack[stackidx]
    for key, v in pairs(d) do
      local typev = type(v)

    local passed = false
    for k, v in pairs(slotVars) do
      if str_byte(v,1) == 36 then -- $

  local vars = {}
  for kv,vv in pairs(allVariables) do
    if vv.type == 'range' then

  local newVars = {}
  for k, v in pairs(allVariables) do
    if type(v) == 'table' and k ~= '$components' then

  local res = {}
  for k, v in pairs(tbl_readonly_src) do
    -- replace key

  --dump(slot.variables or {})
  for sectionKey, section in pairs(source_raw) do
    if sectionKey == 'components' then

    if sectionKey == 'components' then
      for k3, v3 in pairs(section) do
        if type(v3) == 'table' then

local function setFunctionsToNil(t)
  for k, v in pairs(t) do
    if type(v) == "function" then

  -- remove any variables that are hidden
  for k, v in pairs(vehicle.variables) do
    if v.hidden == true then

  parkButtonLookup = {}
  for key, value in pairs(leverStates) do
    leverStateLookup[value] = key

  end
  for key, value in pairs(parkButtonStates) do
    parkButtonLookup[value] = key

  local timeTotalSum = 0
  for k,vehicle in pairs(vehicles) do
    local testVehicle = 'vehicles/' .. vehicle .. '/'

    if self.pinIn.propsIds.value then
      for k,v in pairs(self.pinIn.propsIds.value) do
        if cols[v] then

  for var, varData in pairs(varsData) do
    local vdataVar = vdataVars[var]

  vehData.config.vars = vehData.config.vars or {}
  for var, varData in pairs(varsData) do
    if varData.valPtr then

local function onEditorInitialized()
  for k, view in pairs(carViews) do
    view.img = imguiUtils.texObj(view.imgPath)

  uiReady = true
  for k, v in pairs(cachedSchemes) do
    onSchemeCommand(v.sc, v.startArg)

        local tableKeys = tableKeysSorted(v)
        for _, kk in pairs(tableKeys) do
          local vv = v[kk]

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

  local closestNode = nil
  for idx, node in pairs(currentPath.pathnodes.objects) do
    local distNodeToCam = (node.pos - mouseInfo.camPos):length()

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

    if self.data.debug and closestWheels then
      for k, v in pairs(closestWheels) do
          -- Line from each closest wheel to start line

    for connection, dataChunks in pairs(recData) do
      for _, dataRaw in ipairs(dataChunks) do

  if savedRecentActions then
    for category, actions in pairs(savedRecentActions) do
      recentActions[category] = {}

      recentActions[category] = {}
      for key, action in pairs(actions) do
        local idx = tonumber(key) -- sometimes the key is a number, sometimes it's a string. stupid json

  local savedDynamicSlotSettings = {}
  for key, value in pairs(dynamicSlotSettings) do
    savedDynamicSlotSettings[key] = {

local baseDynamicSlotSettings = {}
for key, value in pairs(dynamicSlotSettings) do
  baseDynamicSlotSettings[key] = {

  if savedDynamicSlotSettings then
    for key, value in pairs(savedDynamicSlotSettings) do
      local slot = dynamicSlotSettings[key]

  for path, value in pairs(flatData) do
    -- Check if path starts with any valid root

    local isValidRoot = nil
    for root in pairs(validRoots) do
      if string.find(path, "^" .. root) then

    -- Add the final value to the leaf node
    for k, v in pairs(value) do
      v.level = path -- Assign the full path to the leaf node

local function addTitleToTreeItems(tree)
  for key, value in pairs(tree.items) do
    if value.path then

    if value.path then
      for key2, value2 in pairs(tree.items) do
        if value2["goto"] and value2["goto"] == value.path then

  local sortedItems = {}
  for key, value in pairs(tree.items) do
    value._key = key

    local newMenuTreeCopyForUI = {}
    for key, value in pairs(menuTreeCopyForUI) do
      if string.find(key, dynamicSlotSettingsData.pathFilter) then

  end
  for key, value in pairs(menuTreeCopyForUI) do
    for _, action in pairs(value or {}) do

  for key, value in pairs(menuTreeCopyForUI) do
    for _, action in pairs(value or {}) do
      action.icon = updateIcon(action.icon, action.title)

    local replaced = false
    for k, v in pairs(menuTree[args.level]) do
      if v.uniqueID == args.uniqueID then

        if vData and vData.vdata and type(vData.vdata.triggers) == 'table' then
          for _, trg in pairs(vData.vdata.triggers or {}) do
            local trigger = veh:getTrigger(trg.abid)

  -- Check each occupied slot to see if it falls within our range
  for slot, _ in pairs(occupiedSlots) do
    local normalizedSlot = ((slot - 1) % maxSlotAmount) + 1

  for path, items in pairs(menuTreeCopy) do
    for _, e in ipairs(items) do

  for path, items in pairs(menuTreeCopy) do
    for i = #items, 1, -1 do

  }
  --for _, path in pairs(favoriteActionsPaths) do
  --  protectedPaths[path] = true

  -- First pass: check all levels for emptiness
  for level, items in pairs(menuTreeCopy) do
    if level ~= "/root/" and not protectedPaths[level] then

  if hasChanges then
    for level, items in pairs(menuTreeCopy) do
      for i = #items, 1, -1 do

  if playerVehId ~= -1 then
    for k, vehicleLevel in pairs(vehicleMenuTrees[playerVehId]) do
      if menuTreeCopy[k] then

  ::gotoButtonsStart::
  for levelPath, levelInfo in pairs(menuTreeCopy) do
    if countLevels(levelPath) >= 2 then

  end
  for level, tree in pairs(menuTreeCopy) do
    local dynamicItems = {}

local function renderTree(node, path)
  for key, value in pairs(node) do
    local currentPath = (path and (path .. "/" .. key) or key)

      -- Check if the current node is a lowest-level table and extract the title if available
      for subKey, subValue in pairs(value) do
        if type(subValue) == "table" then

    local testNames = {}
    for name, func in pairs(tests) do
      if type(func) == "function" and name:match("^test") then

  local i = 1
  for _, device in pairs(powertrainDevices) do
    serializeInfoRes[i] = serializeInfoRes[i] or {}

      deviceData.children = {}
      for _, v in pairs(device.children) do
        table.insert(deviceData.children, v.name or "unknown")

  if streams.willSend("powertrainDeviceData") then
    for _, v in pairs(powertrainDevices) do
      deviceStream[v.name] = deviceStream[v.name] or {outputTorque = {}, outputAV = {}, isBroken = false, uiSimpleModeControl = v.uiSimpleModeControl}

      local di = 1
      for i, _ in pairs(v.outputPorts) do
        deviceStream[v.name].outputTorque[di] = v[outputTorqueStr[i]]

  local devices = {}
  for _, d in pairs(powertrainDevices) do
    if d.parent.isFake then

      local inverseMap = {}
      for _, d1 in pairs(d.children) do
        inverseMap[d1.inputIndex] = d1.name

      end
      for i, _ in pairs(d.outputPorts) do
        table.insert(device.children, inverseMap[i])

  if playerInfo.firstPlayerSeated then
    for _, device in pairs(powertrainDevices) do
      if device.sendTorqueData then

local function updateSimpleControlButtons()
  for _, device in pairs(powertrainDevices) do
    if device.updateSimpleControlButtons then

  if t.requiredExternalInertiaOutputs then
    for _, index in pairs(t.requiredExternalInertiaOutputs) do
      local hasMatchingChild = false

      local hasMatchingChild = false
      for _, child in pairs(t.children or {}) do
        if child.inputIndex == index then

  if t.children then
    for _, v in pairs(t.children) do
      if not t.outputPorts[v.inputIndex] then

    deviceJbeamData = {}
    for _, jbeamData in pairs(deepcopy(v.data.powertrain)) do
      tableMergeRecursive(jbeamData, v.data[jbeamData.name] or {})

        if type(jbeamData.visualPositionRelativeChildren) == "table" and tableSize(jbeamData.visualPositionRelativeChildren) > 0 then
          for _, childRelativePosition in pairs(jbeamData.visualPositionRelativeChildren) do
            device.visualPositionRelativeChildren = device.visualPositionRelativeChildren or {}

    for _, device in pairs(deviceLookup) do
      if not device.parent then

    for _, device in pairs(powertrainDevices) do
      device.parent = device.parent or {isFake = true, outputTorque0 = 0, outputTorque1 = 0, outputTorque2 = 0, deviceCategories = {}}

    --    for _,device in pairs(powertrainDevices) do
    --      print(device.name)

    --dump(beamBrokenEvents)
    --    for k,v in pairs(powertrainDevices) do
    --      print(v.name)

    for _, v in pairs(v.data.beams) do
      if v.name and v.name ~= "" and beamTriggers[v.name] then

    canResetDevices = true
    for _, device in pairs(powertrainDevices) do
      local hasReset = device.reset ~= nil

    if not tableIsEmpty(previousDeviceModes) then
      for k, v in pairs(previousDeviceModes) do
        powertrainDevices[k]:setMode(v)

  torsionReactorIndexes = {}
  for _, rotator in pairs(wheels.wheelRotators) do
    if rotator.torsionReactor then

  for _, device in pairs(powertrainDevices) do
    if device.initSounds then

  for _, device in pairs(powertrainDevices) do
    for _, groupData in ipairs(device.deformGroups) do

  torqueReactionCoefs2 = {}
  for _, rotator in pairs(wheels.wheelRotators) do
    if rotator.torsionReactor then

  for _, device in pairs(powertrainDevices) do
    if device.resetSounds then

  local newMode = device.mode
  for _, v in pairs(device.availableModes) do
    if found then

local function toggleDefaultDiffs()
  for _, v in pairs(powertrainDevices) do
    if v.type == "differential" and v.defaultToggle then

  local result = {}
  for _, v in pairs(powertrainDevices) do
    if v.type == deviceType then

  local result = {}
  for _, v in pairs(powertrainDevices) do
    if v.deviceCategories[category] then

  local poweredWheels = {}
  for _, wheel in pairs(wheels.wheels) do
    local propulsionDevice = powertrain.getPropulsionDeviceForWheel(wheel.name)

  for _, wheel in pairs(wheels.wheels) do
    local propulsionDevice = powertrain.getPropulsionDeviceForWheel(wheel.name)

  local propulsionDevices = {}
  for propulsionDevice, _ in pairs(duplicatedPropulsionDevices) do
    table.insert(propulsionDevices, powertrain.getDevice(propulsionDevice))

  local list = {}
  for k, v in pairs(self.actionsByName) do
    table.insert(list, k)

  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

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

  self.pinOut.openedMenu.value = false
  for flag, act in pairs(self.flags) do
    self.pinOut[flag].value = act

	local alib = {}
	for _,p in pairs(apth) do
		unrequire(p)

    ageopin = {}
    for i,part in pairs(ajpart) do
        if (part.sel or part.key == cpart) and daedata.dgeo then

--        if part.sel and daedata.dgeo then
            for _,k in pairs(part.amesh) do
--                    lo('?? to_SEL:'..k)

        elseif part.key == unsel then
            for _,k in pairs(part.amesh) do
                local ind = U.index(ageopin, daedata.dgeo[name2ind[k] ].key)[1]

--                dump(beamdata.abeampick,'?? for_BEAMS_p:')
            for i,b in pairs(beamdata.abeampick) do
                cstr = cstr + (b.strength == 'FLT_MAX' and 20000 or b.strength)

        end
        for k,v in pairs(dparam) do
            env.ui['in_'..k] = v

        end
        for k,v in pairs(dparam) do
            env.ui['in_'..k] = v

        ajpart = {}
        for k,v in pairs(djpart) do
            ajpart[#ajpart+1] = v

    for i,d in pairs(daedata.ageo) do
        if d.key == key and d.abeam then

    local set = {}
    for i,b in pairs(beamdata.abeam) do
        local a,b =

    beamdata.agroup = {}
    for k,v in pairs(beamdata.opart.dgroup) do
--        beamdata.dgroup[v.key] = k

        for i,p in pairs(ajpart) do
            if p.name == 'pickup_hood' then

            W.onVal('group_in',gkey)
            for i,g in pairs(beamdata.agroup) do
                if g.key == gkey then

--[[
        for j,d in pairs(data.configs) do
            if d.model_key == 'pickup' then

        local data = ui_vehicleSelector_general.getUiData()
        for j,d in pairs(data.configs) do
            if d.model_key == 'pickup' then

        local dgeo = {}
        for i,m in pairs(am) do
            dgeo[#dgeo+1] = {name=m.name,m=m,mat={nm='WarningMaterial', body=nil, c=c}}

        daedata.ageo = {}
        for k,d in pairs(dgeo) do
            daedata.ageo[#daedata.ageo+1] =

                local mi,ma = vec3(math.huge,math.huge,math.huge),-vec3(math.huge,math.huge,math.huge)
                for i,v in pairs(pvd.vdata.nodes) do
                    if v.pos.x < mi.x then

    --            local s = 0
            for k,bbag in pairs(dbeam) do
    --                s = s + #b

                    local dmi,pmi = math.huge
                    for j,m in pairs(am) do
                        if m.name == 'pickup_hood' then

                                end),c={0,1,0},w=0.005}
                            for _,b in pairs(bbag) do
                                local a = pvd.vdata.nodes[b.av[1]]

                                local a = pvd.vdata.nodes[b.av[1]]
                                for _,v in pairs(m.verts) do
            --                            dump(a, '?? for_v:'..tostring(v))

--[[
        for k,v in pairs(dbeam) do
            for _,d in pairs(daedata.ageo) do

        for k,v in pairs(dbeam) do
            for _,d in pairs(daedata.ageo) do
                if string.find(d.name,k) == 1 then

        end)
        for i,m in pairs(am) do
--                lo('?? for_PART:'..i..':'..m.name)

--            dump(U.out.agraph[1].list,'?? apath:'..tostring(apath[1][1])..'/'..#apath)
--        for i,b in pairs(pvd.vdata.beams) do
--            if not dbeam[b.partOrigin] then dbeam[b.partOrigin] = {} end

        local dicon = {}
        for i,mod in pairs(amodel) do
            local hit

            local hit
            for j,d in pairs(data.configs) do
                if d.model_key == mod then

        for _, config in pairs(data.configs) do
            if not data.displayData.showAuxContent and config.isAuxiliary then

    if true then
        for modelName, _ in pairs(core_vehicles.getModelsData()) do
            lo('?? for_model:'..modelName..':'..tostring(core_vehicles.getModel(modelName).model))

        local vid
        for i,id in pairs(aveh) do
            if false and i == 1 then

            beamdata.m = am[1]
                for k,v in pairs(dbeam) do
--                    dump(v,'??==================== vehDATA_dbeam:'..tableSize(dbeam),nil)

                end
            for k,v in pairs(dbeam) do
                for _,d in pairs(daedata.ageo) do

            for k,v in pairs(dbeam) do
                for _,d in pairs(daedata.ageo) do
                    if string.find(d.name,k) == 1 then

    local matFiles = FS:findFiles('/art/shapes/', '*'..'materials.json', -1, true, false)
    for k,f in pairs(matFiles) do
        local list = extensions.editor_resourceChecker_resourceUtil.getSimObjects(f)

--            lo('?? matFile:'..#list..':'..f)
        for i,m in pairs(list) do
--            lo('?? for_MAT:'..tostring(m.name))

    -- models list
    for modelName, _ in pairs(core_vehicles.getModelsData()) do
        amodel[#amodel+1] = modelName

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

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

    fsnode.astep = {'/'}
    for i,s in pairs(astep) do
        fsnode.astep[#fsnode.astep+1] = '/'..s

    local out,outf = {},{}
    for i,f in pairs(adir) do
        f = U.split(f, '/', true)

--        lo('?? pre_FAV:'..#afav)
    for i,p in pairs(afav) do
--            lo('?? if_fav:'..p..':'..fsnode.path)

        if string.find(p, fsnode.path) == 1 then
            for j,d in pairs(out) do
--                    lo('?? if_FAV:'..(fsnode.path..d.s))

--        lo('?? f_list:'..#list)
    for i,f in pairs(list) do
--            lo('?? fof:'..i..':'..tostring(f))

--        dump(daedata.dgeo, '?? DGEO:'..val..':'..n..':'..tableSize(daedata.dgeo),nil,2)
    for k,d in pairs(daedata.dgeo) do
        m = m + 1

                daedata.djoint[k] = jnt
                for i,iv in pairs(jnt) do
                    astick[#astick+1] = daedata.dgeo[val].m.verts[iv]+pos

    local n = 0
    for _,k in pairs(cval['geo_drag'].akey) do
        n = n + 1

    local am = {}
    for k,v in pairs(daedata.dgeo) do
        am[#am+1] = v.m

        lo('>> meshClear:'..#amesh)
    for i,d in pairs(amesh) do
--    if amesh[1] then

    local cfr,cto = vec3(0,0.9,0.2),vec3(0,0,1)
    for i,b in pairs(abeam) do
        w,c,alpha =

local function groupExtract(val, abeamsel, keepbeams)
    for i,d in pairs(beamdata.agroup) do
        if not val or d.key == val then

--[[
            for _,a in pairs(d.list) do
                for _,b in pairs(beamdata.abeam) do

            for _,a in pairs(d.list) do
                for _,b in pairs(beamdata.abeam) do
                    if b.stamp == a.stamp then

]]
            for _,b in pairs(beamdata.abeam) do

                local hit
                for _,a in pairs(d.list) do
                    if b.stamp == a.stamp and val then

    if abeam then
        for i,s in pairs(abeam) do
            abeampick[#abeampick+1] = s

    local npick = 0
    for i,b in pairs(abeam) do
        if not dfrom[b.prn] then dfrom[b.prn] = {} end

    local groupn,beamn = 0,0
    for i,s in pairs(aline) do
        if string.find(s, '"'..beamdata.cpart.name..'":') then

--[[
            for k,d in pairs(djpart['pickup_body'].abeam) do
                local stamp = U.stamp({

        ajpart = {}
        for k,v in pairs(djpart) do
            ajpart[#ajpart+1] = v

    -- models list
--    for modelName, _ in pairs(core_vehicles.getModelsData()) do
--        amodel[#amodel+1] = modelName

    ajpart = {}
    for k,v in pairs(djpart) do
        ajpart[#ajpart+1] = v

        -- cleanup params
        for k,p in pairs(dextparam) do
            lo('?? for_PARAM:'..k..':'..tostring(p == nil)..':'..tostring(tostring(p) == '')..'>'..tostring(p)..'<')

            dump(oval,'?? values_OVAL:')
--        for k,v in pairs(oval) do
--            dextparam[k] = v

        local file = io.open(beamdata.cpart.file,'w')
        for i,s in pairs(aline) do
            file:write(s, '\n')

--        partUp(beamdata.cpart)
        for i,g in pairs(beamdata.agroup) do
            if g.key == 1 then

            ajpart = {}
            for k,v in pairs(djpart) do
                ajpart[#ajpart+1] = v

            ajpart = {}
            for k,v in pairs(djpart) do
                ajpart[#ajpart+1] = v

        local npick = 0
        for i,b in pairs(beamdata.abeampick) do
            if b.prn ~= keyto then

        local groupn,beamn = 0,0
        for i,s in pairs(aline) do
            if string.find(s, '"'..beamdata.cpart.name..'":') then

        local groupn,beamn = 0,0
        for i,s in pairs(aline) do
            if string.find(s, '"'..beamdata.cpart.name..'":') then

                                lo('?? to_TARGET:'..i..':'..groupn..':'..#linemove)
                            for j,s in pairs(linemove) do
                                table.insert(aline, i, s)

            'w')
        for i,s in pairs(aline) do
            file:write(s, '\n')

        partUp(beamdata.cpart)
        for i,g in pairs(beamdata.agroup) do
            if g.key == keyto then

            ajpart = {}
            for k,v in pairs(djpart) do
                ajpart[#ajpart+1] = v

    --            dump(aveh, '?? aVEH:')
            for i,id in pairs(aveh) do
                scenetree.findObjectById(id):delete()

            ajpart = {}
            for k,v in pairs(djpart) do
                ajpart[#ajpart+1] = v

            if cg then
                for j,g in pairs(beamdata.agroup) do
                    if g.key == cg then

]]
--        for i,d in pairs(beamdata.agpick)
--        val.sel = not val.sel

        local cbeam = {}
        for i,b in pairs(beamdata.cgroup) do
            if val == b.stamp then

        local part
        for i,p in pairs(ajpart) do
            if val == p.key then

--[[
        for i,part in pairs(ajpart) do
            if part.sel and daedata.dgeo then

            if part.sel and daedata.dgeo then
                for _,k in pairs(part.amesh) do
    --                    lo('?? if_IND:'..tostring(name2ind[k]))

            elseif part.key == unsel then
                for _,k in pairs(part.amesh) do
                    local ind = U.index(ageopin, daedata.dgeo[name2ind[k] ].key)[1]

        ageopin = {}
        for i,p in pairs(ajpart) do
            p.sel = false

            {m=m,aiv={},aif=fbag})
        for i,p in pairs(apiece) do
            dump(geo.fbag[p],'?? piece:'..p)

            dump(geo.fbag[p],'?? piece:'..p)
            for _,fi in pairs(geo.fbag[p]) do
                dump(fi, '?? fbag_SRC:'..p)

            local pos = amesh[env.ui['lod_up']].body:getPosition()
            for i,d in pairs(apiece) do
--                    dump(geo.abag[d], '?? bag:')

--                    dump(geo.abag[d], '?? bag:')
                for _,ind in pairs(geo.abag[d]) do
                    local v = cval['piece_rot'].verts[ind]+pos

        local apath = {}
        for i,d in pairs(apiece) do
            local fbag = geo.fbag[d]

            local fbag = geo.fbag[d]
            for i,fi in pairs(fbag) do
                apath[#apath+1] = {

        local aline = {}
        for i,geotgt in pairs(daedata.dgeo) do
            if i ~= env.ui['geo_up'] then

            aline = {aline[#aline]}
        for i,line in pairs(aline) do
            local c = (line.ab[1]+line.ab[2])/2

        local pos = amesh[env.ui['lod_up']].body:getPosition()
        for i,fi in pairs(fbag) do
            apath[#apath+1] = {

        if val == env.ui[key] or not editor.keyModifiers.ctrl then return end
        for i,m in pairs(amesh) do
--                lo('?? if_HIT:'..val..':'..i..':'..m.name..':'..daedata.alod[val].name)

                local dicon = {}
                for i,mod in pairs(amodel) do
                    local hit

                    local hit
                    for j,d in pairs(data.configs) do
                        if d.model_key == mod then

            dump(aveh, '?? aVEH:')
        for i,id in pairs(aveh) do
            scenetree.findObjectById(id):delete()

        local list = {}
        for i,f in pairs(fbag[val].list) do
            list[#list+1] = {m.verts[m.faces[f].v+1]+pos,m.verts[m.faces[f+1].v+1]+pos,m.verts[m.faces[f+2].v+1]+pos} -- [#av-0],av[#av-2],av[#av-1],av[#av-0]}

        local am = amesh[1].data
        for i,cm in pairs(am) do
            if cm.key == cgeo then

        local pos = amesh[1].body:getPosition()
        for i,f in pairs(flist) do
            av[#av+1] = m.verts[m.faces[f].v+1]+pos

        local am = {}
        for k,d in pairs(daedata.dgeo) do
            if k == cgeo then

                if val > 0 then
                    for i,k in pairs(geonode.apart) do
    --                    am[#am+1] = daedata.dgeo[k].m

            if val>0 then
                for _,k in pairs(geonode.apart) do
                    am[#am+1] = daedata.dgeo[k].m

        if not cval['DragPos'] then
            for k,d in pairs(daedata.dgeo) do
                if k == cgeo then

                            lo('?? for_POS:'..tostring(d.pos))
                        for i,p in pairs(cval['DragPos'].m.verts) do
                            cval['DragPos'].m.verts[i] = p - d.pos

        local am = {}
        for k,d in pairs(daedata.dgeo) do
            if k == cgeo then

            if k == cgeo then
                for i,p in pairs(cval['DragPos'].m.verts) do
                    d.pos = vec3(val,0,0)

        local am = {}
        for i,m in pairs(mesh.data) do
            local ds = sma*(i-(nm - 1)/2-1)

--[[
        for k,g in pairs(daedata.dgeo) do
            lo('?? for_geo:'..k)

--            local nm = daedata.dgeo[key].name
            for i,d in pairs(ajpart) do
                if d.sel then

            local p1,p2
            for i,d in pairs(daedata.ageo) do
                if d.key == ageopin[1] then

--                local apath = {}
                for i,b in pairs(abeam) do
    --                    lo('?? pp:'..i..':'..tostring(anode[b.av[1]].partOrigin)..':'..tostring(anode[b.av[2]].partOrigin))

                    lo('?? for_PART:')
                for i,b in pairs(abeam) do
                    if anode[b.av[1]].partOrigin == p1 or anode[b.av[2]].partOrigin == p1 then

            local cfr,cto = vec3(0,0.5,0.5),vec3(0,0,1)
            for i,b in pairs(list) do
                w,c,alpha =

            local nm = daedata.dgeo[key].name
            for i,d in pairs(ajpart) do
--                if d.sel then

]]
                for j,k in pairs(d.amesh) do
                    if k == nm then

                local list = {}
                for i,b in pairs(abeam) do
    --                    lo('?? foS:'..i..':'..b.stamp..'/'..'rb8r_rb8rr'..'<')

        if abeam then
            for i,b in pairs(abeam) do
                w,c,alpha =

        for i,d in pairs(daedata.ageo) do
            -- i ~= d.key since sorting

                    local mid,mad = math.huge,-math.huge
                    for i,b in pairs(d.abeam) do
                        if b.strength < math.huge and b.strength < mis then

                        lo('?? if_BEAMS:'..#d.abeam)
                for i,b in pairs(d.abeam) do
--                        w = b.strength == math.huge and 1 or (b.strength-beamdata.mis)/(beamdata.mas-beamdata.mis)

                for i,b in pairs(abeam) do
                        w = 2

        local item
        for i,d in pairs(daedata.ageo) do
            if d.key == val then

        local mi,ma=vec3(math.huge,math.huge,math.huge),vec3(-math.huge,-math.huge,-math.huge)
        for i,v in pairs(daedata.dgeo[val].m.verts) do
            if v.x < mi.x then

        if false then
            for k,d in pairs(daedata.dgeo) do
    --                k='Mesh_160-mesh'

                    if jnt then
                        for i,iv in pairs(jnt) do
                            astick[#astick+1] = daedata.dgeo[val].m.verts[iv]+pos

                        local bv = {}
                        for s,f in pairs(d.m.faces) do
                            bv[#bv+1] = d.m.verts[f.v+1]+pos

]]
        for i,m in pairs(am) do
            if m.key == cgeo then

        local pm = {}
        for i,flist in pairs(fbag) do
            pm[#pm+1] = deepcopy(am[idel])

--                dump(pm[#pm].faces, '?? list:'..i)
            for j,f in pairs(flist.list) do
--                    lo('?? fo_F:'..tostring(f))

            om:createMesh({})
            for i,m in pairs(am) do
                if m.key ~= cgeo then

        ageopin = {}
        for k,v in pairs(daedata.alod[val].list) do
--                dump(v.mat, '?? for_MAT2:'..v.mat.body)

--[[
        for k,d in pairs(dgeo) do
            daedata.ageo[#daedata.ageo+1] =

--[[
                for k,d in pairs(djpart['pickup_body'].abeam) do
                    local stamp = U.stamp({

            ajpart = {}
            for k,v in pairs(djpart) do
                ajpart[#ajpart+1] = v

                local po = {}
                for _,b in pairs(pvd.vdata.beams) do
--                    lo('?? for_beam:'..i..':'..tostring(b.partOrigin))

            end)
            for k,g in pairs(alod) do
--                alod[#alod+1] = {key=k,name=g.name or 'NONE',area=g.area,nface=g.nface}

                    local am = {}
                    for i,d in pairs(g.list) do
                        d.m.material = d.mat.nm

        daedata.ageo = {}
        for k,d in pairs(dgeo) do
            daedata.ageo[#daedata.ageo+1] =

                dump(pvd.vdata.nodes[1], '?? NODES_1:')
            for k,v in pairs(dbeam) do
                for _,d in pairs(daedata.ageo) do

            for k,v in pairs(dbeam) do
                for _,d in pairs(daedata.ageo) do
                    if string.find(d.name,k) == 1 then

                local po = {}
                for _,b in pairs(pvd.vdata.beams) do
--                    lo('?? for_beam:'..i..':'..tostring(b.partOrigin))

            local mi,ma = vec3(math.huge,math.huge,math.huge),-vec3(math.huge,math.huge,math.huge)
            for i,v in pairs(beamdata.anode) do
                if v.pos.x < mi.x then

            am = {}
            for k,d in pairs(dgeo) do
                am[#am+1] = d.m

        daedata.ageo = {}
        for k,d in pairs(dgeo) do
            daedata.ageo[#daedata.ageo+1] =

            local dbeam = M.forBeams(extensions.core_vehicle_manager.getPlayerVehicleData().vdata)
            for k,v in pairs(dbeam) do
                for _,d in pairs(daedata.ageo) do

            for k,v in pairs(dbeam) do
                for _,d in pairs(daedata.ageo) do
                    if string.find(d.name,k) == 1 then

                dump(aveh, '?? aVEH:')
            for i,id in pairs(aveh) do
                scenetree.findObjectById(id).hidden = false

            dump(aveh, '?? aVEH:')
        for i,id in pairs(aveh) do
            scenetree.findObjectById(id).hidden = true

        if true then
            for k,d in pairs(dgeo) do
                daedata.ageo[#daedata.ageo+1] = {key=k,name=d.name or 'NONE',area=d.area}

            local am = {}
            for k,d in pairs(dgeo) do
                am[#am+1] = d.m

		if M.valid(am) then
            for i,m in pairs(amesh) do
                local obj = scenetree.findObjectById(m.id)

                                if v.exp then
                                    for _,d in pairs(v.amesh) do
                                        im.TableNextColumn()

--                                im.SetCursorPosX(curx)
                                for k,v in pairs(geonode.astep) do
                                    if daedata.dgeo[v] then

                                        im.PushStyleColor2(im.Col_Text, im.ImVec4(0.6,1,0.9,0.9))
                                        for i,b in pairs(v.list) do
                                            im.TableNextColumn()

-------------------------
                                for k,v in pairs(geonode.apart) do
                                    im.Text(daedata.dgeo[v] and tostring(daedata.dgeo[v].name) or 'NONE')

                                    forParam()
--                                    for k,v in pairs(dparam) do
                                    for j,k in pairs({'strength','deform','spring','damp'}) do

--                                    for k,v in pairs(dparam) do
                                    for j,k in pairs({'strength','deform','spring','damp'}) do
                                        UI.sliderC(k,'in_'..k, {dparam[k]/2,

                                    if fbag then
                                        for i,b in pairs(fbag) do
                                            im.TableNextColumn()

--[[
                            for i,af in pairs(fbag) do
                                im.Text(''..#af)

                                if env.ui['geo_up'] then
                                    for i,d in pairs(daedata.dgeo[env.ui['geo_up'] ].abag) do
                                        im.Text('Piece '..i..' /'..#d..'/')

                        im.Columns(#bag4surf, "geoSurf", true)
                        for i,list in pairs(bag4surf) do
                            im.Text(toroman[i])

                            if im.BeginListBox(id, im.ImVec2(-1,-1)) then
                                for j,af in pairs(list) do
                                    im.PushItemWidth(200)

--                                lo('??***** PIN:'..tostring(inhover)..':'..#ageopin)
                        for c,d in pairs(daedata.dgeo) do
                            if (inhover and editor.keyModifiers.ctrl) or #ageopin>0 then

                        -- JOINTS
                        for c,d in pairs(daedata.dgeo) do
                            if djoint[c] then -- and inhover and inpanel~=1 then

                        if geonode.astep then
                            for _,k in pairs(geonode.astep) do
                                if _ == #geonode.astep then

    --                                lo('?? toPIN:'..tableSize(djoint))
                            for c,d in pairs(daedata.dgeo) do
                                if djoint[c] and c~=inhover then

                            if geonode.astep then
                                for _,k in pairs(geonode.astep) do
                                    if _ == #geonode.astep then

--                                lo('?? toPIN:'..tableSize(djoint))
                        for c,d in pairs(daedata.dgeo) do
                            if djoint[c] and c~=inhover then

                        if geonode.astep then
                            for _,k in pairs(geonode.astep) do
                                if _ == #geonode.astep then

                        im.SetColumnWidth(1, panelW-80)
                        for j,d in pairs(fsnode.afile) do
                            if j == fsnode.cfile then

        --                im.SetColumnWidth(2, 26)
                        for j,s in pairs(fsnode.astep) do
        --                for i=1,#fsnode.astep do

            local set = {}
            for i,b in pairs(beamdata.abeam) do
                local a,b =

            beamdata.agroup = {}
            for k,v in pairs(beamdata.opart.dgroup) do
                beamdata.agroup[#beamdata.agroup+1] = v

                local n = 0
                for _,k in pairs(cval['geo_drag'].akey) do
                    n = n + 1

                local am = {}
                for k,v in pairs(daedata.dgeo) do
                    am[#am+1] = v.m

                    ajpart = {}
                    for k,v in pairs(djpart) do
                        ajpart[#ajpart+1] = v

            local partname
            for i,d in pairs(ajpart) do
                for j,k in pairs(d.amesh) do

            for i,d in pairs(ajpart) do
                for j,k in pairs(d.amesh) do
                    if k == nm then

            local partname
            for i,p in pairs(ajpart) do
                if p.key == env.ui['jpart_pick'] then

    end
    for k,v in pairs(danim) do
        if v.cb then

            meshTarget = nil
            for c,d in pairs(daedata.dgeo) do
                d.mat.c[4] = _conf.alpha

                        local cm = vec3(0,0,0)
                        for _,v in pairs(daedata.dgeo[key].m.verts) do
                            cm = cm + v

--            local pos = amesh[1].body:getPosition()
            for i,d in pairs(daedata.ageo) do
                -- i ~= d.key since sorting

                        local mid,mad = math.huge,-math.huge
                        for i,b in pairs(d.abeam) do
                            if b.strength < math.huge and b.strength < mis then

                    U.out.agraph = {}
                    for i,b in pairs(d.abeam) do
--                        w = b.strength == math.huge and 1 or (b.strength-beamdata.mis)/(beamdata.mas-beamdata.mis)

                        lo('?? to_BR:'..#d.abeam)
                    for i,b in pairs(d.abeam) do
                        w = b.strength == math.huge and 1 or (b.strength-beamdata.mis)/(beamdata.mas-beamdata.mis)

                    U.out.agraph = {}
                    for i,b in pairs(d.abeam) do
                        U.out.agraph[#U.out.agraph+1] = {

--[[
                    for i,list in pairs(bag4surf) do
                        im.Text(toroman[i])

                    im.PushFont3("cairo_regular_medium")
                    for i,list in pairs(bag4surf) do
--                        im.Text(tostring(cgeo))

--                    im.NextColumn()
                    for i,list in pairs(bag4surf) do
                        im.Text('AAA')

                        if im.BeginListBox(id, im.ImVec2(-1,-1)) then
                            for j,af in pairs(list) do
                                im.Text(j)

                                im.Columns(#bag4surf, "geoSurf", true)
                                for i,list in pairs(bag4surf) do
                                    im.SameLine()

                                    lo('??***** PIN:'..tostring(inhover)..':'..#ageopin)
                            for c,d in pairs(daedata.dgeo) do
                                if (inhover and editor.keyModifiers.ctrl) or #ageopin>0 then

--                                lo('?? toPIN:'..tableSize(djoint))
                            for c,d in pairs(daedata.dgeo) do
                                if djoint[c] and c~=inhover then

                            inhover = false
                            for k,v in pairs(daedata.dgeo) do
                                color = im.ImVec4(0.8, 0.8, 0.8, 1) --U.index(ageopin,k)[1] and im.ImVec4(0.9, 0.2, 0.9, 1) or im.ImVec4(0.8, 0.8, 0.8, 1)

  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 or {}, pn.name) then

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

  -- Convert valid join groups to mesh attachment data.
  for joinName, joinGroup in pairs(joinGroups) do
    local points = joinGroup.points

      if not isPlaced[i] then
        for j, _ in pairs(isPlaced) do -- Iterate over all placed meshes.
          local placedMesh = rigids[j]

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

    for id, gr in pairs(self.mgr.garbageData.graphs) do self:computeStats(gr) gr.meta = {type = "graph", graph = self.mgr.graphs[id]} end
    for id, n  in pairs(self.mgr.garbageData.nodes) do self:computeStats(n) n.meta = {type = "node", node = self.mgr.graphs[n.graphId].nodes[id]} end

    for id, gr in pairs(self.mgr.garbageData.graphs) do self:computeStats(gr) gr.meta = {type = "graph", graph = self.mgr.graphs[id]} end
    for id, n  in pairs(self.mgr.garbageData.nodes) do self:computeStats(n) n.meta = {type = "node", node = self.mgr.graphs[n.graphId].nodes[id]} end

    }
    for _, gr in pairs(self.mgr.garbageData.graphs) do
      graphSum.total = graphSum.total + gr.total

    self.maxValue = 0
    for _, gr in pairs(self.mgr.garbageData.graphs) do self:setSortingValue(gr) end
    for _, n  in pairs(self.mgr.garbageData.nodes) do self:setSortingValue(n) end

    for _, gr in pairs(self.mgr.garbageData.graphs) do self:setSortingValue(gr) end
    for _, n  in pairs(self.mgr.garbageData.nodes) do self:setSortingValue(n) end
    self:setSortingValue(self.mgr.garbageData.graphSum)

  for name,variants in pairs(self.systemPacenotes) do
    for i,variant in ipairs(variants) do

  -- for _,spn in ipairs(self.path.static_pacenotes.sorted) do
  --   for lang,langData in pairs(spn.notes) do
  --     im.Text(spn.name)

      local rvcc = 0
      for rk, rv in pairs(rowValue) do
        --log('D', "jbeam.processTableWithSchema", "### "..header[rk].."//"..tostring(newRow[header[rk]]))

      local localColumnCount = 0
      for _, _ in pairs(data) do
        localColumnCount = localColumnCount + 1

      local i = 1
      for k, v in pairs(data) do
        if type(v) == "table" then

      for i = 1, #data, 1 do
        --k,v in pairs(data) do
        local v = data[i]

local updateStableIdIndexes = function(stableIdIndex, insertItem)
  for k, item in pairs(stableIdIndex) do
    if item.idx >= insertItem.idx then

  -- gcprobe() -- about 3000
  for percent, hit in pairs(event.cornerPercentHit) do
    -- gcprobe() -- a couple on first pass after full reset

  -- gcprobe() -- none
  for offset, hit in pairs(event.csMeterOffsetHit) do
    distOffset = offset

  -- gcprobe() -- needs attention
  for offset, hit in pairs(event.ceMeterOffsetHit) do
    local distOffset = offset

  local s = ""
  for k, v in pairs(t) do
    s = s .. tostring(k) .. "=" .. valToStr(v) .. " "

        local md = {}
        for k,v in pairs(point.metadata) do
          if type(v) == "table" then

  if self.pinIn.file.value then
    for name, pin in pairs(self.pinIn) do
      if name ~= 'flow' and name ~= 'reset' and name ~= 'file' then

  for ropeId, _ in pairs(perfStats.ropeSimTimes) do
    if not activeRopeIds[ropeId] then

    local configCount = 0
    for _,vdir in pairs(vehicles) do
      --do we have a vehicle that is known to fail on spawning?

      if #configs == 0 then goto skipme end
      for _,config in pairs(configs) do
          io.write("\tresaving config " .. config .. "\n")

    local added = false
    for name, pin in pairs(self.pinIn) do
      if not pin.fixed then

  local max, n = 0, 0
  for k, _ in pairs(array) do
    if not (type(k) == "number" and k > 0 and math_floor(k) == k) then

  local sum = 0.0
  for _, v in pairs(t) do
    sum = sum + v

  local setup = deepcopy(gameplay_missions_missions.getMissionProgressSetupData(self.missionType))
  for k, v in pairs(setup) do
  --  self[k] = v

  end
  for name, value in pairs(self.progressVariables) do
    if self.progress[name] ~= nil then

  end
  for name, value in pairs(variables or {}) do
    if self.progressVariables[name] ~= nil then

    for k, v in pairs(self.oneOffVariables or {}) do
      tempVariables[k] = v

  -- setup existing progress variables.
  for name, v in pairs(self.progressVariables or {}) do
    local value = v

  if self.userSettings then
    for name, value in pairs(self.userSettings) do
      if self:addOrSetVariable(name, value) then

function C:retrieveProgressFromFlowgraph()
  for name,_ in pairs(self.progressVariables or {}) do
    local value, exists = self.mgr.variables:get(name)

  table.clear(results)
  for id, btn in pairs(byId) do
    table.insert(results, btn)

  o:init()
  for k, v in pairs(derivedClass) do
    o[k] = v

    local data = {}
    for vk,vs in pairs(data_ref) do
        data[vk] = {}

        -- for nodeid, beamnid
        for _,vv in pairs(vs) do
            data[vk][vv.cid] = {}

            data[vk][vv.cid] = {}
            for vk,vi in pairs(vv) do
                if whitelist[vk] then

    local tris = {}
    for k, s in pairs(v.data.beams) do
        if not s.wheelID then

    end
    for k, s in pairs(v.data.nodes) do
        if not s.wheelTreadBeamDeform then

    end
    for k, s in pairs(v.data.triangles) do
        if s.cid then

  for k, v in pairs(storage.fuelNodes) do
    obj:setNodeMass(k, v + storage.storedEnergy * storage.fuelNodeMassCoef)

  --apply final weight as soon as possible
  for k, v in pairs(storage.fuelNodes) do
    obj:setNodeMass(k, v + storage.storedEnergy * storage.fuelNodeMassCoef)

  if jbeamData.fuel and jbeamData.fuel._engineGroup_nodes then
    for _, n in pairs(jbeamData.fuel._engineGroup_nodes) do
      storage.fuelNodes[n] = v.data.nodes[n].nodeWeight --save initial mass as the offset for the fuel node weights

  --apply final weight as soon as possible
  for k, v in pairs(storage.fuelNodes) do
    obj:setNodeMass(k, v + storage.storedEnergy * storage.fuelNodeMassCoef)

  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"

  --Add the locations to the cars so we can keep track
  for _,car in pairs(self.mgr._fgTutoTestCarsStep.carsData) do
    car.locationsLeft = {1,2,3}

  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

  local reverseGears = {}
  for _, v in pairs(jbeamData.gearRatios) do
    table.insert(v >= 0 and forwardGears or reverseGears, v)

    local gearIndex = device.minGearIndex
    for _, v in pairs(gearWhineCoefsOutput) do
      device.gearWhineCoefsOutput[gearIndex] = v

    local gearIndex = device.minGearIndex
    for _, v in pairs(gearWhineCoefsInput) do
      device.gearWhineCoefsInput[gearIndex] = v

  meshPools[splineId] = meshPools[splineId] or {}
  for meshPath, neededCount in pairs(neededMeshes) do
    meshPools[splineId][meshPath] = meshPools[splineId][meshPath] or {}

  -- Delete meshes for paths that are no longer needed.
  for meshPath, pathPool in pairs(meshPools[splineId]) do
    if not neededMeshes[meshPath] then

  -- Clear the existing meshes by path table for reuse.
  for path, meshList in pairs(existingMeshesByPath) do
    table.clear(meshList)

  table.clear(counters)
  for meshPath, _ in pairs(neededMeshes) do
    counters[meshPath] = 1

  if meshPools[splineId] then
    for _, pathPool in pairs(meshPools[splineId]) do
      for i = #pathPool, 1, -1 do

  if editor.isWindowVisible(toolWindowName) then
    for _, fn in pairs(onEditorGuiFunctions) do
      fn()

  for _, onUpdateFn in pairs(editorOnUpdateFunctions) do
    onUpdateFn(dtReal, dtSim, dtRaw)

  if not selectedLayers then return end
  for uid, layer in pairs(selectedLayers) do
    editor.selection["dynamicDecalLayer"][uid] = deepcopy(api.getLayerByUid(uid))

  if not selectedLayers then return end
  for uid, layer in pairs(selectedLayers) do
    editor.selection["dynamicDecalLayer"][uid] = deepcopy(api.getLayerByUid(uid))

  -- Find highest predefined order
  for _, config in pairs(pageConfig) do
    if config.order > nextOrder then

    if element.pages then
      for pageName, enabled in pairs(element.pages) do
        if not career_career.isActive() and pageConfig[pageName].hideInCareer then

  local unflattenedSettings = {}
  for k, v in pairs(mission.lastUserSettings) do
    table.insert(unflattenedSettings, {key = k, value = v})

  local perfStatsRows = {}
  for _, statData in pairs(driftStats.perfStats) do
    table.insert(perfStatsRows, {

  local totalTiersScore = 0
  for _, statData in pairs(driftStats.tiersStats) do
    totalTiersScore = totalTiersScore + statData.totalScore

  local totalDriftEventsScore = 0
  for _, eventData in pairs(driftStats.driftEvents) do
    totalDriftEventsScore = totalDriftEventsScore + eventData.totalScoreEarned

    local i = 0
    for k,v in pairs(icons) do
      if imgui.ImGuiTextFilter_PassFilter(filter, v) then

  -- build grouping data on cards
  for id, card in pairs(cardsById) do
    local groupTags = {}

  -- build group lists (new groups might have been added)
  for key, group in pairs(groupsByKey) do
    group.cardIdsUnsorted = {}

  -- add card ids to groups
  for id, card in pairs(cardsById) do
    for groupKey, _ in pairs(card.groupTags) do

  for id, card in pairs(cardsById) do
    for groupKey, _ in pairs(card.groupTags) do
      table.insert(groupsByKey[groupKey].cardIdsUnsorted, id)

      table.insert(groupsByKey[groupKey].cardIdsUnsorted, id)
      for filterKey, _ in pairs(card.filterTags) do
        groupsByKey[groupKey].filterTags[filterKey] = true

    end
    for filterKey, _ in pairs(card.filterTags) do
      if not usePlayerCards then

  local destinationGroups = {}
  for key, group in pairs(groupsByKey) do
    if key ~= "destination_noDestination" and key:startswith('destination_') then

    local taskGroups = {}
    for key, group in pairs(groupsByKey) do
      if key:startswith('task_') then

  local idx = 1
  for _, card in pairs(cardsById) do
    card.sortValues = {}

  -- give the groups in the groupsets the sorting values.
  for _, groupSet in pairs(groupSets) do
    for _, group in ipairs(groupSet.groups) do

  local itemCount = 0
  for _, card in pairs(cardsById) do
    if card.isPlayerCard and

    if s.tsVar then
      for k, v in pairs(s) do
        if k ~= 'settings' then

local function setMultiSettings(keyvars)
  for key, var in pairs(keyvars or {}) do
    setSetting(key, var)

  local baseInit = o.init
  for k, v in pairs(derivedClass) do
    o[k] = v

local function updateGFX(dtSim)
  for sensorId, _ in pairs(advancedIMUs) do
    updateAdvancedIMUGFXStep(dtSim, sensorId, false, nil)

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

  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)

  local withWheels = not withoutWheels
  for _, n in pairs(v.data.nodes) do
    local cid = n.cid

  local cidList = {}
  for _, n in pairs(v.data.nodes) do
    if n.name then

  playmodeKd = nil
  for _, marker in pairs(markersByClusterId) do
    marker:clearObjects()

  local poisByMarkerType = {}
  for markerType, _ in pairs(playmodeMarkerTypeNames) do
    poisByMarkerType[markerType] = {}

  -- let each markertype cluster their own markers in their own way
  for markerType, _ in pairs(playmodeMarkerTypeNames) do
    local factory = require('lua/ge/extensions/gameplay/markers/'..markerType)

  end
  for k,v in pairs(timelineEvents) do
    gameplay_statistic.callbackRegister(k, false, statCbTimeline)

  end
  for k,v in pairs(timelineEvents) do
    gameplay_statistic.callbackRemove(k, false, statCbTimeline)

  M.richPresenceEnabled = enabled
  for k, v in pairs(toggleableFunctions) do
    M[k] = enabled and v or nop

local function _convertTableSchema(fileRoot)
  for _, partRoot in pairs(fileRoot) do
    if type(partRoot) == 'table' then

    end
    for k, v in pairs(node) do
      _cleanupData(v)

  table.clear(axes[5])
  for k, ribbonIdx in pairs(nearList) do
    local ribbon = ribbons[ribbonIdx]

  for i = 1, 5 do
    for _, sfxEmitterOnAxis in pairs(sfxEmitters[i]) do
      sfxEmitterOnAxis.vol = 0.0

    local axis = axes[i]
    for eventName, event in pairs(axis) do
      if sfxEmitters[i][eventName] == nil then

  for i = 1, 5 do
    for _, sfxEmitterOnAxis in pairs(sfxEmitters[i]) do
      if simObjectExists(sfxEmitterOnAxis.emitter) then

  for i = 1, 5 do
    for _, sfxEmitterByAxis in pairs(sfxEmitters[i]) do
      if sfxEmitterByAxis.emitter and simObjectExists(sfxEmitterByAxis.emitter) then

    local alib = {}
    for _,p in pairs(apth) do
        unrequire(p)

    aed = {}
    for i,d in pairs(aax) do
        dedge[#dedge+1] = U.stamp({d[1][2],d[2][2]})

    for i=1,#aa do
--    for i,a in pairs(ac) do
--            U.dump(avp,'??----------- NEXT:'..i..':'..aind[i])

        for i=1,(cvneigh and #dedge or #dedge-2) do
--        for i,s in pairs(dedge) do
            local ab = U.split(dedge[i], '_')

        end
--        for i,d in pairs(aax) do
--            elist[#elist+1] = {d[1][1],d[2][1]}

--        dedge = {U.stamp({1,2})}
        for i,d in pairs(aax) do
            dedge[#dedge+1] = U.stamp({d[1][2],d[2][2]})

            local ai2 = U.split(dedge[i],'_')
            for _,ind in pairs(ai2) do
                if de[ind] then

                if not cvover then
                    for i,d in pairs(segpick) do
                        if d.on then

                            dedge = {}
                            for i,d in pairs(aax) do
                                dedge[#dedge+1] = U.stamp({d[1][2],d[2][2]})

            local amil,amir,vmil,vmir = math.huge,math.huge
            for i,v in pairs(m.verts) do
                local ang = U.vang(U.proj2D(v-campos),U.proj2D(tocur-campos),true)

                -- check side hit
                for i,d in pairs(segpick) do
                    d.on = nil

            local hit
            for i,v in pairs(m.verts) do
                local ang = U.vang(v-campos,tocur-campos)

            if not cvover then
                for i,d in pairs(segpick) do
                    if d.on then

                        dedge = {}
                        for i,d in pairs(aax) do
                            dedge[#dedge+1] = U.stamp({d[1][2],d[2][2]})

--------------------------
    for i,d in pairs(danim) do
        if d.cb then

            local ami1,ami2,vmi1,vmi2
            for i,v in pairs(m.verts) do
                local ang = U.vang(v-campos,tocur-campos)

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)

    self:_executionStopped()
    for _, p in pairs(self.pinOut) do p.value = nil end
  end

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

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

  local RL2 = 0
  for _, n in pairs(v.data.nodes) do
    if n.cid == frontRightWheel.node1 then

    allCategories = {}
    for name, info in pairs(allActions) do
      allCategories[info.cat] = allCategories[info.cat] or {}

    --  self.search:setSameScoreResolvingFunction(sortFun)
    for name, info in pairs(allActions) do
      self.search:queryElement({

    self.list = {}
    for k, v in pairs(listKeys) do
      if v then

  local i = 1
  for l, pin in pairs(self.pinIn) do
    if pin.value and type(pin.value) == "number" then

  local i = 0
  for l, pin in pairs(self.pinInLocal) do
    if pin.type == "number" and self.pinIn[l].value then

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

  local activeGroups = {}
  for groupKey, isVisible in pairs(groupVisibilityState) do
    if isVisible then

  local allGroups = {}
  for groupKey, _ in pairs(groupVisibilityState) do
    table.insert(allGroups, groupKey)

M.resetAllGroupsToVisible = function()
  for groupKey, _ in pairs(groupVisibilityState) do
    groupVisibilityState[groupKey] = true

    for key, val in pairs(gameplay_missions_progress.formatSaveDataForBigmap(mission.id) or {}) do
      ret[key] = val

  for _, diff in pairs(gameplay_missions_missions.getAdditionalAttributes().difficulty.valuesByKey) do
    groupData["difficulty_"..diff.key] = {label = "Difficulty: " ..diff.translationKey}

  end
  for _, v in pairs(gameplay_missions_missions.getAdditionalAttributes().vehicle.valuesByKey) do
    groupData["vehicleUsed_"..v.key] = {label = "Vehicle Used: " .. v.translationKey}

  for groupKey, gr in pairs(groupData) do
    gr.elements = {}

      for tag, act in pairs(filterData.groupTags) do
        if act then

  -- Sort elements in each group
  for key, gr in pairs(groupData) do
    local elementsAsPois = {}

  if cachedGroupData then
    for groupKey, gr in pairs(cachedGroupData) do
      gr.visible = M.getGroupVisibility(groupKey)

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

    for _, wd in pairs(wheels.wheels) do
      local pressureGroupID = v.data.pressureGroups[wd.pressureGroup]

        for _, nid in pairs(wd.treadNodes or {}) do
          obj.debugDrawProxy:drawNodeSphere(nid, 0.02, ironbowColor((obj:getNodeTemperature(nid) - baseTemp) * 0.004))

        end
        for _, nid in pairs(wd.nodes or {}) do
          obj.debugDrawProxy:drawNodeSphere(nid, 0.02, ironbowColor((obj:getNodeTemperature(nid) - baseTemp) * 0.004))

    M.nodeCollision = nodeCollision
    for _, c in pairs(wheelContacts) do
      obj.debugDrawProxy:drawSphere(0.02, (c.contactPoint / c.totalForce), color(255, 0, 0, 255))

    for nodeCID, data in pairs(M.state.vehicle.nodeDebugTextModes[modeID].data) do
      local nodePos = obj:getAbsNodePosition(nodeCID)

    initRenderNodeTexts(partsSelected, showWheels)
    for groupID, entries in pairs(groupIDToEntries) do
      local text = ''

    initRenderNodeTexts(partsSelected, showWheels)
    for groupID, entries in pairs(groupIDToEntries) do
      local text = ''

    initRenderNodeTexts(partsSelected, showWheels)
    for groupID, entries in pairs(groupIDToEntries) do
      local text = ''

    initRenderNodeTexts(partsSelected, showWheels)
    for groupID, entries in pairs(groupIDToEntries) do
      local text = ''

    initRenderNodeTexts(partsSelected, showWheels)
    for groupID, entries in pairs(groupIDToEntries) do
      local text = ''

    initRenderNodeTexts(partsSelected, showWheels)
    for groupID, entries in pairs(groupIDToEntries) do
      local text = ''

          local k = 1
          for _,v in pairs(node.group) do
            txt = txt .. v

    initRenderNodeTexts(partsSelected, showWheels)
    for groupID, entries in pairs(groupIDToEntries) do
      local text = ''

    initRenderNodeTexts(partsSelected, showWheels)
    for groupID, entries in pairs(groupIDToEntries) do
      local text = ''

    tempVec:set(obj:getPositionXYZ())
    for groupID, entries in pairs(groupIDToEntries) do
      local text = ''

    initRenderBeamTexts(partsSelected, showWheels)
    for groupID, entries in pairs(groupIDToEntries) do
      local text = ''

    initRenderBeamTexts(partsSelected, showWheels)
    for groupID, entries in pairs(groupIDToEntries) do
      local text = ''

    initRenderBeamTexts(partsSelected, showWheels)
    for groupID, entries in pairs(groupIDToEntries) do
      local text = ''

          local breakGroups = type(beam.breakGroup) == "table" and beam.breakGroup or {beam.breakGroup}
          for _, g in pairs(breakGroups) do
            if not groupsData[g] then

    end
    for g, groupData in pairs(groupsData) do
      local groupPos = groupData[2]

          local deformGroups = type(beam.deformGroup) == "table" and beam.deformGroup or {beam.deformGroup}
          for _, g in pairs(deformGroups) do
            if not groupsData[g] then

    end
    for g, groupData in pairs(groupsData) do
      local groupPos = groupData[2]

    local ampScaler = 1 / ampMax
    for beamID, energy in pairs(beamFreqModeAmp) do
      local a = min(255, energy * ampScaler * 255 * alpha)

    -- Find beams between t nodes
    for name, rail in pairs(v.data.rails or {}) do
      if name ~= 'cids' then

  if modeID == 2 then
    for name, rail in pairs(v.data.rails or {}) do
      if name ~= 'cids' then

  elseif modeID == 3 or modeID == 4 or modeID == 5 then
    for name, rail in pairs(v.data.rails or {}) do
      if name ~= 'cids' then

  M.debugDraw = nop
  for k, v in pairs(M.state.vehicle) do
    if type(v) ~= "table" and v ~= M.initState.vehicle[k] and M.state.vehicleDebugVisible then

  M.state.vehicle = M.state.vehicle or deepcopy(M.initState.vehicle)
  for k, v in pairs(M.state.vehicle) do
    if type(v) ~= "table" and v ~= M.initState.vehicle[k] then

    for name, pin in pairs(self.pinOut) do
      if name ~= 'flow' and not pin.fixed then

      self.configs = {}
      for k, v in pairs(modelData.configs) do
        table.insert(self.configs, v)

  local context = {}
  for key, value in pairs(data) do
    if type(value) == 'string' or type(value) == 'number' then

      local unflattenedSettings = {}
      for k, v in pairs(mission.lastUserSettings) do
        table.insert(unflattenedSettings, {key = k, value = v})

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

  self.mgr._fgTutoTestCarsStep.getCarBySortedId = function(id)
    for _,car in pairs(self.mgr._fgTutoTestCarsStep.carsData) do
      if car.id == id then return car end

  local autoModulesSize = 0
  for k, m in pairs(luaMods) do
    if m.__manuallyLoaded__ then

      log('W', logTag, 'Unloading the following modules. Their dependencies could not be resolved:')
      for k, v in pairs(failedModules) do
        log('W', logTag, '    ' .. tostring(k) .. ' dependencies not resolved: '..dumps(v))

  -- nop the function cache so that existing hook iterations do not get invalidated as they are used
  for fName, fList in pairs(luaExtensionFuncs) do
    for i, _ in ipairs(fList) do

  if #{...} > 1 then
    for k,array in pairs({...}) do
      for i, v in pairs(array) do

    for k,array in pairs({...}) do
      for i, v in pairs(array) do
        table.insert(exceptionList, v)

    if deprecatedExtensions then
      for name,data in pairs(deprecatedExtensions) do
        if type(m[name]) == 'function' then

  for j, m in ipairs(resolvedModules) do
    for name, value in pairs(m) do
      if type(value) == "function" and name ~= "wrapAllExtensions" then

local function extSafetyCheck(m, extName, extPath)
  for k, v in pairs(m) do
    if type(v) == 'function' then

  if profileAllExtensionFunctions then
    for memberName, member in pairs(m) do
      if type(member) == "function" then

  local luaFiles = FS:findFiles(directory, '*.lua', -1, true, false)
  for _,luaFilename in pairs(luaFiles) do
    load(luaFilename:sub(1,-5))  -- strip '.lua'

      local skip = false
      for _,subDir in pairs(excludeSubdirectories) do
        if string.find(file, subDir) then

  local loadedModules = {}
  for k, m in pairs(luaMods) do
    local ignoreExtension = tableContains(doNotSerializeModules, m.__extensionName__)

    local extbatch = {}
    for extName,extPath in pairs(extensionsData.loadedModules) do
      local tempExtName = luaPathToExtName(extPath)

    if not m then return end
    for k, func in pairs(m) do
      if string.sub(k, 1, 2) == 'on' and type(func) == 'function' then

  local hookLists = {}
  for _, m in pairs(hookableTablesInstances) do
    walkTable(hookLists, m, m)

  self.hookProxies = {}
  for k, sinkList in pairs(hookLists) do
    self.hookProxies[k] = function(...)

    self.hookProxies[k] = function(...)
      for _, m in pairs(sinkList) do
        m[k](m, ...)

  local loadedNames = {}
  for k, data in pairs(luaMods) do
    if not excludeVirtual or not data.__virtual__ then

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

  multiPaintSetupsByIdCache = {}
  for _, paintFilePath in pairs(core_vehicles.getPaintFiles()) do
    local paintFile = core_vehicles.getFilesParsed()[paintFilePath]

    for id, paint in pairs(paintFile.paints or {}) do
      paint.sources = nil

    end
    for id, collection in pairs(paintFile.collections or {}) do
      for _, paintName in pairs(collection.paints) do

    for id, collection in pairs(paintFile.collections or {}) do
      for _, paintName in pairs(collection.paints) do
        paintCollectionsByIdCache[id] = collection

    end
    for id, setup in pairs(paintFile.multiPaintSetups or {}) do
      multiPaintSetupsByIdCache[id] = setup

  end
  for cId, collection in pairs(paintCollectionsByIdCache) do
    local cleanCollection = {}

    local cleanCollection = {}
    for pId, paint in pairs(collection.paints) do
      if type(paint) == 'string' then paint = {id = paint} end

  end
  for id, paint in pairs(paintsByIdCache) do
    paint.id = id

  local multiNames = 0
  for name, paints in pairs(paintsByNameAsListCache) do
    if #paints > 1 then

  -- add names to old paint format
  for name, paint in pairs(model.paints) do
    paint.name = name

  -- convert paint names from library to actual paint data
  for _, paint in pairs(model.libraryPaints or {}) do
    if type(paint) == 'string' then paint = {id = paint} end

  -- convert paint collections to actual paint data
  for _, collectionId in pairs(model.paintCollections or {}) do
    local collection = getPaintCollectionById(collectionId)

    if collection then
      for _, paint in pairs(collection) do
        debugLog("adding paint from model.paintCollections to model: " .. dumps(paint.id) .. "/" .. dumps(paint.name) .. " (from collection " .. dumps(collectionId) .. ")")

  -- process all the setups already in the model
  for _, multiPaintSetup in pairs(multiPaintSetupsToProcess) do
    local multiPaintSetupWithNames = resolveMultiPaintSetupHelper(model, multiPaintSetup, paintIdsToPaintNames, multiPaintSetupsByIdOrName)

  -- process configs
  for _, config in pairs(configs) do
    debugConfigKey = config.key

  -- validate paints and set up factory and custom paints lists
  for _, paint in pairs(model.paints) do
    if not paint.class then

  model.customPaintNames = {}
  for _, paint in pairs(model.paints) do
    if paint.class == 'factory' then

  local newRandomPaintDistributionModel = {}
  for paintNameOrId, probability in pairs(model.randomPaintDistribution) do
    local paint = model.paints[paintNameOrId]

  -- then add all the remaining paint names with 1 probability
  for paintName, _ in pairs(model.paints) do
    newRandomPaintDistributionModel[paintName] = newRandomPaintDistributionModel[paintName] or defaultRandomPaintProbability

  local newRandomMultiPaintDistributionModel = {}
  for multiPaintSetupNameOrId, probability in pairs(model.randomMultiPaintDistribution) do
    local multiPaintSetup = multiPaintSetupsByName[multiPaintSetupNameOrId]

  local allPaintResults = {}
  for paintName, probability in pairs(newRandomPaintDistributionModel) do
    totalProbability = totalProbability + probability

  end
  for multiPaintSetupName, probability in pairs(newRandomMultiPaintDistributionModel) do
    totalProbability = totalProbability + probability

    debugLog("model " .. dumps(key) .. " has " .. #allPaintResults .. " paint results with total probability " .. totalProbability)
    for _, paintResult in pairs(allPaintResults) do
      debugLog("paint result: " .. dumps(paintResult.type) .. ", " .. dumps(paintResult.paintName1) .. ", " .. dumps(paintResult.paintName2) .. ", " .. dumps(paintResult.paintName3) .. ", probability: " .. dumps(paintResult.probability))

  -- now do the same for each config
  for _, config in pairs(configs) do
    debugConfigKey = config.key

    local newRandomPaintDistributionConfig = {}
    for paintNameOrId, probability in pairs(config.randomPaintDistribution or {}) do
      local paint = model.paints[paintNameOrId]

    if not config.ignoreModelRandomPaintDistribution then
      for paintName, probability in pairs(newRandomPaintDistributionModel) do
        newRandomPaintDistributionConfig[paintName] = newRandomPaintDistributionConfig[paintName] or newRandomPaintDistributionModel[paintName] or probability

    -- then add all the remaining paint names with 1 probability
    for paintName, _ in pairs(model.paints) do
      newRandomPaintDistributionConfig[paintName] = newRandomPaintDistributionConfig[paintName] or defaultRandomPaintProbability

    local newRandomMultiPaintDistributionConfig = {}
    for multiPaintSetupNameOrId, probability in pairs(config.randomMultiPaintDistribution or {}) do
      local multiPaintSetup = multiPaintSetupsByName[multiPaintSetupNameOrId]

    if not config.ignoreModelRandomMultiPaintDistribution then
      for multiPaintSetupName, probability in pairs(newRandomMultiPaintDistributionConfig) do
        newRandomMultiPaintDistributionConfig[multiPaintSetupName] = newRandomMultiPaintDistributionModel[multiPaintSetupName] or probability

    local allPaintResults = {}
    for paintName, probability in pairs(newRandomPaintDistributionConfig) do
      totalProbability = totalProbability + probability

    end
    for multiPaintSetupName, probability in pairs(newRandomMultiPaintDistributionConfig) do
      totalProbability = totalProbability + probability

      debugLog("config " .. dumps(config.key) .. " has " .. #allPaintResults .. " paint results with total probability " .. totalProbability)
      for _, paintResult in pairs(allPaintResults) do
        debugLog("paint result: " .. dumps(paintResult.type) .. ", " .. dumps(paintResult.paintName1) .. ", " .. dumps(paintResult.paintName2) .. ", " .. dumps(paintResult.paintName3) .. ", probability: " .. dumps(paintResult.probability))

  local sortedResults = {}
  for name, count in pairs(resultsByName) do
    table.insert(sortedResults, {name = name, count = count})

      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 widthCubics = {}
    for key, _ in pairs(laneKeys) do
      local k = laneKeys[key]

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

    for name, pin in pairs(self.pinOut) do
      if not pin.fixed then

    self.pinOut.nodeName.value = nil
    for name, pin in pairs(self.pinOut) do
      if not pin.fixed then pin.value = nil end

  flashingLEDsOff = {}
  for _, v in pairs(jbeamData.flashingOutputElectrics or {}) do
    table.insert(flashingLEDsOn, v)

  end
  for _, v in pairs(jbeamData.flashingAlternateOutputElectrics or {}) do
    table.insert(flashingLEDsOff, v)

        local wps = {}
        for _, m in pairs(self.minimapMarkers) do
          m.mode = 'hidden'

        if self.pinIn.ignoreRecovery.value then
          for k, v in pairs(wps) do
            if v == 'recovery' then

  --if not self.pinIn.raceData.value then return end
  for _, m in pairs(self.minimapMarkers or {}) do
    local clr = m.color

    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)

  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

  for _, event in pairs(eventsList) do
    local entry = {name = event.eventName, score = 1}

  local t, n = {}, 0
  for k in pairs(count1) do
    n = n + 1

  local ms = 0
  for k, v in pairs(count1) do
    local pct = floor(v*100/samples + 0.5)

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

  for _, node in pairs(self.path.pathnodes.objects) do
    node._drawMode = (id == node.id) and 'highlight' or 'normal'

  local closestNode = nil
  for idx, node in pairs(self.path.pathnodes.objects) do
    if node.pos then

  for idx, node in pairs(self.path.pathnodes.objects) do
    if node.pos then

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

local function onSaveCurrentSaveSlot(currentSavePath)
  for id, trail in pairs(M.getPlayerCrawlTrailsById()) do
    if trail._dirty then

local function fuzzyTableLookup(d, n)
  for k, v in pairs(d) do
    if string.find(string.lower(k), string.lower(n)) ~= nil then

  for k, v in pairs(outParts) do
    local data = fuzzyTableLookup(parts, k)

  for k, v in pairs(outParts) do
    if ret[k] == nil then

  for part, v in pairs(parts) do
    local partEntry = {}

  for k, v in pairs(params) do
    vehicles[id][k] = v[1][0]

  if not id or not vehicles[id] then return end
  for k, v in pairs(params) do
    v[1][0] = vehicles[id][k]

        local pos, rot = firstVeh:getPosition(), firstVeh:getRotation()
        for k, v in pairs(vehicles) do
          getObjectByID(k):setPosRot(pos.x, pos.y, pos.z, rot.x, rot.y, rot.z, rot.w)

        for k, v in pairs(vehicles) do
          local obj = getObjectByID(k)

          local aiParams = {}
          for key, _ in pairs(params) do
            aiParams[key] = v[key]

      if im.Button("Stop##aiParams") then
        for k, v in pairs(vehicles) do
          getObjectByID(k):queueLuaCommand("ai.setMode('stop')")

    if im.Button("Reset##aiParams") then
      for k, v in pairs(vehicles) do
        getObjectByID(k):setPosRot(v.pos.x, v.pos.y, v.pos.z, v.rot.x, v.rot.y, v.rot.z, v.rot.w)

    if im.Button("Reload##aiParams") then
      for k, v in pairs(vehicles) do
        getObjectByID(k):reload()

  local fcts = {}
  for k,v in pairs(timings_tmp) do
    if calls_tmp[k] > 0 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 num = 0
  for _, _ in pairs(tbl) do num = num + 1 end
  return num

local function mergeTable(dst, src)
  for k, v in pairs(src) do
    if not dst[k] then  dst[k] = src[k] end

local function overwriteTable(dst, src)
  for k, v in pairs(src) do
    dst[k] = src[k]

  local ret = {}
  for k, v in pairs(tbl) do
    local nk = string.gsub(k, "_", "-")

local function processPropertyValues(tbl, run)
  for k,v in pairs(tbl) do
    if serializableValue(k, v) then

  if not run.preflight then
    for k,v in pairs(tbl) do
      if serializableValue(k, v) then

    for k,v in pairs(tbl["__style"]) do
      if serializableValue(k, v) then

  for k, v in pairs(tbl["__functions"]) do
    if serializableValue(k, v) then

      local func = ""
      for i, vv in pairs(v) do
        if i == 1 then func = string.format("%s%s(", func, vv)

    local stringTable = {}
    for k, v in pairs(tbl) do
      if serializableValue(k, v) then

  else
    for _, v in pairs(EzSVG.styles) do
      v[key] = value

  EzSVG.styles = {}
  for _, v in pairs(EzSVG.knownTags) do
    EzSVG.styles[v] = {}

  local style = {}
  for k, v in pairs(EzSVG.styles) do
    style[k] = {}

    style[k] = {}
    for kk, vv in pairs(v) do
      style[k][kk] = vv

    tag = value -- promote
    for k, v in pairs(key) do
      setDefaultStyles(k, v, tag)

      local seperator = ""
      for k, v in pairs(tbl["__d"]) do
        if serializableValue(k, v) then

    local i = 0
    for _, v in pairs(tbl["__points"]) do
      if i ~= 0 then

    -- Put referenced objects not in the tree to 
    for _, v in pairs(preflightRun["referencedObjects"]) do
      if v["lastRunID"] ~= preflightRun["id"] then

	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)

    if attr then
        for k, v in pairs(attr) do
            if type(k) == "number" then

  local fields = mat:getFields() or {}
  for k, v in pairs(fields) do
    if v.type == "filename" then

  for k, f in pairs(fields) do
    if f.type == "filename" then

  local rows = {}
  for mesh, count in pairs(usageByMesh) do
    table.insert(rows, { mesh = mesh, count = count })

  local forestRows = {}
  for mesh, count in pairs(forestUsageByShape) do
    table.insert(forestRows, { mesh = mesh, count = count })

  table.sort(sortedTags, sortFunc)
  for tagName, materials in pairs(tags) do
    table.sort(materials, sortFunc)

      for mat, _ in pairs(tbl) do
        if mat ~= "" then

      for mat, _ in pairs(tbl) do
        table.insert(materialObjectNames, mat)

  for k, v in pairs(materialObjectNames) do
    if im.ImGuiTextFilter_PassFilter(matFilter, v) and v then

  local i = 0
  for k, val in pairs(sortedMaterialObjectNamesAtTop) do
    local mat = scenetree.findObject(val)

  end
  for k, val in pairs(sortedMaterialObjectNames) do
    local mat = scenetree.findObject(val)

local function saveAllDirtyMaterials()
  for matName, _ in pairs(v.dirtyMaterials) do
    local mat = scenetree.findObject(matName)

  local field = currentMaterial:getField(property, layer)
  for k, v in pairs(items) do
    if v == field then

  else
    for k, v in pairs(items) do
      if v == translucentBlendOp then

      local files = {}
      for k,v in pairs(currentMaterial:getFields()) do
        if v.type == "filename" then

          local tooltipMsg = "Save all dirty materials:\n"
          for k,v in pairs(v.dirtyMaterials) do
            tooltipMsg = tooltipMsg .. "* " .. k .. "\n"

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

  if mapData and mapData.nodes then
    for _, node in pairs(mapData.nodes) do
      if node.pos:length() < 1e14 then

    local partCounter = 0
    for partName, part in pairs(data) do
      parts[partName] = {}

  -- walk all file caches to build the global caches together
  for filename, cacheData in pairs(fileCache) do
    --dumpz({"cacheData: ", cacheData}, 8)

    --dumpz({"cacheData: ", cacheData}, 8)
    for partName, partData in pairs(cacheData.parts) do
      for _, slotType in ipairs(partData.slotTypes) do

    -- merge manually to catch errors
    for partName, partDesc in pairs(partNameMap[dir]) do
      if res[partName] then

    -- merge manually to catch errors
    for slotName, partList in pairs(partSlotMap[dir]) do
      if not res[slotName] then res[slotName], slotsPartMap[slotName] = {}, {} end

local function updateSimpleControlButtons()
  for _, buttonData in pairs(simpleControlButtons) do
    updateSimpleControlButton(buttonData)

local function updateGFX(dt)
  for _, buttonData in pairs(simpleControlButtons) do
    local desiredColor = (electrics.values[buttonData.offColorElectric] and electrics.values[buttonData.offColorElectric] >= 1) and buttonData.offColor or buttonData.color

    local defaultSettingData = tableFromHeaderTable(defaults)
    for _, v in pairs(defaultSettingData) do
      local key = v.key or v.controllerName or v.type

  local modeData = {}
  for k, v in pairs(jbeamData) do
    if k:sub(1, #"modes") == "modes" then

    if k:sub(1, #"enabledModes") == "enabledModes" then
      for _, modeKey in pairs(v) do
        enabledModeKeys[modeKey] = true

  for k, mode in pairs(modeData) do
    if driveModes[mode.order] then

      driveModes[k].settingsOrder = {}
      for _, newSetting in pairs(modeSettings) do
        local key = newSetting.key or newSetting.deviceName or newSetting.electricsName or newSetting.controllerName or newSetting.type

      for settingsKey, _ in pairs(driveModes[k].settings) do
        table.insert(driveModes[k].settingsOrder, settingsKey)

  for _, mode in pairs(modeSorting) do
    table.insert(enabledDriveModes, mode.key)

  -- for name, mode in pairs(modeSorting) do
  --   if driveModeOrder[mode.order] then

for name,_ in pairs(shapeNames) do obstacleTypes[#obstacleTypes+1] = name end
local objects = {}

  for name,list in pairs(data) do
    expandTruncateList(name,#list)

  local validItems = {}
  for _, item in pairs(items) do
    if backend.passesFilters(item) then

    -- Group items by the specified group mode (similar to vehicle selector approach)
    for _, item in pairs(validItems) do
      -- Get groups for this item (including special groups)

      -- Create groups and add items
      for _, groupInfo in pairs(groupsForItem) do
        local groupName = groupInfo.groupName

    -- Process each group to create tiles
    for _, group in pairs(groups) do
      local tiles = group.tiles

        for clusterKey, clusterData in pairs(clusteredItems) do
          -- Skip clustering for "None" results (e.g., campaign system in automatic mode)

            -- For "None" clustering, add items directly without clustering
            for _, item in pairs(clusterData.itemsByKey) do
              table.insert(tiles, item)

    if displayData.showFavouritesMode == 'completeClusters' or displayData.showRecentMode == 'completeClusters' then
      for _, group in pairs(groups) do
        if not group.isFavouriteGroup and not group.isRecentGroup then

        if not group.isFavouriteGroup and not group.isRecentGroup then
          for _, tile in pairs(group.tiles) do
            -- Duplicate tiles for favourites group if needed

                local favouriteTile = {}
                for k, v in pairs(tile) do
                  favouriteTile[k] = v

                local recentTile = {}
                for k, v in pairs(tile) do
                  recentTile[k] = v

    -- Sort tiles within each group
    for _, group in pairs(groups) do
      if group.isRecentGroup then

      if group.isRecentGroup then
        for _, tile in pairs(group.tiles) do
          tile.recentIdx = backend.isRecent(tile.key) or math.huge

    local groupsList = {}
    for _, group in pairs(groups) do
      if #group.tiles > 0 then

  -- Filter items based on the automatic clustering rules
  for _, item in pairs(items) do
    -- Apply general filters first

    local hasDefaultTile = false
    for _, tile in pairs(filteredItems) do
      tile.isDefaultSelected = false

  local items = data.items
  for _, item in pairs(items) do
    item.showFavouriteIconPercent = backend.isFavourite(item.key) and 1 or 0

    validItems = {}
    for _, item in pairs(items) do
      if item.validBackends[backend.backendName] then

local function onSaveCurrentSaveSlot(currentSavePath)
  for id, spot in pairs(M.getDriftSpotsById()) do
    if spot._dirty then

      -- immediately hide the objects found
      for id, line in pairs(spotData.spatialInfo.lines) do
        for _, name in ipairs(line.markerObjects or {}) do

  local spotsForLevel = {}
  for _, spot in pairs(getDriftSpotsById()) do
    if spot.level == getCurrentLevelIdentifier() then

  self.flowgraph.transient = true -- prevent flowgraph from restarting flowgraphs after ctrl+L
  for key, value in pairs(varData or {}) do
    if self.flowgraph.variables:variableExists(key) then

  local personality = {}
  for _, v in pairs({'aggression', 'patience', 'bravery'}) do
    local mod = {}

      local valid = false
      for _, state in pairs(sequence.controllerStates) do
        local ctrlState = state.controller.states[state.stateIdx]

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

  for _, zone in pairs(sites.zones.objects) do
    zone:drawDebug(nil, isOutOfBounds and red or white, 2, -0.5, not isOutOfBounds)

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

    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)

  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)

    for k, v in pairs(gameplay_traffic.getTrafficData()) do
      if v.role.name == "police" then

    playerData.preStartTicks = playerData.preStartTicks - 1
    for k, v in pairs(freeroam_specialTriggers.getTriggers()) do
      if not v.vehIds[be:getPlayerVehicleID(0)] then

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

    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

        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

    self:clear()
    for _, p in pairs(self.pinOut) do p.value = nil end
    return

  local corner, found, hit
  for k,marker in pairs(self.markerObjects)do
    if k == 1 then --top left

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)

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

  end
  for _, paint in pairs(modelDetails.paints) do
    table.insert(paintData.factoryPaints, paint)

  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

    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)

    if mmap ~= nil then
      for _, r in pairs(mmap) do
        if r.compareFunc(p) then

  local i = 0
  for _, id in pairs(containers) do
    local veh = scenetree.findObjectById(id)

  coinAvailable = false
  for id, t in pairs(buffs) do
    if t.available then

function C:doBuffsTime()
  for id, t in pairs(buffs) do
    if t.useTime then --make sure the current buff actually uses timers

  for id, t in pairs(buffs) do
    if t.onScreen and t.pos[2] - camPos.y > propDespawn then

function C:getBuffByName(name)
  for id, t in pairs(buffs) do
    if t.name == name then

function C:getPropByName(name)
  for id, t in pairs(propsInfo) do
    if t.name == name then

  local i = 0
  for id, t in pairs(propsInfo) do
    if t.decal then

  for id, t in pairs(propsInfo) do
    if t.decal 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

    local added = false
    for name, pin in pairs(self.pinIn) do
      if not pin.fixed then

  local t, n = {}, 0
  for k in pairs(count1) do
    n = n + 1

  local ms = 0
  for k, v in pairs(count1) do
    local pct = floor(v*1000/samples + 0.5)/10

  local files = FS:findFiles(notebooksFullPath, '*.notebook.json', -1, true, false)
  for _,fname in pairs(files) do
    table.insert(paths, fname)

    local lower = {}
    for i,v in base.pairs(headers or lower) do
        lower[string.lower(i)] = v

    local h = "\r\n"
    for f,v in base.pairs(tosend) do
        h = (canonic[f] or f) .. ': ' .. v .. "\r\n" .. h

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

  for name, state in pairs(self.states) do
    -- clear extProxy

  -- find all links that have our node as the source node.
  for id, link in pairs(stateGraph.links) do
    if link.sourceNode.id == node.id then

  local deps = {}
  for k, i in pairs(kDeps) do
    table.insert(deps, k)

  for _, node in ipairs(hooks) do
    for k, func in pairs(node) do
      if string.sub(k, 1, 2) == 'on' and type(func) == 'function' then

function C:startAutoStartStates()
  for name, state in pairs(self.states) do
    if state.autoStart then

  -- find out if there is a connection from the entry node to any exit node. if so, this subgraph is invalid.
  for _, link in pairs(graph.links) do
    if link.sourceNode.nodeType == "states/stateEntry" and link.targetNode.nodeType == "states/stateExit" then

  table.insert(currentDepth, graph.id)
  for _, node in pairs(graph.nodes) do
    if node.nodeType ~= 'debug/comment' then

        local parent = nil
        for id, nd in pairs(group) do
          if nd.targetGraph.id == node.graph.id then

  for _, link in pairs(graph.links) do
    local elem = {

  local validNodes = {}
  for id, node in pairs(nodes) do
    if not node.isConnector then

  local rootNodes = {}
  for id, node in pairs(nodes) do
    if node.isRoot then

  for _, root in ipairs(rootNodes) do
    for name, port in pairs(root.ports or {}) do
      for _, targetId in ipairs(port.targets) do

  -- now that the heavy work is done, we can build the actual states :)
  for id, node in pairs(portedNodes) do
    if not node.stopProjectWhenReached then

  local deps = {}
  for id, state in pairs(self.states) do
    table.insert(deps, state.extProxy.extName)

function C:getStateIdForNode(node)
  for id, state in pairs(self.states) do
    if state.graph.id == node.graph:getRootGraph().id then return id end

function C:findStateNodeInStateGraphRecursive(graph, id)
  for _, node in pairs(graph.nodes) do
    if node.nodeType == 'states/stateNode' and node.targetGraph and node.targetGraph.id == id then return node end

  local ret = nil
  for _, child in pairs(graph:getChildren()) do
    if not ret then

        log("D","","Adding to transition stack of " .. dumps(self.states[id].name).."/"..dumps(id)..":")
        for key, val in pairs(onStates[id][3] or {}) do
          self.states[id].transitionStack[key] = val

        end
        for key, val in pairs(onStates[id][2] or {}) do
          self.states[id].transitionStack[key] = val

  local ids = {}
  for id, state in pairs(self.states) do
    if tableContains(state.depth, lastId) then

function C:broadcastCall(functionName, ...)
  for id, state in pairs(self.states) do
    if state.extProxy and state.extProxy.hookProxies and state.extProxy.hookProxies[functionName] then

function C:broadcastCallReturn(functionName, results, ...)
  for id, state in pairs(self.states) do
    if state.extProxy and state.extProxy.hookProxies and state.extProxy.hookProxies[functionName] then

      for id, node in pairs(self.hover.nodes) do
        ui_flowgraph_editor.SetCurrentEditor(self.fgEditor.ectx)

      for _, link in pairs(self.hover.links) do
        link:draw()

  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)

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

  automaticHandling.availableModeLookup = {}
  for _, v in pairs(automaticHandling.availableModes) do
    automaticHandling.availableModeLookup[v] = true

  if jbeamData.hShifterModePositions then
    for mode, index in pairs(jbeamData.hShifterModePositions) do
      automaticHandling.hShifterModeLookup[index] = mode

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

  local maxRow, maxCol = 0, 0
  for r, row in pairs(sheetData) do
    if r > maxRow then maxRow = r end

    if r > maxRow then maxRow = r end
    for c in pairs(row) do
      if c > maxCol then maxCol = c end

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

  local workbookRel = nil
  for _, rel in pairs(packageRels) do
    if rel.type == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" then

  local sharedStringsFile = nil
  for _, rel in pairs(workbookRels) do
    if rel.type == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" then

    -- Try to find the sheet ignoring case
    for name, path in pairs(xlsx.sheets) do
      if name:lower() == sheetName:lower() then

M.onGeneralMilestonesSetupCallbacks = function()
  for attKey, milestone in pairs(attKeyToMilestone) do
    M.setNotificationTarget(attKey)

local function onPlayerAttributesChanged(change)
  for attKey, val in pairs(change) do
    if val > 0 then

local function containsOnly (arr, val)
  for _, l in pairs(arr) do
    if l ~= val then

  self.pinOut.exitedEnd.value = false
  for flag, act in pairs(self.flags) do
    self.pinOut[flag].value = act

  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

  if m then
    for nid, n in pairs(m.getMap().nodes) do
      local pos = n.pos

  local navgraph = {}
  for nid, n in pairs(map.getMap().nodes) do -- remember edges are now single sided
    local a = map.getMap().nodes[nid]

    local a = map.getMap().nodes[nid]
    for lid, link in pairs(n.links) do
      local b = map.getMap().nodes[lid]

      local resp = {}
      for _, v in pairs(vehicleInfo) do
        resp[v.name] = v

M.onDrawDebug = function(dtReal, lastFocus)
  for _, sphere in pairs(debugObjects.spheres) do
    debugDrawer:drawSphere(sphere.coo, sphere.radius, sphere.color)

  end
  for _, dSphere in pairs(debugObjects.dynamicSpheres) do
    local spec = dSphere.getSpec()

  end
  for _, polyline in pairs(debugObjects.polylines) do
    for _, segment in pairs(polyline.segments) do

  for _, polyline in pairs(debugObjects.polylines) do
    for _, segment in pairs(polyline.segments) do
      debugDrawer:drawLine(segment.origin, segment.target, polyline.color)

  end
  for _, cylinder in pairs(debugObjects.cylinders) do
    debugDrawer:drawCylinder(cylinder.circleAPos, cylinder.circleBPos, cylinder.radius, cylinder.color)

  end
  for _, triangle in pairs(debugObjects.triangles) do
    if type(triangle.color) == "number" then

  end
  for _, rectangle in pairs(debugObjects.rectangles) do
    debugDrawer:drawQuadSolid(rectangle.a, rectangle.b, rectangle.c, rectangle.d, rectangle.color)

  end
  for _, line in pairs(debugObjects.text) do
    debugDrawer:drawText(line.origin, line.content, line.color)

  end
  for _, prism in pairs(debugObjects.squarePrisms) do
    debugDrawer:drawSquarePrism(prism.sideA, prism.sideB, prism.sideADims, prism.sideBDims, prism.color)

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

  for _, client in pairs(clients) do
    client:close()

  if frameDelayFuncQueue then
    for idx, item in pairs(frameDelayFuncQueue) do
      item.frameCountDown = item.frameCountDown-1

  if obsoleteFuncIndices then
    for k, idx in pairs(obsoleteFuncIndices) do
      table.remove(obsoleteFuncIndices, idx)

  if exts then
    for idx, ext in pairs(exts) do
      command = 'extensions.load("' .. ext .. '")'

    local roadData = {}
    for fieldName, _ in pairs(road:getFields()) do
      roadData[fieldName] = road:getField(fieldName, '')

    local roadData = {}
    for fieldName, _ in pairs(road:getFields()) do
      roadData[fieldName] = road:getField(fieldName, '')

  local converted = {}
  for key, val in pairs(colors) do
    converted[key] = {val.r, val.g, val.b}

  local annotations = AnnotationManager.getAnnotations()
  for k, v in pairs(annotations) do
    annotations[k] = {v.r, v.g, v.b}

    obj['options'] = {}
    for fld, nfo in pairs(object:getFieldList()) do
      if fld ~= 'position' and fld ~= 'rotation' and fld ~= 'scale' and fld ~= 'id' and fld ~= 'type' and fld ~= 'name' then

  for model, modelData in pairs(models) do
    local data = {

    data.configurations = {}
    for key, config in pairs(configs) do
      if config.model_key == model then

M.handleRemoveDebugObjects = function(request)
  for _, idx in pairs(request.objIDs) do
    debugObjects[request.objType][idx] = nil

    response = {}
    for i, scenario in pairs(scenarios) do
      if levelSet[scenario.levelName] then

  for k, veh in pairs(getAllVehicles()) do
    if not veh:getActive() then goto continue end

  local fields = obj:getFieldList()
  for field, props in pairs(fields) do
    if ignoreNames[field] == nil then

  for k, v in pairs(config) do
    if k == 'rotation' then

  local sensorsOfType = sensors[sensorType]
  for name, id in pairs(sensorsOfType) do
    if id == sensorId then

local totalSize = 0
for _, filename in pairs(filenames) do
  fileContent[filename] = readFile(filename)

  for i = 1, reruns do
    for filename, content in pairs(fileContent) do
      --print(' * ' ..tostring(filename))

local luaContent = {}
for filename, content in pairs(fileContent) do
  --print(' * ' ..tostring(filename))

  for i = 1, reruns do
    for filename, content in pairs(luaContent) do
      --print(' * ' ..tostring(filename))

  for i = 1, reruns do
    for filename, content in pairs(lpackContent) do
      --print(' * ' ..tostring(filename))

  for i = 1, reruns do
    for filename, content in pairs(luaContent) do
      --print(' * ' ..tostring(filename))

  for i = 1, reruns do
    for filename, content in pairs(luaContent) do
      strbufContent[filename] = tostring(buffer.encode(content))

  for i = 1, reruns do
    for filename, content in pairs(strbufContent) do
      buffer.decode(content)

    local dF = child:getDynamicFields()
    for _, value in pairs(dF or {}) do
      if type(value) == "string" and value == dynamicName then

    -- Don't clear if any active crawl is from mission
    for crawlerId, state in pairs(crawlStates) do
      if state and state.active and state.isFromMission then

    for crawlerId, _ in pairs(crawlStates) do
      clearCrawler(crawlerId)

  -- Mark completed nodes as finished (green)
  for pathnodeId, _ in pairs(state.completedPathnodes) do
    markerModes[tostring(pathnodeId)] = 'finished'

  if state.skippedPathnodes then
    for skippedId, _ in pairs(state.skippedPathnodes) do
      -- Only mark as skipped if not completed (skipped nodes can be completed later)

  local sortedPathnodeIndices = {}
  for idx, _ in pairs(state.pathnodeTimings or {}) do
    table.insert(sortedPathnodeIndices, idx)

  if not force then
    for crawlerId, state in pairs(crawlStates) do
      if state and state.active and state.isFromMission then

  for crawlerId, state in pairs(crawlStates) do
    if not state or not state.active then

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

M.getActiveCrawlerId = function()
  for crawlerId, state in pairs(crawlStates) do
    if state and state.active then

  commands.dropPlayerAtCameraNoReset = function(player)
    for crawlerId, state in pairs(crawlStates) do
      if state and state.active then

  recovery.startRecovering = function(useAltMode)
    for crawlerId, state in pairs(crawlStates) do
      if state and state.active then

local function trackVehReset()
  for crawlerId, state in pairs(crawlStates) do
    if state and state.active and state.crawlerData then

  -- highlight all coupling nodes
  for _, coupler in pairs(couplerCache) do
    if not coupler.couplerLock and not coupler.couplerWeld and ((coupler.couplerTag and externalCouplerVisibilityTags[coupler.couplerTag]) or (coupler.tag and externalCouplerVisibilityTags[coupler.tag])) then

    visibleTags = {}
    for _, c in pairs(couplerCache) do
      if not c.couplerWeld and not c.couplerLock and c.couplerTag then

  local nodetag = _nodetag or ""
  for _, val in pairs(couplerCache) do
    if (val.couplerWeld ~= true and val.couplerTag and (_nodetag == nil or val.couplerTag == nodetag)) and val.cid then

  local nodetag = _nodetag or ""
  for _, val in pairs(couplerCache) do
    if ((val.couplerLock ~= true or forceLocked) and (val.couplerWeld ~= true or forceWelded) and val.couplerTag and (_nodetag == nil or val.couplerTag == nodetag)) and val.cid then

  -- check for manual coupler
  for nid, c in pairs(couplerCache) do
    if not c.couplerWeld and not c.couplerLock and c.couplerTag and (nodeTag == nil or c.couplerTag == nodeTag) then

  --otherwise we'd detect the secondary one as "attached" here even if it's locked or welded
  for nid, _ in pairs(attachedCouplers) do
    if couplerCache[nid] and not couplerCache[nid].couplerWeld and not couplerCache[nid].couplerLock and (nodeTag == nil or couplerCache[nid].couplerTag == nodeTag) then

    local isAttached = false
    for cid, coupler in pairs(couplerCache) do
      if coupler.couplerTag == _nodetag then

  local breakGroups = type(n.breakGroup) == "table" and n.breakGroup or {n.breakGroup}
  for _, g in pairs(breakGroups) do
    couplerBreakGroupCache[g] = couplerBreakGroupCacheOrig[g]

      local breakGroups = type(n.breakGroup) == "table" and n.breakGroup or {n.breakGroup}
      for _, g in pairs(breakGroups) do
        breakBreakGroup(g)

  local couplerOffset = {}
  for _, c in pairs(couplerCache) do
    if c.couplerTag == couplerTag or c.tag == couplerTag or couplerTag == "" or not couplerTag then

  if data.inputs then
    for k, v in pairs(data.inputs) do
      input.event(k, v, 2)

    if wheel.treadNodes ~= nil and wheel.treadBeams ~= nil then
      for _, nodecid in pairs(wheel.treadNodes) do
        local frictionCoef = v.data.nodes[nodecid].frictionCoef

      for _, beamcid in pairs(wheel.treadBeams) do
        obj:setBeamSpringDamp(beamcid, v.data.beams[beamcid].beamSpring * 0.1, 2, -1, -1)

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

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

    if wheel.reinfBeams ~= nil then
      for _, beamcid in pairs(wheel.reinfBeams) do
        obj:setBeamSpringDamp(beamcid, 0, 0.7, 0, 0)

    if wheel.pressuredBeams ~= nil then
      for _, beamcid in pairs(wheel.pressuredBeams) do
        obj:setBeamPressureRel(beamcid, 0, math.huge, -1, -1)

  local damageSum = 0
  for k, partData in pairs(partDamageData) do
    local partValue = partData.value

    if autoCouplingTimer > 0.5 then
      for nodeTag, _ in pairs(autoCouplingVisibleTags) do
        attachCouplers(nodeTag)

  -- transmit data
  for _, coupler in pairs(transmitCouplers) do
    if coupler.obj2id then

        data.electrics = {}
        for _, v in pairs(coupler.exportElectrics) do
          data.electrics[v] = electrics.values[v]

        data.inputs = {}
        for _, v in pairs(coupler.exportInputs) do
          data.inputs[v] = electrics.values[v] or input[v]

  if part.parts then
    for _, subSlot in pairs(part.parts) do
      for _, subPart in pairs(subSlot) do

    for _, subSlot in pairs(part.parts) do
      for _, subPart in pairs(subSlot) do
        searchForActiveParts(subPart, activeParts)

    for _, beam in pairs(vehicle.beams) do
      local b1, b2 = beam.id1, beam.id2

    for _, tri in pairs(vehicle.triangles) do
      local t1, t2, t3 = tri.id1, tri.id2, tri.id3

    collTriState = {}
    for _, t in pairs(v.data.triangles) do
      if t.cid and t.beamCount then

          local breakGroups = type(t.breakGroup) == "table" and t.breakGroup or {t.breakGroup}
          for _, g in pairs(breakGroups) do
            triangleBreakGroupCache[g] = triangleBreakGroupCache[g] or {}

  for _, n in pairs(v.data.nodes or {}) do
    if n.name then

          local breakGroups = type(n.breakGroup) == "table" and n.breakGroup or {n.breakGroup}
          for _, g in pairs(breakGroups) do
            couplerBreakGroupCache[g] = couplerBreakGroupCache[g] or {}

  for _, c in pairs(couplerCache) do
    if c.couplerStartRadius and c.cid then

  M.activeParts = {}
  for _, slot in pairs(v.data.slotMap or {}) do
    for _, part in pairs(slot) do

  for _, slot in pairs(v.data.slotMap or {}) do
    for _, part in pairs(slot) do
      searchForActiveParts(part, M.activeParts)

  if v.data.activeParts and v.data.activePartsData then
    for partPath, partName in pairs(v.data.activeParts) do
      local part = v.data.activePartsData[partName]

  if v.data.beams then
    for bid, b in pairs(v.data.beams) do
      if b.tag then

        local breakGroups = type(b.breakGroup) == "table" and b.breakGroup or {b.breakGroup}
        for _, g in pairs(breakGroups) do
          if not breakGroupCache[g] then

        local deformGroups = type(b.deformGroup) == "table" and b.deformGroup or {b.deformGroup}
        for _, g in pairs(deformGroups) do
          local group = M.deformGroupDamage[g] or {eventCount = 0, damage = 0, maxEvents = 0, invMaxEvents = 0}

  if v.data.torsionbars then
    for _, t in pairs(v.data.torsionbars) do
      if type(t.precompressionTime) == "number" and t.precompressionTime > 0 then

  for k, v in pairs(invBodyPartBeamCount) do
    invBodyPartBeamCount[k] = 1 / v

local function breakAllBreakgroups()
  for _, b in pairs(v.data.beams) do
    if b.breakGroup ~= nil then

  --break groups that ONLY exist with couplers in them
  for breakgroup, _ in pairs(couplerBreakGroupCache) do
    breakBreakGroup(breakgroup)

local function breakHinges()
  for _, b in pairs(v.data.beams) do
    if b.breakGroup ~= nil then

      -- multiple break groups
      for _, g in pairs(breakGroups) do
        if type(g) == "string" and (string.find(g, "hinge") ~= nil or string.find(g, "latch") ~= nil) then

  --break groups that ONLY exist with couplers in them
  for breakgroup, _ in pairs(couplerBreakGroupCache) do
    if type(breakgroup) == "string" and (string.find(breakgroup, "hinge") ~= nil or string.find(breakgroup, "latch") ~= nil) then

local function deflateTires()
  for i, _ in pairs(wheels.wheels) do
    deflateTire(i)

  local inflatedTires = {}
  for k, v in pairs(wheels.wheels) do
    if not v.isTireDeflated then

  end
  for _, b in pairs(v.data.beams) do
    if b.deformSwitches ~= nil then

      local deformSwitchesT = type(b.deformSwitches) == "table" and b.deformSwitches or {b.deformSwitches}
      for _, g in pairs(deformSwitchesT) do
        if g.deformGroup == group then

  local data = {}
  for _, beam in pairs(v.data.beams) do
    local n1 = v.data.nodes[beam.id1]

local function hasCouplers(couplerTag)
  for _, val in pairs(couplerCache) do
    if (val.couplerWeld ~= true and val.couplerTag) and val.cid and (couplerTag == nil or val.couplerTag == couplerTag or val.tag == couplerTag) then

  save.hydros = {}
  for _, h in pairs(hydros.hydros) do
    table.insert(save.hydros, h.state)

  save.nodes = {}
  for _, node in pairs(v.data.nodes) do
    local d = {obj:getNodePosition(node.cid):toTable()}

  save.beams = {}
  for _, beam in pairs(v.data.beams) do
    local d = {

  for k, h in pairs(save.hydros) do
    hydros.hydros[k].state = h

  for cid, node in pairs(save.nodes) do
    cid = tonumber(cid) - 1

  for cid, beam in pairs(save.beams) do
    cid = tonumber(cid) - 1

  local damageData = {}
  for partName, partData in pairs(partDamageData) do
    local brokenCoef = clamp(partData.beamsBroken / partData.brokenBeamsThreshold, 0, 1)

          for materialName, materialData  in pairs(data) do
            if materialData.mapTo == material then

M.blendModesMap = {}
for k, v in pairs(M.blendModes) do M.blendModesMap[v.name] = v.value end
M.textureResolutions = {

M.layerTypesMap = {}
for k, v in pairs(M.layerTypes) do M.layerTypesMap[v] = k end
M.layerBakingStatusCode = {

M.typesMap = {}
for k, v in pairs(M.types) do M.typesMap[v] = k end
M.widgetTypes = {

M.propertiesMap = {}
for _, cat in pairs(M.properties) do
  for _, prop in ipairs(cat) do

      local meshNames = {}
      for name, enabled in pairs(sMeshes) do
        if enabled then

      local mNames = M.getShapeMaterialNames()
      for k, materialName in pairs(mNames) do
        if materials[materialName] then

      local mNames = M.getShapeMaterialNames()
      for k, materialName in pairs(mNames) do
        if materialName == vehicleName then

  local materials = {}
  for materialId, materialName in pairs(mNames) do
    materials[materialId] = materialName

  local layerData = {}
  for _, layer in pairs(layerStack) do
    table.insert(layerData, serializeLayer(layer))

  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

  local emitLargeParticulates = particleTicks.exhaustSmokeParticleTick > 1 and particulateEmission >= 0.3
  for _, n in pairs(nodes.exhaustEnds) do
    --regular exhaust smoke

  --if a node is underwater we want to increase the block to air cooling to simulate water cooling of the block
  for _, v in pairs(nodes.engine) do
    underWaterBlockCoolingCoef = underWaterBlockCoolingCoef + (obj:inWater(v) and 1000 or 0)

  --if a node is underwater we want to increase the block to air cooling to simulate water cooling of the block
  for _, v in pairs(nodes.engine) do
    underWaterBlockCoolingCoef = underWaterBlockCoolingCoef + (obj:inWater(v) and 100 or 0)

    for _, n in pairs(nodes.exhaustEnds) do
      if particleTicks.exhaustOilParticleTick > 1 and not parentEngine.isDisabled then

  for k, child in pairs(branch.children) do
    --if at this point something broke away or we reached the original end of the branch

  --search for the exhaust start node
  for _, n in pairs(v.data.nodes) do
    if n.isExhaust and (type(n.isExhaust) == "boolean" or n.isExhaust == parentEngine.name) then

  --find all exhaust beams
  for _, b in pairs(v.data.beams) do
    if b.isExhaust and (type(b.isExhaust) == "boolean" or b.isExhaust == parentEngine.name) then

local function exhaustBeamBroken(id, exhaustTree)
  for _, v in pairs(exhaustTree.children) do
    --if the broken beam matches one of our tree beams

local function resetExhaustTree(exhaustTree)
  for _, v in pairs(exhaustTree.children) do
    --if one of the children are already broken

  for k, _ in pairs(exhaustBeams) do
    exhaustBeams[k] = true

  burnEfficiencyCoef = {}
  for k, v in pairs(parentEngine.invBurnEfficiencyTable) do
    burnEfficiencyCoef[k] = v - 1

  end
  for _, n in pairs(jbeamData.engineBlock._engineGroup_nodes) do
    engineBlockMass = engineBlockMass + v.data.nodes[n].nodeWeight

  tblx = {}
  for _, fileType in pairs(exportTexturesFileTypes) do
    table.insert(tblx, fileType)

  --guihooks.trigger('downloadStateChanged', r);
  for k,v in pairs(progressQueue) do
    if v.id == r.id then

  log('D', 'repo.deleteUpdateQueue', 'delete ' .. tostring(data.filename) ..'   URI=' .. tostring(data.filename))
  for k,v in pairs(updateQueue) do
    if v.uri == data.uri then

  for k,v in pairs(updateQueue) do
    if v.id == idlook then return true end

  for k,v in pairs(updateQueue) do
    if v.id == idlook then return v.state end

  -- local toDelete = {}
  for k,v in pairs(updateQueue) do
    -- log('D', 'repo.updateDownloadQueue',v.filename.."  update="..tostring(v.update) .."   state="..tostring(v.state) )

  -- if(#toDelete>0) then
  --   for k,v in pairs(toDelete) do
  --     deleteUpdateQueue(v)

  for k,v in pairs(updateQueue) do
    if v.update and v.state == "updating" and downloading < parDownloads then

  --log('I', 'repo.changeStatusUpdateQueue', ' ' .. tostring(fname))
  for k,v in pairs(updateQueue) do
    if v.filename == fname then

    data.modID = string.match(uri, '%w+')
    for k,v in pairs(progressQueue) do
      if v.id == r.id then

    end
    for k,v in pairs(updateQueue) do
      if v.id==data.modID then

      end
      for k,v in pairs(updateQueue) do
        if v.id==data.modID then table.remove( updateQueue, k ) end

      guihooks.trigger("toastrMsg", {type="error", title="Repo Error", msg="Could not download the file, File missing"})
      for k,v in pairs(updateQueue) do
        if v.id==data.modID then table.remove( updateQueue, k ) end

    local finished = true
    for k,v in pairs(updateQueue) do
      if v.update and v.state ~= "done" then

      -- log('I', 'repo.finish', "updateQueue"..dumps(updateQueue) )
      for k,v in pairs(updateQueue) do
        if v.state == "done" then

      request.responseData.automationMsg = repoAutomationMsg
      for k,v in pairs(modList) do
        modList[k].pending = idInUpdateQueue(v.tagid)

    request.responseData.automationMsg = repoAutomationMsg
    for k,v in pairs(modList) do
      modList[k].pending = idInUpdateQueue(v.id)

  for k,v in pairs(updateQueue) do
    if v.id == mod_id then log('E', 'repo.modSubscribe', "Subscription '"..tostring(mod_id).."' already in update list"); return end

    for k,v in pairs(updateQueue) do
      if v.reason ~= "subscription" then v.update = false end

  log('D', 'repo.modUnsubscribe', tostring(mod_id).." -> "..tostring(modName))
  for k,v in pairs(updateQueue) do
    if v.id == mod_id then

local function addUpdateQueue(data)
  for k,v in pairs(updateQueue) do --no duplicate
    if v.id == data.id then return end

  updatingRepo = true
  for k,v in pairs(updateQueue) do
    if v.action == "update" then

  updatingRepo = true
  for k,v in pairs(updateQueue) do
    if v.id == id then

  updatingRepo = true
  for k,v in pairs(updateQueue) do
    if v.action == "missing" then

  if repoCmd.forceInstall then
    for k,v in pairs(repoCmd.forceInstall) do
      if core_modmanager.getModNameFromID(v) == nil then

  if repoCmd.forceRemove then
    for k,v in pairs(repoCmd.forceRemove) do
      if core_modmanager.getModNameFromID(v) ~= nil then

  if repoCmd.forceDisable then
    for k,v in pairs(repoCmd.forceDisable) do
      guihooks.trigger('repoError', 'force Disable : '..v)

  if #subList > 0 and core_modmanager.isReady() and Engine.Online.isAuthenticated() then
    for k,v in pairs(subList) do
      modSubscribe(v)

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

  if actionData.onBuildFuncFields then
    for _, val in pairs(actionData.onBuildFuncFields) do
      obj:setField(val[1], val[2], val[3])

      if fieldsSetOnBuildFunc[currentCreateObjectItem.classname] then
        for _, val in pairs(fieldsSetOnBuildFunc[currentCreateObjectItem.classname]) do
          -- If this field has been set in buildFunc, serialize it.

  --setmetatable(o, C)
  for k, v in pairs(C) do
    --print('k = ' .. tostring(k) .. ' = '.. tostring(v) )

  local baseInit = o.init
  for k, v in pairs(derivedClass) do
    --print('k = ' .. tostring(k) .. ' = '.. tostring(v) )

  for _, b in pairs(vdata.vdata.beams or {}) do
    if b and b.id1 and b.id2 then

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

  isDebugEnabled = false
  for _,v in pairs(debugUsers) do
    isDebugEnabled = isDebugEnabled or v

  local data = {}
  for _,wd in pairs(v.data.wheels) do
    local name = wd.name

local function setBrakedWheelsUpdate()
  for _, wd in pairs(wheels.wheels) do
    if brakedWheelsLookup[wd.name] then

  for _, v in pairs(torqueTable) do
    minBrakePressure = min(minBrakePressure, v.pressure)

  for _, v in pairs(torqueTable) do
    minSpringBrakePressure = min(minSpringBrakePressure, v.pressure)

  brakedWheelsLookup = {}
  for _, brakedWheelName in pairs(brakedWheels) do
    brakedWheelsLookup[brakedWheelName] = true

  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]

    local layerTypeCount = 0
    for k, _ in pairs(layerTypes) do
      layerType = k

          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

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

    for partName, _ in pairs(partsList) do
      local part, jbeamFilename = jbeamIO.getPart(ioCtx, partName)

            partsViewCount = 0
            for _, v in pairs(parts) do
              local partName = tostring(v[2])

          local isSelectedPart = false
          for k, v in pairs(parts) do
            if v[1] then

  for id, entry in pairs(previewNames) do
    table.insert(ids, id)

local function findCollisionWithNewName(ownerId, newName)
  for id, entry in pairs(previewNames) do
    -- we skip the id we check with the others

  for id, entry in pairs(previewNames) do
    local objId

        -- Populate rows
        for id, entry in pairs(previewNames) do
            imgui.TableNextRow()

    local aConds = require(file:sub(0,-5))
    for key, value in pairs(aConds) do
      missionConditions[key] = value

    local mans = {}
    for model, info in pairs(core_vehicles.getModelList().models) do
      if info.Brand then

    end
    for k, _ in pairs(mans) do table.insert(self.manufacturerList, k) end
    table.sort(self.manufacturerList)

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

  for _,node in pairs(vEditor.selectedNodes) do
    lastPickedNodesPos[node.name] = node.pos

  -- Center transforming axes arrows on node selection
  for _, node in pairs(vEditor.selectedNodes) do
    axesArrowPos:setAdd(node.pos)

  local pages = {}
  for id, pageInfo in pairs(pageInfosById) do
    local page = deepcopy(pageInfo)

  local devices = {}
  for k, v in pairs(core_input_bindings.bindings) do
    if v.contents.devicetype and v.contents.imagePack then

local function registerModule(name, actions, lookups)
  for k, _ in pairs(actions) do
    if registeredActions[k] then

  end
  for k, _ in pairs(lookups) do
    if registeredLookups[k] then

    if not data.bodyStyle then return false end
    for _, bodyStyle in pairs(values) do
      if data.bodyStyle[bodyStyle] then

    if not data.commercialClass then return false end
    for _, commercialClass in pairs(values) do
      if commercialClass == data.commercialClass then

    if insuranceInfo.perks then
      for perkId, perkInfo in pairs(insuranceInfo.perks) do
        local perkStaticData = perks[perkId]

      insuranceInfo.coverageOptions.deductible.perkText = insuranceInfo.perks.reduceDeductible.intro
      for coverageOptionName, coverageOptionInfo in pairs(insuranceInfo.coverageOptions.deductible.choices) do
        coverageOptionInfo.oldValue = coverageOptionInfo.value

      insuranceInfo.coverageOptions.paintRepair.perkText = insuranceInfo.perks.freeRepaintDuringRepair.intro
      for coverageOptionName, coverageOptionInfo in pairs(insuranceInfo.coverageOptions.paintRepair.choices) do
        coverageOptionInfo.oldPremiumInfluence = coverageOptionInfo.premiumInfluence

      insuranceInfo.coverageOptions.roadsideAssistance.perkText = insuranceInfo.perks.freeTowing.intro
      for coverageOptionName, coverageOptionInfo in pairs(insuranceInfo.coverageOptions.roadsideAssistance.choices) do
        coverageOptionInfo.oldPremiumInfluence = coverageOptionInfo.premiumInfluence

      insuranceInfo.coverageOptions.repairTime.perkText = insuranceInfo.perks.repairTimeDiscount.intro
      for coverageOptionName, coverageOptionInfo in pairs(insuranceInfo.coverageOptions.repairTime.choices) do
        coverageOptionInfo.premiumInfluence = coverageOptionInfo.premiumInfluence * (1 - repairTimeDiscountPerkValue)

      insuranceInfo.coverageOptions.repairTime.perkText = insuranceInfo.perks.instantRepair.intro
      for coverageOptionName, coverageOptionInfo in pairs(insuranceInfo.coverageOptions.repairTime.choices) do
        if coverageOptionInfo.value > 0 then

    for coverageOptionName, coverageOptionInfo in pairs(insuranceInfo.coverageOptions.roadsideAssistance.choices) do
      coverageOptionInfo.choiceText = string.format("%i tows", coverageOptionInfo.value)

    end
    for coverageOptionName, coverageOptionInfo in pairs(insuranceInfo.coverageOptions.repairTime.choices) do
      coverageOptionInfo.choiceText = coverageOptionInfo.value / 60 > 0 and string.format("%i min", coverageOptionInfo.value / 60) or "Instant"

    end
    for coverageOptionName, coverageOptionInfo in pairs(insuranceInfo.coverageOptions.deductible.choices) do
      coverageOptionInfo.choiceText = string.format("%i$", coverageOptionInfo.value)

    insuranceInfo.slogan = translateLanguage(insuranceInfo.slogan, insuranceInfo.slogan, true)
    for coverageOptionName, coverageOptionInfo in pairs(insuranceInfo.coverageOptions) do
      for choiceId, choiceInfo in pairs(coverageOptionInfo.choices) do --add id to each choice to make it more practical

    for coverageOptionName, coverageOptionInfo in pairs(insuranceInfo.coverageOptions) do
      for choiceId, choiceInfo in pairs(coverageOptionInfo.choices) do --add id to each choice to make it more practical
        choiceInfo.id = choiceId

    plInsurancesData = {}
    for _, insuranceInfo in pairs(availableInsurances) do
      plInsurancesData[insuranceInfo.id] = {

      }
      for gestureName, gestureInfo in pairs(insuranceInfo.gestures) do
        plInsurancesData[insuranceInfo.id].gesturesData[gestureName] = {

      end
      for coverageOptionName, coverageOptionInfo in pairs(insuranceInfo.coverageOptions) do
        if availableCoverageOptions[coverageOptionName].isInsuranceWide then

      -- convert string keys to numbers
      for k, v in pairs(savedPlInsuranceData.invVehs) do
        invVehs[tonumber(k) or k] = v

  for partPath, info in pairs(data.partConditions) do
    if info.integrityValue then

        -- keep the fuel level
        for _, tankData in pairs(info.integrityState.energyStorage) do
          for attributeName, value in pairs(tankData) do

        for _, tankData in pairs(info.integrityState.energyStorage) do
          for attributeName, value in pairs(tankData) do
            if attributeName ~= "storedEnergy" then

  local totalCost = 0
  for _, cost in pairs(costs) do
    totalCost = totalCost + cost

  if not score then score = plDriverScore end
  for _, tierData in pairs(driverScoreTiers) do
    if score >= tierData.min and score <= tierData.max then

  if repairOptionData.cost then
    for _, cost in pairs(repairOptionData.cost) do
      totalCost = totalCost + cost

  for coverageOptionId, coverageOptionValueId in pairs(currentCoverageOptions) do
    table.insert(coverageOptionsData, sanitizeCoverageOption(insuranceId, coverageOptionId, invVehId))

  local invVehList = {}
  for invVehId, data in pairs(invVehs) do
    if data.insuranceId == insuranceId then

  local invVehList = {}
  for invVehId, data in pairs(invVehs) do
    if availableInsurances[data.insuranceId] and availableInsurances[data.insuranceId].class == classId then

  local sendDataToUI = false
  for _, invVehInsuranceData in pairs(invVehs) do
    if invVehInsuranceData.insuranceId > 0 then

  local plInsuranceData = plInsurancesData[activeInsuranceId]
  for gestureName, _ in pairs(insuranceData.gestures) do -- every gesture is based on driven distance for now
    local lastHappenedAt = plInsuranceData.gesturesData[gestureName].lastHappenedAt or 0

  local insurances = {}
  for _, insuranceInfo in pairs(availableInsurances) do
    if insuranceInfo.class == class then

  if conditionData.jsonInsuranceClass then
    for className, value in pairs(conditionData.jsonInsuranceClass) do
      if value == true then

  for _, classInfo in pairs(availableClasses) do
    if classInfo.applicableConditions then

    if classInfo.applicableConditions then
      for condition, values in pairs(classInfo.applicableConditions.conditions) do -- that's an or condition
        if conditions[condition](conditionData, values) then

  local totalValue = 0
  for _, invVehData in pairs(getInvVehsUnderInsurance(insuranceId)) do
    if invVehData.initialValue then

  -- find the tier that the total value falls into
  for _, tier in pairs(groupDiscountTiers) do
    if tier.max then

    for coverageOptionId, coverageOptionData in pairs(potentialCoverageOptions or availableInsurances[insuranceId].coverageOptions) do
      if not availableCoverageOptions[coverageOptionId].isInsuranceWide then

    -- Insured vehicle: use current coverage options
    for coverageOptionId, coverageOptionValueId in pairs(potentialCoverageOptions or invVeh.insuranceData.coverageOptionsData.currentCoverageOptions) do
      totalDiscount = totalDiscount * availableInsurances[insuranceId].coverageOptions[coverageOptionId].choices[coverageOptionValueId].premiumInfluence

  for _, invVehData in pairs(getInvVehsUnderInsurance(insuranceId)) do
    hasVehicles = true

  if hasVehicles then
    for coverageOptionName, coverageOptionValueId in pairs(potentialCoverageOptions or plInsurancesData[insuranceId].coverageOptionsData.currentCoverageOptions) do
      local coverageOption = availableInsurances[insuranceId].coverageOptions[coverageOptionName]

  for detailName, detailPrice in pairs(details.items) do
    details.totalPrice = details.totalPrice + detailPrice.price

  local totalValue = 0
  for _, invVehData in pairs(getInvVehsUnderInsurance(insuranceId)) do
    if invVehData.initialValue then

  for _, invVehData in pairs(carsInsured) do
    invVehData.insuranceData.currentPremiumPrice = calculateVehiclePremium(invVehData.id).cost

  local count = 0
  for _, invVehData in pairs(invVehs) do
    if invVehData.insuranceId > 0 then

  local applicableInsurances = getInsurancesByClass(context.insuranceClassId)
  for _, insuranceInfo in pairs(applicableInsurances) do
    local sanitizedData

  -- format the data to make it easier to use in the UI
  for invVehId, invVehData in pairs(invVehs) do
    local invVehTileData = career_modules_inventory.getVehicleUiData(invVehId)

  for classId, classData in pairs(availableClasses) do
    local carsInsured = #getInvVehsUnderClass(classId)

    }
    for _, insuranceInfo in pairs(getInsurancesByClass(classId)) do
      table.insert(data.plClassesData[classId].insurances, getInsuranceSanitizedData(insuranceInfo.id))

    -- set the default vehicle specific coverage options
    for coverageOptionName, coverageOptionValue in pairs(availableInsurances[newInsuranceId].coverageOptions) do
      if not availableCoverageOptions[coverageOptionName].isInsuranceWide then

    if #getInvVehsUnderInsurance(newInsuranceId) == 0 then
      for coverageOptionName, coverageOptionValue in pairs(availableInsurances[newInsuranceId].coverageOptions) do
        if availableCoverageOptions[coverageOptionName].isInsuranceWide then

local function changeInvVehInsuranceCoverageOptions(invVehId, changedCoverageOptions)
  for coverageOptionName, coverageOptionValue in pairs(changedCoverageOptions) do
    local coverageOptionValueIndex = tableFindKey(availableInsurances[invVehs[invVehId].insuranceId].coverageOptions[coverageOptionName].changeability.changeParams.choices, coverageOptionValue)

  -- collect all insurances that match the class
  for _, insuranceInfo in pairs(availableInsurances) do
    if insuranceInfo.class == insuranceClassId then

  local vueModsChanged = false
  for _,v in pairs(files) do
    if not modModulesChanged and string.startswith(v.filename, "/ui/modModules/") then

local function checkInput(dt)
  for k, v in pairs(iV) do
    lastInputs[k] = inputs[k]

  local keyPressed = false
  for k, v in pairs(inputs) do
    if v and v ~= lastInputs[k] then

  if keyPressed then
    for k, v in pairs(inputs) do
      if v and v ~= lastInputs[k] then

  if self.pinSchema then
    for _, v in pairs(self.pinSchema) do
      local dir = v.dir

  if self.pinSchema then
    for _, v in pairs(self.pinSchema) do
      local dir = v.dir

      -- sorts pins
      for _, p in pairs(pinOrder) do
        if p[1] == pin.name and p[2] == pin.direction then

  if self.pinSchema then
    for _, v in pairs(self.pinSchema) do
      if v.type == 'flow' then

  if self.pinSchema then
    for _, v in pairs(self.pinSchema) do
      if v.dir == 'in' then

  for _, p in pairs(self.pinOut) do
    p.value = nil

  -- remove links
  for _, lnk in pairs(self.graph.links) do
    if lnk.sourcePin == pin or lnk.targetPin == pin then

  if self.clearOutPinsOnStart then
    for _, p in pairs(self.pinOut) do
      p.value = nil

  local targets = {}
  for lid, link in pairs(self.graph.links) do
    if link.sourceNode.id == self.id then

  if editor.getPreference("flowgraph.general.showNodeBehaviours") then
    for k, v in pairs(self.behaviour) do iconWidth = iconWidth + 24 end
  end

      im.TextUnformatted('Errors:')
      for k, v in pairs(self._error) do
        im.TextUnformatted(v)

  builder:Middle()
  for k, pin in pairs(self.pinIn) do
    im.TextUnformatted('> ' .. k .. '[' .. pin.type .. ']')

  end
  for k, pin in pairs(self.pinInLocal) do
    im.TextUnformatted('L> ' .. k .. '[' .. pin.type .. ']')

  end
  for k, pin in pairs(self.pinOut) do
    im.TextUnformatted(k .. '[' .. pin.type .. '] >')

  local hasActivePins = false
  for _, pin in pairs(self.pinList) do
    if pin:isActive() then

  local hiddenCount = 0
  for _, pin in pairs(self.pinList) do
    local show = not pin.hidden

  local inCount = 0
  for _, pin in pairs(self.pinList) do
    if pin.direction == 'in' then

  --for parentNode, _ in pairs(self._flowColors) do
  --  im.TextUnformatted(tostring(parentNode.id))

  -- outputs
  for _, pin in pairs(self.pinList) do
    if pin.direction == 'out' and (isSimple or pin.type ~= 'delegate')  then

  ui_flowgraph_editor.Suspend()
  for _, pin in pairs(self.pinList) do
    pin:hoverDraw(self.mgr)

        local selectedNodes = {}
        for id, _ in pairs(self.mgr.selectedNodes) do
          table.insert(selectedNodes, self.graph.nodes[id])

  for k, v in pairs(self.data) do

  for _, pin in pairs(self.pinIn) do
    if pin._hardcodedDummyPin then

  end
  for _, pin in pairs(self.pinList) do
    if pin.quickAccess then

  -- deserialize data/values
  for k, v in pairs(nodeData.data) do
    if self.data[k] ~= nil then

  if nodeData.hardcodedPins then
    for pinName, val in pairs(nodeData.hardcodedPins) do

  if nodeData.quickAccess then
    for pinName, val in pairs(nodeData.quickAccess.p_in) do
      if self.pinInLocal[pinName] then

    end
    for pinName, val in pairs(nodeData.quickAccess.p_out) do
      if self.pinOut[pinName] then

  if nodeData.hiddenPins then
    for pinName, val in pairs(nodeData.hiddenPins.p_in) do
      if val then

    end
    for pinName, val in pairs(nodeData.hiddenPins.p_out) do
      if val then

  local baseInit = o.init
  for k, v in pairs(derivedClass) do
    --print('k = ' .. tostring(k) .. ' = '.. tostring(v) )

  self.roadObj = nil
  for _, p in pairs(self.pinOut) do
    p.value = nil

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

    local replaced = false
    for k, v in pairs(menuTree[args.level]) do
      if v.uniqueID == args.uniqueID then

  for path, items in pairs(menuTreeCopy) do
    for _, e in ipairs(items) do

  for path, items in pairs(menuTreeCopy) do
    for i = #items, 1, -1 do

  local item
  for path, items in pairs(menuTreeCopy) do
    for i = 1, #items do

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

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