View difference between Paste ID: pL3VDYNA and LSwUP7QB

 local helper = {}
 --#region CONFIG----
 local cfg = {}
 cfg.localConfig = {
 	--if true, the program will attempt to download and use the config from remoteConfigPath
 	--useful if you have many turtles and you don't want to change the config of each one manually
 	useRemoteConfig = false,
 	remoteConfigPath = "http://localhost:33344/config.lua",
 	--this command will be used when the program is started as "mine def" (mineLoop overrides this command)
 	defaultCommand = "cube 3 3 8",
 	--false: build walls/floor/ceiling everywhere, true: only where there is fluid
 	plugFluidsOnly = true,
 	--maximum taxicab distance from enterance point when collecting ores, 0 = disable ore traversal
 	oreTraversalRadius = 0,
 	--layer mining order, use "z" for branch mining, "y" for anything else
 	--"y" - mine top to bottom layer by layer, "z" - mine forward in vertical slices
 	layerSeparationAxis="y",
 	--false: use regular chests, true: use entangled chests
 	--if true, the turtle will place a single entangled chest to drop off items and break it afterwards.
 	--tested with chests from https://www.curseforge.com/minecraft/mc-mods/kibe
 	useEntangledChests = false,
 	--false: refuel from inventory, true: refuel from (a different) entangled chest
 	--if true, the turtle won't store any coal. Instead, when refueling, it will place the entangled chest, grab fuel from it, refuel, and then break the chest.
 	useFuelEntangledChest = false,
 	--true: use two chuck loaders to mine indefinitely without moving into unloaded chunks.
 	--This doesn't work with chunk loaders from https://www.curseforge.com/minecraft/mc-mods/kibe, but might work with some other mod.
 	--After an area is mined, the turtle will shift by mineLoopOffset and execute mineLoopCommand
 	--mineLoopCommand is used in place of defaultCommand when launching as "mine def"
 	mineLoop = false,
 	mineLoopOffset = {x=0, y=0, z=8},
 	mineLoopCommand = "rcube 1 1 1"
 }
 
 cfg.getRemoteConfig = function(remotePath)
 	local handle = http.get(remotePath)
 	if not handle then
 		helper.printError("Server not responding, using local")
 		return nil
 	end
 	local data = handle.readAll()
 	handle.close()
 	local deser = textutils.unserialise(data)
 	if not deser then
 		helper.printError("Couldn't parse remote config, using local")
 		return nil
 	end
 	for key,_ in pairs(cfg.localConfig) do
 		if deser[key] == nil then
 			helper.printError("No key", key, "in remote config, using local")
 			return nil
 		end
 	end
 	return deser
 end
 
 cfg.processConfig = function()
 	local config = cfg.localConfig
 	if cfg.localConfig.useRemoteConfig then
 		helper.print("Downloading config..")
 		local remoteConfig = cfg.getRemoteConfig(config.remoteConfigPath)
 		config = remoteConfig or cfg.localConfig
 	end
 	return config
 end
 
 --#endregion
 --#region CONSTANTS----
 
 local SOUTH = 0
 local WEST = 1
 local NORTH = 2
 local EAST = 3
 
 local CHEST_SLOT = "chest_slot"
 local BLOCK_SLOT = "block_slot"
 local FUEL_SLOT = "fuel_slot"
 local FUEL_CHEST_SLOT = "fuel_chest_slot"
 local CHUNK_LOADER_SLOT = "chunk_loader_slot"
 local MISC_SLOT = "misc_slot"
 
 local ACTION = 0
 local TASK = 1
 
 local PATHFIND_INSIDE_AREA = 0
 local PATHFIND_OUTSIDE_AREA = 1
 local PATHFIND_INSIDE_NONPRESERVED_AREA = 2
 local PATHFIND_ANYWHERE_NONPRESERVED = 3
 
 local SUCCESS = 0
 local FAILED_NONONE_COMPONENTCOUNT = 1
 local FAILED_TURTLE_NOTINREGION = 2
 local FAILED_REGION_EMPTY = 4
 
 local REFUEL_THRESHOLD = 500
 local RETRY_DELAY = 3
 
 local FALLING_BLOCKS = {
 	["minecraft:gravel"] = true,
 	["minecraft:sand"] = true
 }
 
 --#endregion
 --#region WRAPPER----
 
 local wrapt = (function()
 	local self = {
 		selectedSlot = 1,
 		direction = SOUTH,
 		x = 0,
 		y = 0,
 		z = 0
 	}
 
 	local public = {}
 
 	--wrap everything in turtle
 	for key,value in pairs(turtle) do
 		public[key] = value
 	end
 	--init turtle selected slot
 	turtle.select(self.selectedSlot);
 
 	public.select = function(slot)
 		if self.selectedSlot ~= slot then
 			turtle.select(slot)
 			self.selectedSlot = slot
 		end
 	end
 
 	public.forward = function()
 		local success = turtle.forward()
 		if not success then
 			return success
 		end
 		if self.direction == EAST then
 			self.x = self.x + 1
 		elseif self.direction == WEST then
 			self.x = self.x - 1
 		elseif self.direction == SOUTH then
 			self.z = self.z + 1
 		elseif self.direction == NORTH then
 			self.z = self.z - 1
 		end
 		return success
 	end
 
 	public.up = function()
 		local success = turtle.up()
 		if not success then
 			return success
 		end
 		self.y = self.y + 1
 		return success
 	end
 
 	public.down = function()
 		local success = turtle.down()
 		if not success then
 			return success
 		end
 		self.y = self.y - 1
 		return success
 	end
 
 	public.turnRight = function()
 		local success = turtle.turnRight()
 		if not success then
 			return success
 		end
 		self.direction = self.direction + 1
 		if self.direction > 3 then
 			self.direction = 0
 		end
 		return success
 	end
 
 	public.turnLeft = function()
 		local success = turtle.turnLeft()
 		if not success then
 			return success
 		end
 		self.direction = self.direction - 1
 		if self.direction < 0 then
 			self.direction = 3
 		end
 		return success
 	end
 
 	public.getX = function() return self.x end
 	public.getY = function() return self.y end
 	public.getZ = function() return self.z end
 	public.getDirection = function() return self.direction end
 	public.getPosition = function() return {x = self.x, y = self.y, z = self.z, direction = self.direction} end
 
 	return public
 end)()
 
 --#endregion
 --#region DEBUG FUNCTIONS----
 
 local debug = {
 	dumpPoints = function(points, filename)
 		local file = fs.open(filename .. ".txt","w")
 		for key, value in pairs(points) do
 			local line =
 				tostring(value.x)..","..
 				tostring(value.y)..","..
 				tostring(value.z)..","
 			if value.adjacent then
 				line = line .. "0,128,0"
 			elseif value.inacc then
 				line = line .. "255,0,0"
 			elseif value.triple then
 				line = line .. "0,255,0"
 			elseif value.checkedInFirstPass then
 				line = line .. "0,0,0"
 			else
 				helper.printError("Invalid block type when dumping points")
 			end
 
 			if math.abs(value.z) < 100 then
 				file.writeLine(line)
 			end
 		end
 		file.close()
 	end,
 
 	dumpPath = function(points, filename)
 		local file = fs.open(filename .. ".txt","w")
 		for key, value in pairs(points) do
 			if tonumber(key) then
 				local line =
 					tostring(value.x)..","..
 					tostring(value.y)..","..
 					tostring(value.z)
 				file.writeLine(line)
 			end
 		end
 		file.close()
 	end,
 
 	dumpLayers = function(layers, filename)
 		for index, layer in ipairs(layers) do
 			local file = fs.open(filename .. tostring(index) .. ".txt","w")
 			for _, value in ipairs(layer) do
 				local line =
 					tostring(value.x)..","..
 					tostring(value.y)..","..
 					tostring(value.z)..","
 				if value.adjacent then
 					line = line .. "0,128,0"
 				elseif value.inacc then
 					line = line .. "255,0,0"
 				elseif value.triple then
 					line = line .. "0,255,0"
 				elseif value.checkedInFirstPass then
 					line = line .. "0,0,0"
 				else
 					helper.printError("Invalid block type when dumping layers")
 				end
 				file.writeLine(line)
 			end
 			file.close()
 		end
 	end
 }
 
 --#endregion
 --#region HELPER FUNCTIONS----
 
 helper.deltaToDirection = function(dX, dZ)
 	if dX > 0 then
 		return EAST
 	elseif dX < 0 then
 		return WEST
 	elseif dZ > 0 then
 		return SOUTH
 	elseif dZ < 0 then
 		return NORTH
 	end
 	error("Invalid delta", 2)
 end
 
 helper.tableLength = function(T)
 	local count = 0
 	for _ in pairs(T) do count = count + 1 end
 	return count
 end
 
 helper.getIndex = function(x, y, z)
 	return tostring(x) .. "," .. tostring(y) .. "," .. tostring(z)
 end
 
 helper.isPosEqual = function(pos1, pos2)
 	return pos1.x == pos2.x and pos1.y == pos2.y and pos1.z == pos2.z
 end
 
 helper.getSurroundings = function(pos)
 	return {
 		[helper.getIndex(pos.x + 1, pos.y, pos.z)] = {x = pos.x + 1, y = pos.y, z = pos.z},
 		[helper.getIndex(pos.x - 1, pos.y, pos.z)] = {x = pos.x - 1, y = pos.y, z = pos.z},
 		[helper.getIndex(pos.x, pos.y + 1, pos.z)] = {x = pos.x, y = pos.y + 1, z = pos.z},
 		[helper.getIndex(pos.x, pos.y - 1, pos.z)] = {x = pos.x, y = pos.y - 1, z = pos.z},
 		[helper.getIndex(pos.x, pos.y, pos.z + 1)] = {x = pos.x, y = pos.y, z = pos.z + 1},
 		[helper.getIndex(pos.x, pos.y, pos.z - 1)] = {x = pos.x, y = pos.y, z = pos.z - 1}
 	}
 end
 
 helper.getForwardPos = function(currentPos)
 	local newPos = {x = currentPos.x, y = currentPos.y, z = currentPos.z}
 	if currentPos.direction == EAST then
 		newPos.x = newPos.x + 1
 	elseif currentPos.direction == WEST then
 		newPos.x = newPos.x - 1
 	elseif currentPos.direction == SOUTH then
 		newPos.z = newPos.z + 1
 	elseif currentPos.direction == NORTH then
 		newPos.z = newPos.z - 1
 	end
 	return newPos
 end
 
 helper.distance = function(from, to)
 	return math.abs(from.x - to.x) + math.abs(from.y - to.y) + math.abs(from.z - to.z)
 end
 
 helper.sign = function(number)
     return number > 0 and 1 or (number == 0 and 0 or -1)
 end
 
 helper.inRange = function(number, a, b)
 	return number >= a and number <= b
 end
 
 helper.splitString = function(string, separator)
 	if not separator then separator = "%s" end
 	local split = {}
 	for str in string.gmatch(string, "([^"..separator.."]+)") do
 		table.insert(split, str)
 	end
 	return split
 end
 
 helper.stringEndsWith = function (str, ending)
 	return ending == "" or str:sub(-#ending) == ending
 end
 
 helper.tableContains = function(table, element, comparison)
 	for _, value in pairs(table) do
 		if comparison(value, element) then
 			return true
 		end
 	end
 	return false
 end
 
 helper.readOnlyTable = function(t)
 	local mt = {
 		__index = t,
 		__newindex = function(t,k,v)
 			error("Cannot write into a read-only table", 2)
 		end
 	}
 	local proxy = {}
 	setmetatable(proxy, mt)
 	return proxy
 end
 
 helper.osYield = function()
 ---@diagnostic disable-next-line: undefined-field
 	os.queueEvent("fakeEvent");
 ---@diagnostic disable-next-line: undefined-field
 	os.pullEvent();
 end
 
 helper.printError = function(...)
 	term.setTextColor(colors.red)
 	print(...)
 end
 
 helper.printWarning = function(...)
 	term.setTextColor(colors.yellow)
 	print(...)
 end
 
 helper.print = function(...)
 	term.setTextColor(colors.white)
 	print(...)
 end
 
 helper.write = function(...)
 	term.setTextColor(colors.white)
 	term.write(...)
 end
 
 helper.read = function()
 	term.setTextColor(colors.lightGray)
 	local data = read()
 	term.setTextColor(colors.white)
 	return data
 end
 
 --#endregion
 --#region SHAPE LIBRARY----
 
 local shapes = {}
 
 shapes.custom = {
 	command = "custom",
 	shortDesc = "custom <filename>",
 	longDesc = "Executes a function named \"generate\" from the specified file and uses the data it returns as a shape",
 	args = {"str"},
 	generate = function(filename)
 		local env = {
 			table=table,
 			fs=fs,
 			http=http,
 			io=io,
 			math=math,
 			os=os,
 			parallel=parallel,
 			string=string,
 			vector=vector,
 			textutils=textutils
 		}
 		local chunk, err = loadfile(filename, "bt", env)
 		if err then
 			helper.printError("Couldn't load file:", err);
 			return {}
 		end
 		chunk();
 		if type(env.generate) ~= "function" then
 			helper.printError("File does not contain generate function")
 			return {}
 		end
 		local generated = env.generate()
 		if type(generated) ~= "table" then
 			helper.printError("Generate function didn't return a table")
 			return {}
 		end
 		local blocks = {}
 		for _, value in ipairs(generated) do
 			if type(value.x) ~= "number" or type(value.y) ~= "number" or type(value.z) ~= "number" then
 				helper.printError("Invalid coordinates entry:", textutils.serialize(value))
 				return {}
 			end
 			blocks[helper.getIndex(value.x, value.y, value.z)] = {x = value.x, y = value.y, z = value.z}
 		end
 		return blocks
 	end
 }
 
 shapes.sphere = {
 	command = "sphere",
 	shortDesc = "sphere <diameter>",
 	longDesc = "Mine a sphere of diameter <diameter>, starting from it's bottom center",
 	args = {"2.."},
 	generate = function(diameter)
 		local radius = math.ceil(diameter / 2.0)
 		local radiusSq = (diameter / 2.0) * (diameter / 2.0)
 		local blocks = {}
 		local first = nil
 		for j=-radius,radius do
 			for i=-radius,radius do
 				for k=-radius,radius do
 					if diameter % 2 == 0 then
 						if math.pow(i+0.5, 2) + math.pow(j+0.5, 2) + math.pow(k+0.5, 2) < radiusSq then
 							if not first then
 								first = j
 							end
 							blocks[helper.getIndex(i,j-first,k)] = {x = i, y = j-first, z = k}
 						end
 					else
 						if math.pow(i, 2) + math.pow(j, 2) + math.pow(k, 2) < radiusSq then
 							if not first then
 								first = j
 							end
 							blocks[helper.getIndex(i,j-first,k)] = {x = i, y = j-first, z = k}
 						end
 					end
 				end
 			end
 			helper.osYield()
 		end
 		return blocks
 	end
 }
 
 shapes.cuboid = {
 	command="cube",
 	shortDesc = "cube <left> <up> <forward>",
 	longDesc = "Mine a cuboid of a specified size. Use negative values to dig in an opposite direction",
 	args= {"..-2 2..", "..-2 2..", "..-2 2.."},
 	generate = function(x, y, z)
 		local blocks = {}
 		local sX = helper.sign(x)
 		local sY = helper.sign(y)
 		local sZ = helper.sign(z)
 		local tX = sX * (math.abs(x) - 1)
 		local tY = sY * (math.abs(y) - 1)
 		local tZ = sZ * (math.abs(z) - 1)
 		for i=0,tX,sX do
 			for j=0,tY,sY do
 				for k=0,tZ,sZ do
 					blocks[helper.getIndex(i,j,k)] = {x = i, y = j, z = k}
 				end
 			end
 			helper.osYield()
 		end
 		return blocks
 	end
 }
 
 shapes.centeredCuboid = {
 	command="rcube",
 	shortDesc = "rcube <leftR> <upR> <forwardR>",
 	longDesc = "Mine a cuboid centered on the turtle. Each dimension is a \"radius\", so typing \"rcube 1 1 1\" will yield a 3x3x3 cube",
 	args={"1..", "1..", "1.."},
 	generate = function(rX, rY, rZ)
 		local blocks = {}
 		for i=-rX,rX do
 			for j=-rY,rY do
 				for k=-rZ,rZ do
 					blocks[helper.getIndex(i,j,k)] = {x = i, y = j, z = k}
 				end
 			end
 			helper.osYield()
 		end
 		return blocks
 	end
 }
 
 shapes.branch = {
 	command="branch",
 	shortDesc = "branch <branchLen> <shaftLen>",
 	longDesc = "Branch-mining. <branchLen> is the length of each branch, <shaftLen> is the length of the main shaft",
 	args={"0..", "3.."},
 	generate = function(xRadius, zDepth)
 		local blocks = {}
 		--generate corridor
 		for x=-1,1 do
 			for y=0,2 do
 				for z=0,zDepth-1 do
 					blocks[helper.getIndex(x,y,z)] = {x = x, y = y, z = z}
 				end
 			end
 		end
 		--generate branches
 		for z=2,zDepth-1,2 do
 			local y = (z % 4 == 2) and 0 or 2
 			for x=0,xRadius-1 do
 				blocks[helper.getIndex(x+2,y,z)] = {x = x+2, y = y, z = z}
 				blocks[helper.getIndex(-x-2,y,z)] = {x = -x-2, y = y, z = z}
 			end
 		end
 		return blocks
 	end
 }
 
 --#endregion
 --#region REGION PROCESSING----
 
 local region = {}
 region.createShape = function()
 	local blocks = {}
 	for i=-7,7 do
 		for j=0,7 do
 			for k=-7,7 do
 				if i*i + j*j + k*k < 2.5*2.5 then
 					blocks[helper.getIndex(i,j,k)] = {x = i, y = j, z = k}
 				end
 			end
 		end
 	end
 	return blocks
 end
 
 region.cloneBlocks = function(allBlocks)
 	local cloned = {}
 	for key,value in pairs(allBlocks) do
 		local blockClone = {
 			x = value.x,
 			y = value.y,
 			z = value.z
 		}
 		cloned[key] = blockClone
 	end
 	return cloned
 end
 
 --mark blocks that are next to walls
 region.markAdjacentInPlace = function(allBlocks)
 	for key,value in pairs(allBlocks) do
 		local xMinus = allBlocks[helper.getIndex(value.x - 1, value.y, value.z)]
 		local xPlus = allBlocks[helper.getIndex(value.x + 1, value.y, value.z)]
 		local yMinus = allBlocks[helper.getIndex(value.x, value.y - 1, value.z)]
 		local yPlus = allBlocks[helper.getIndex(value.x, value.y + 1, value.z)]
 		local zMinus = allBlocks[helper.getIndex(value.x, value.y, value.z - 1)]
 		local zPlus = allBlocks[helper.getIndex(value.x, value.y, value.z + 1)]
 		if not xMinus or not xPlus or not yMinus or not yPlus or not zMinus or not zPlus then
 			value.adjacent = true
 			if yMinus then yMinus.checkedInFirstPass = true end
 			if yPlus then yPlus.checkedInFirstPass = true end
 		end
 	end
 end
 
 --mark positions where the turtle can check both the block above and the block below
 region.markTripleInPlace = function(allBlocks)
 	local minY = 9999999;
 	for key,value in pairs(allBlocks) do
 		if not value.checkedInFirstPass and not value.adjacent then
 			minY = math.min(minY, value.y)
 		end
 	end
 	for key,value in pairs(allBlocks) do
 		if not value.checkedInFirstPass and not value.adjacent then
 			local offset = (value.y - minY) % 3;
 			if offset == 0 then
 				local blockAbove = allBlocks[helper.getIndex(value.x, value.y+1, value.z)]
 				if blockAbove ~= nil and blockAbove.checkedInFirstPass ~= true then
 					value.checkedInFirstPass = true
 				else
 					value.inacc = true
 				end
 			elseif offset == 1 then
 				value.triple = true
 			elseif offset == 2 and allBlocks[helper.getIndex(value.x, value.y-1, value.z)] ~= nil then
 				local blockBelow = allBlocks[helper.getIndex(value.x, value.y-1, value.z)]
 				if blockBelow ~= nil and blockBelow.checkedInFirstPass ~= true then
 					value.checkedInFirstPass = true
 				else
 					value.inacc = true
 				end
 			end
 		end
 	end
 end
 
 region.findConnectedComponents = function(allBlocks)
 	local visited = {}
 	local components = {}
 	local counter = 0
 	local lastTime = os.clock()
 	for key,value in pairs(allBlocks) do
 		if not visited[key] then
 			local component = {}
 			local toVisit = {[key] = value}
 			while true do
 				local newToVisit = {}
 				local didSomething = false
 				for currentKey,current in pairs(toVisit) do
 					didSomething = true
 					visited[currentKey] = true
 					component[currentKey] = current
 					local minusX = helper.getIndex(current.x-1, current.y, current.z)
 					local plusX = helper.getIndex(current.x+1, current.y, current.z)
 					local minusY = helper.getIndex(current.x, current.y-1, current.z)
 					local plusY = helper.getIndex(current.x, current.y+1, current.z)
 					local minusZ = helper.getIndex(current.x, current.y, current.z-1)
 					local plusZ = helper.getIndex(current.x, current.y, current.z+1)
 					if allBlocks[minusX] and not visited[minusX] then newToVisit[minusX] = allBlocks[minusX] end
 					if allBlocks[plusX] and not visited[plusX] then newToVisit[plusX] = allBlocks[plusX] end
 					if allBlocks[minusY] and not visited[minusY] then newToVisit[minusY] = allBlocks[minusY] end
 					if allBlocks[plusY] and not visited[plusY] then newToVisit[plusY] = allBlocks[plusY] end
 					if allBlocks[minusZ] and not visited[minusZ] then newToVisit[minusZ] = allBlocks[minusZ] end
 					if allBlocks[plusZ] and not visited[plusZ] then newToVisit[plusZ] = allBlocks[plusZ] end
 
 					counter = counter + 1
 					if counter % 50 == 0 then
 						local curTime = os.clock()
 						if curTime - lastTime > 1 then
 							lastTime = curTime
 							helper.osYield()
 						end
 					end
 				end
 				toVisit = newToVisit
 				if not didSomething then break end
 			end
 			table.insert(components, component)
 		end
 	end
 	return components
 end
 
 region.separateLayers = function(allBlocks, direction)
 	if direction ~= "y" and direction ~= "z" then
 		error("Invalid direction value", 2)
 	end
 	local layers = {}
 	local min = 999999
 	local max = -999999
 	for key,value in pairs(allBlocks) do
 		if not (not value.adjacent and value.checkedInFirstPass) then
 			local index = direction == "y" and value.y or value.z
 			if not layers[index] then
 				layers[index] = {}
 			end
 			layers[index][key] = value
 			min = math.min(min, index)
 			max = math.max(max, index)
 		end
 	end
 	if min == 999999 then
 		error("There should be at least one block in passed table", 2)
 	end
 
 	local reassLayers = {}
 	for key, value in pairs(layers) do
 		local index = direction == "y" and (max - min+1) - (key - min) or (key - min + 1)
 		reassLayers[index] = value
 	end
 	return reassLayers
 end
 
 region.sortFunction = function(a, b)
 	return (a.y ~= b.y and a.y < b.y or (a.x ~= b.x and a.x > b.x or a.z > b.z))
 end
 
 region.findClosestPoint = function(location, points, usedPoints)
 	local surroundings = helper.getSurroundings(location)
 	local existingSurroundings = {}
 	local foundClose = false
 	for key,value in pairs(surroundings) do
 		if points[key] and not usedPoints[key] then
 			table.insert(existingSurroundings, value)
 			foundClose = true
 		end
 	end
 	if foundClose then
 		table.sort(existingSurroundings, region.sortFunction)
 		local closest = table.remove(existingSurroundings)
 		return points[helper.getIndex(closest.x, closest.y, closest.z)]
 	end
 
 	local minDist = 999999
 	local minValue = nil
 	for key,value in pairs(points) do
 		if not usedPoints[key] then
 			local dist = helper.distance(value,location)
 			if dist < minDist then
 				minDist = dist
 				minValue = value
 			end
 		end
 	end
 	if not minValue then
 		return nil
 	end
 	return minValue
 end
 
 --travelling salesman, nearest neighbour method
 region.findOptimalBlockOrder = function(layers)
 	local newLayers = {}
 	local lastTime = os.clock()
 	for index, layer in ipairs(layers) do
 		local newLayer = {}
 		local usedPoints = {}
 		local current = region.findClosestPoint({x=0,y=0,z=0}, layer, usedPoints)
 		repeat
 			usedPoints[helper.getIndex(current.x, current.y, current.z)] = true
 			table.insert(newLayer, current)
 			current = region.findClosestPoint(current, layer, usedPoints)
 			local curTime = os.clock()
 			if curTime - lastTime > 1 then
 				lastTime = curTime
 				helper.osYield()
 			end
 		until not current
 		newLayers[index]=newLayer
 	end
 	return newLayers
 end
 
 region.createLayersFromArea = function(diggingArea, direction)
 	local blocksToProcess = region.cloneBlocks(diggingArea)
 	region.markAdjacentInPlace(blocksToProcess)
 	region.markTripleInPlace(blocksToProcess)
 	local layers = region.separateLayers(blocksToProcess, direction)
 	local orderedLayers = region.findOptimalBlockOrder(layers)
 	return orderedLayers
 end
 
 region.shiftRegion = function(shape, delta)
 	local newShape = {}
 	for key,value in pairs(shape) do
 		local newPos = {x = value.x + delta.x, y = value.y + delta.y, z = value.z + delta.z}
 		newShape[helper.getIndex(newPos.x, newPos.y, newPos.z)] = newPos
 	end
 	return newShape
 end
 
 region.reserveChests = function(blocks)
 	local blocksCopy = {}
 	local counter = 0
 	for _,value in pairs(blocks) do
 		counter = counter + 1
 		blocksCopy[counter] = value
 	end
 	table.sort(blocksCopy, function(a,b)
 		if a.y ~= b.y then return a.y > b.y
 		elseif a.z~=b.z then return a.z > b.z
 		else return a.x > b.x end
 	end)
 
 	return {reserved=blocksCopy}
 end
 
 region.validateRegion = function(blocks)
 	local result = SUCCESS
 	--there must be only one connected component
 	local components = region.findConnectedComponents(blocks)
 	if helper.tableLength(components) == 0 then
 		result = result + FAILED_REGION_EMPTY
 	end
 	if helper.tableLength(components) > 1 then
 		result = result + FAILED_NONONE_COMPONENTCOUNT
 	end
 	--the turtle must be inside of the region
 	if not blocks[helper.getIndex(0,0,0)] then
 		result = result + FAILED_TURTLE_NOTINREGION
 	end
 	return result
 end
 
 --#endregion
 --#region PATHFINDING----
 
 local path = {}
 path.pathfindUpdateNeighbour = function(data, neighbour, destination, origin, neighbourIndex)
 	local originIndex = helper.getIndex(origin.x, origin.y, origin.z)
 	if not data[neighbourIndex] then
 		data[neighbourIndex] = {}
 		data[neighbourIndex].startDist = data[originIndex].startDist + 1
 		data[neighbourIndex].heuristicDist = helper.distance(neighbour, destination)
 		data[neighbourIndex].previous = origin
 	elseif data[originIndex].startDist + 1 < data[neighbourIndex].startDist then
 		data[neighbourIndex].startDist = data[originIndex].startDist + 1
 		data[neighbourIndex].previous = origin
 	end
 end
 
 path.traversable = function(area, index, pathfindingType)
 	if pathfindingType == PATHFIND_INSIDE_AREA then
 		return area[index] ~= nil
 	elseif pathfindingType == PATHFIND_INSIDE_NONPRESERVED_AREA then
 		return not not (area[index] and not area[index].preserve)
 	elseif pathfindingType == PATHFIND_OUTSIDE_AREA then
 		return area[index] == nil
 	elseif PATHFIND_ANYWHERE_NONPRESERVED then
 		return area[index] == nil or not area[index].preserve
 	end
 	error("Unknown pathfinding type", 3)
 end
 
 path.pathfind = function(from, to, allBlocks, pathfindingType)
 	if helper.isPosEqual(from,to) then
 		return {length = 0}
 	end
 	local data = {}
 	local openSet = {}
 	local closedSet = {}
 
 	local current = from
 	local curIndex = helper.getIndex(from.x, from.y, from.z)
 	openSet[curIndex] = current
 
 	data[curIndex] = {}
 	data[curIndex].startDist = 0
 	data[curIndex].heuristicDist = helper.distance(current, to)
 
 	while true do
 		local surroundings = helper.getSurroundings(current)
 		for key,value in pairs(surroundings) do
 			if path.traversable(allBlocks,key,pathfindingType) and not closedSet[key] then
 				path.pathfindUpdateNeighbour(data, value, to, current, key)
 				openSet[key] = value
 			end
 		end
 
 		closedSet[curIndex] = current
 		openSet[curIndex] = nil
 
 		local minN = 9999999
 		local minValue = nil
 		for key,value in pairs(openSet) do
 			local sum = data[key].startDist + data[key].heuristicDist
 			if sum < minN then
 				minN = sum
 				minValue = value
 			end
 		end
 		current = minValue;
 
 		if current == nil then
 			helper.printWarning("No path from", from.x, from.y, from.z, "to", to.x, to.y, to.z)
 			return false
 		end
 
 		curIndex = helper.getIndex(current.x, current.y, current.z)
 		if helper.isPosEqual(current,to) then
 			break
 		end
 	end
 
 	local path = {}
 	local counter = 1
 	while current ~= nil do
 		path[counter] = current
 		counter = counter + 1
 		current = data[helper.getIndex(current.x, current.y, current.z)].previous
 	end
 
 	local reversedPath = {}
 	local newCounter = 1
 	for i=counter-1,1,-1 do
 		reversedPath[newCounter] = path[i]
 		newCounter = newCounter + 1
 	end
 	reversedPath.length = newCounter-1;
 	return reversedPath
 end
 
 --#endregion
 --#region SLOT MANAGER----
 local slots = (function()
 	local slotAssignments = {}
 	local assigned = false
 	local public = {}
 
 	local slotDesc = nil
 
 	local generateDescription = function(config)
 		local desc = {
 			[CHEST_SLOT] = "Chests",
 			[BLOCK_SLOT] = "Cobblestone",
 			[FUEL_SLOT] = "Fuel (only coal supported)",
 			[FUEL_CHEST_SLOT] = "Fuel Entangled Chest",
 			[CHUNK_LOADER_SLOT] = "2 Chunk Loaders",
 		}
 		if config.useEntangledChests then
 			desc[CHEST_SLOT] = "Entangled Chest"
 		end
 		return desc
 	end
 
 	public.assignSlots = function(config)
 		if assigned then
 			error("Slots have already been assigned", 2)
 		end
 		assigned = true
 
 		local currentSlot = 1
 		slotAssignments[CHEST_SLOT] = currentSlot
 		currentSlot = currentSlot + 1
 		if config.useFuelEntangledChest then
 			slotAssignments[FUEL_CHEST_SLOT] = currentSlot
 			currentSlot = currentSlot + 1
 		else
 			slotAssignments[FUEL_SLOT] = currentSlot
 			currentSlot = currentSlot + 1
 		end
 		if config.mineLoop then
 			slotAssignments[CHUNK_LOADER_SLOT] = currentSlot
 			currentSlot = currentSlot + 1
 		end
 		slotAssignments[BLOCK_SLOT] = currentSlot
 		currentSlot = currentSlot + 1
 		slotAssignments[MISC_SLOT] = currentSlot
 		currentSlot = currentSlot + 1
 
 		slotDesc = generateDescription(config)
 	end
 
 	public.get = function(slotId)
 		if slotAssignments[slotId] then
 			return slotAssignments[slotId]
 		else
 			error("Slot " .. tostring(slotId) .. " was not assigned", 2)
 		end
 	end
 
 	public.printSlotInfo = function()
 		local inverse = {}
 		for key,value in pairs(slotAssignments) do
 			inverse[value] = key
 		end
 		for key,value in ipairs(inverse) do
 			if value ~= MISC_SLOT then
 				helper.print("\tSlot", key, "-", slotDesc[value])
 			end
 		end
 	end
 
 	return public
 end)()
 
 --#endregion
 --#region UI----
 
 local ui = {}
 
 ui.printInfo = function()
 	helper.print("Current fuel level is", wrapt.getFuelLevel())
 	helper.print("Item slots, can change based on config:")
 	slots.printSlotInfo()
 end
 
 ui.printProgramsInfo = function()
 	helper.print("Select a program:")
 	helper.print("\thelp <program>")
 	for _,value in pairs(shapes) do
 		helper.print("\t"..value.shortDesc)
 	end
 end
 
 ui.tryShowHelp = function(input)
 	if not input then
 		return false
 	end
 	local split = helper.splitString(input)
 	if split[1] ~= "help" then
 		return false
 	end
 
 	if #split == 1 then
 		ui.printProgramsInfo()
 		return true
 	end
 
 	if #split ~= 2 then
 		return false
 	end
 
 	local program = split[2]
 	local shape = nil
 	for key, value in pairs(shapes) do
 		if value.command == program then
 			shape = value
 		end
 	end
 
 	if not shape then
 		helper.printError("Unknown program")
 		return true
 	end
 	helper.print("Usage:", shape.shortDesc)
 	helper.print("\t"..shape.longDesc)
 	return true
 end
 
 ui.testRange = function(range, value)
 	if range == "str" then
 		return "string"
 	end
 	if type(value) ~= "number" then
 		return false
 	end
 
 	local subRanges = helper.splitString(range, " ")
 	for _, range in ipairs(subRanges) do
 		local borders = helper.splitString(range, "..")
 		local tableLength = helper.tableLength(borders)
 		if tableLength == 2 then
 			local left = tonumber(borders[1])
 			local right = tonumber(borders[2])
 			if helper.inRange(value, left, right) then
 				return true
 			end
 		elseif tableLength == 1 then
 			local isLeft = string.sub(range, 0, 1) ~= "."
 			local border = tonumber(borders[1])
 			local good = isLeft and (value >= border) or not isLeft and (value <= border)
 			if good then
 				return true
 			end
 		end
 	end
 	return false
 end
 
 ui.parseArgs = function(argPattern, args)
 	if helper.tableLength(argPattern) ~= helper.tableLength(args) then
 		return nil
 	end
 
 	local parsed = {}
 	for _,value in ipairs(args) do
 		local number = tonumber(value)
 		if not number then
 			table.insert(parsed, value)
 		end
 		table.insert(parsed, number)
 	end
 
 	for index,value in ipairs(argPattern) do
 		local result = ui.testRange(value, parsed[index])
 		if result == "string" then
 			parsed[index] = args[index]
 		elseif not result then
 			return nil
 		end
 	end
 	return parsed
 end
 
 ui.parseProgram = function(string)
 	if not string then
 		return nil
 	end
 
 	local split = helper.splitString(string)
 	if not split or helper.tableLength(split) == 0 then
 		return nil
 	end
 
 	local program = split[1]
 	local shape = nil
 	for _, value in pairs(shapes) do
 		if value.command == program then
 			shape = value
 		end
 	end
 	if not shape then
 		return nil
 	end
 
 	local args = {table.unpack(split, 2, #split)}
 	local parsed = ui.parseArgs(shape.args, args)
 	if not parsed then
 		return nil
 	end
 
 	return {shape = shape, args = parsed}
 end
 
 ui.promptForShape = function()
 	local shape
 	while true do
 		helper.write("> ")
 		local input = helper.read()
 		shape = ui.parseProgram(input)
 		if not shape then
 			if not ui.tryShowHelp(input) then
 				helper.printError("Invalid program")
 			end
 		else
 			break
 		end
 	end
 	return shape
 end
 
 ui.showValidationError = function(validationResult)
 	local error = "Invalid mining volume:";
 	if bit32.band(validationResult, FAILED_REGION_EMPTY) ~= 0 then
 		helper.printError("Invalid mining volume: \n\tVolume is empty")
 		return
 	end
 	if bit32.band(validationResult, FAILED_NONONE_COMPONENTCOUNT) ~= 0 then
 		error = error .. "\n\tVolume has multiple disconnected parts"
 	end
 	if bit32.band(validationResult, FAILED_TURTLE_NOTINREGION) ~= 0 then
 		error = error .. "\n\tTurtle (pos(0,0,0)) not in volume"
 	end
 	helper.printError(error)
 end
 
 --#endregion
 
 ----THE REST OF THE CODE----
 
 local function execWithSlot(func, slot)
 	wrapt.select(slots.get(slot))
 	local data = func()
 	wrapt.select(slots.get(MISC_SLOT))
 	return data
 end
 
 local function isWaterSource(inspectFunction)
 	local success, data = inspectFunction()
 	if success and data.name == "minecraft:water" and data.state.level == 0 then
 		return true
 	end
 	return false
 end
 
 local function isFluidSource(inspectFunction)
 	local success, data = inspectFunction()
 	if success and (data.name == "minecraft:lava" or data.name == "minecraft:water") and data.state.level == 0 then
 		return true
 	end
 	return false
 end
 
 local function isFluid(inspectFunction)
 	local success, data = inspectFunction()
 	if success and (data.name == "minecraft:lava" or data.name == "minecraft:water") then
 		return true
 	end
 	return false
 end
 
 local function isSand(inspectFunction)
 	local success, data = inspectFunction()
 	if success and FALLING_BLOCKS[data.name] then
 		return true
 	end
 	return false
 end
 
 local function isOre(inspectFunction)
 	local success, data = inspectFunction()
 	if success and helper.stringEndsWith(data.name, "_ore") then
 		return true
 	end
 	return false
 end
 
 
 local function dropInventory(dropFunction)
 	local dropped = true
 	for i=slots.get(MISC_SLOT),16 do
 		if wrapt.getItemCount(i) > 0 then
 			wrapt.select(i)
 			dropped = dropFunction() and dropped
 		end
 	end
 	wrapt.select(slots.get(MISC_SLOT))
 	return dropped
 end
 
 local function forceMoveForward()
 	if isWaterSource(wrapt.inspect) then
 		execWithSlot(wrapt.place, BLOCK_SLOT)
 	end
 	repeat
 		wrapt.dig()
 	until wrapt.forward()
 end
 
 local function plugTop(onlyFluids)
 	if isSand(wrapt.inspectUp) then
 		wrapt.digUp()
 	end
 	if not wrapt.detectUp() and not onlyFluids or onlyFluids and isFluid(wrapt.inspectUp) then
 		if wrapt.getItemCount(slots.get(BLOCK_SLOT)) > 0 then
 			local tries = 0
 			repeat tries = tries + 1 until execWithSlot(wrapt.placeUp, BLOCK_SLOT) or tries > 10
 		end
 	end
 end
 
 local function plugBottom(onlyFluids)
 	if not onlyFluids or isFluidSource(wrapt.inspectDown) then
 		execWithSlot(wrapt.placeDown, BLOCK_SLOT)
 	end
 end
 
 local function digAbove()
 	if isFluidSource(wrapt.inspectUp) then
 		execWithSlot(wrapt.placeUp, BLOCK_SLOT)
 	end
 	wrapt.digUp()
 end
 
 local function digBelow()
 	if isFluidSource(wrapt.inspectDown) then
 		execWithSlot(wrapt.placeDown, BLOCK_SLOT)
 	end
 	wrapt.digDown()
 end
 
 local function digInFront()
 	if isFluidSource(wrapt.inspect) then
 		execWithSlot(wrapt.place, BLOCK_SLOT)
 	end
 	wrapt.dig()
 end
 
 local function turnTowardsDirection(targetDir)
 	local delta = (targetDir - wrapt.getDirection()) % 4
 	if delta == 1 then
 		wrapt.turnRight()
 	elseif delta == 2 then
 		wrapt.turnRight()
 		wrapt.turnRight()
 	elseif delta == 3 then
 		wrapt.turnLeft()
 	end
 	if targetDir ~= wrapt.getDirection() then
 		error("Could not turn to requested direction")
 	end
 end
 
 
 
 local function stepTo(tX, tY, tZ)
 	local dX = tX - wrapt.getX()
 	local dY = tY - wrapt.getY()
 	local dZ = tZ - wrapt.getZ()
 	if dY < 0 then
 		repeat wrapt.digDown() until wrapt.down()
 	elseif dY > 0 then
 		repeat wrapt.digUp() until wrapt.up()
 	else
 		local dir = helper.deltaToDirection(dX, dZ)
 		turnTowardsDirection(dir)
 		forceMoveForward()
 	end
 end
 
 local function goToCoords(curBlock, pathfindingArea, pathfindingType)
 	local pos = wrapt.getPosition()
 	local path = path.pathfind(pos, curBlock, pathfindingArea, pathfindingType)
 	if not path then
 		return false
 	end
 
 	for k=1,path.length do
 		if not (path[k].x == pos.x and path[k].y == pos.y and path[k].z == pos.z) then
 			stepTo(path[k].x, path[k].y, path[k].z)
 		end
 	end
 	return true
 end
 
 
 
 local function findOre(oresTable, startPos, rangeLimit)
 	local ores = {}
 	local isForwardCloseEnough = function()
 		return helper.distance(helper.getForwardPos(wrapt.getPosition()), startPos) <= rangeLimit
 	end
 	if isForwardCloseEnough() and isOre(wrapt.inspect) then
 		table.insert(ores,helper.getForwardPos(wrapt.getPosition()))
 	end
 	local down = {x = wrapt.getX(), y = wrapt.getY() - 1, z = wrapt.getZ()}
 	if helper.distance(down, startPos) <= rangeLimit and isOre(wrapt.inspectDown) then
 		table.insert(ores, down)
 	end
 	local up = {x = wrapt.getX(), y = wrapt.getY() + 1, z = wrapt.getZ()}
 	if helper.distance(up, startPos) <= rangeLimit and isOre(wrapt.inspectUp) then
 		table.insert(ores, up)
 	end
 	wrapt.turnLeft()
 	if isForwardCloseEnough() and isOre(wrapt.inspect) then
 		table.insert(ores,helper.getForwardPos(wrapt.getPosition()))
 	end
 	wrapt.turnLeft()
 	if isForwardCloseEnough() and isOre(wrapt.inspect) then
 		table.insert(ores,helper.getForwardPos(wrapt.getPosition()))
 	end
 	wrapt.turnLeft()
 	if isForwardCloseEnough() and isOre(wrapt.inspect) then
 		table.insert(ores,helper.getForwardPos(wrapt.getPosition()))
 	end
 	for _,value in pairs(ores) do
 		if not helper.tableContains(oresTable, value, helper.isPosEqual) then
 			table.insert(oresTable, value)
 		end
 	end
 end
 
 --traverse an ore vein and return to original turtle position afterwards
 local function traverseVein(blocks, rangeLimit)
 	local startPos = wrapt.getPosition()
 	local minePath = {}
 	minePath[helper.getIndex(startPos.x, startPos.y, startPos.z)] = startPos
 
 	local ores = {}
 	local searchedPositions = {}
 	while true do
 		local currentIndex = helper.getIndex(wrapt.getX(),wrapt.getY(),wrapt.getZ())
 		if not searchedPositions[currentIndex] then
 			findOre(ores, startPos, rangeLimit)
 			searchedPositions[currentIndex] = true
 		end
 		local targetOre = table.remove(ores)
 		if not targetOre then
 			goToCoords(startPos, minePath, PATHFIND_INSIDE_AREA)
 			turnTowardsDirection(startPos.direction)
 			break
 		end
 		local targetIndex = helper.getIndex(targetOre.x, targetOre.y, targetOre.z)
 		if not blocks[targetIndex] or not blocks[targetIndex].preserve then
 			minePath[helper.getIndex(targetOre.x, targetOre.y, targetOre.z)] = targetOre
 			goToCoords(targetOre, minePath, PATHFIND_INSIDE_AREA)
 		end
 	end
 end
 
 
 
 --diggingOptions: plugFluidsOnly, oreTraversalRadius
 local function processAdjacent(allBlocks, diggingOptions)
 	local toPlace = {}
 
 	local pos = wrapt.getPosition()
 
 	local minusX = helper.getIndex(pos.x-1, pos.y, pos.z)
 	local plusX = helper.getIndex(pos.x+1, pos.y, pos.z)
 	local minusZ = helper.getIndex(pos.x, pos.y, pos.z-1)
 	local plusZ = helper.getIndex(pos.x, pos.y, pos.z+1)
 
 	if not allBlocks[minusX] then toPlace[minusX] = {x = pos.x - 1, y = pos.y, z = pos.z} end
 	if not allBlocks[plusX] then toPlace[plusX] = {x = pos.x + 1, y = pos.y, z = pos.z} end
 	if not allBlocks[minusZ] then toPlace[minusZ] = {x = pos.x, y = pos.y, z = pos.z - 1} end
 	if not allBlocks[plusZ] then toPlace[plusZ] = {x = pos.x, y = pos.y, z = pos.z + 1} end
 
 	for key,value in pairs(toPlace) do
 		local dX = value.x - pos.x
 		local dZ = value.z - pos.z
 		local dir = helper.deltaToDirection(dX, dZ)
 		turnTowardsDirection(dir)
 		if diggingOptions.oreTraversalRadius > 0 and isOre(wrapt.inspect) then
 			traverseVein(allBlocks, diggingOptions.oreTraversalRadius)
 		end
 		if not diggingOptions.plugFluidsOnly or isFluid(wrapt.inspect) then
 			execWithSlot(wrapt.place, BLOCK_SLOT)
 		end
 	end
 
 	local minusY = helper.getIndex(pos.x, pos.y-1, pos.z)
 	local plusY = helper.getIndex(pos.x, pos.y+1, pos.z)
 
 	if diggingOptions.oreTraversalRadius > 0 then
 		if not allBlocks[minusY] and isOre(wrapt.inspectDown)
 			or not allBlocks[plusY] and isOre(wrapt.inspectUp) then
 			traverseVein(allBlocks, diggingOptions.oreTraversalRadius)
 		end
 	end
 
 	if allBlocks[minusY] then
 		if not allBlocks[minusY].preserve then digBelow() end
 	else
 		plugBottom(diggingOptions.plugFluidsOnly)
 	end
 
 	if allBlocks[plusY] then
 		if not allBlocks[plusY].preserve then digAbove() end
 	else
 		plugTop(diggingOptions.plugFluidsOnly)
 	end
 end
 
 
 
 
 local function processTriple(diggingArea)
 	local pos = wrapt.getPosition()
 	local minusY = helper.getIndex(pos.x, pos.y-1, pos.z)
 	local plusY = helper.getIndex(pos.x, pos.y+1, pos.z)
 	if not diggingArea[plusY].preserve then digAbove() end
 	if not diggingArea[minusY].preserve then digBelow() end
 end
 
 
 
 local function sortInventory(sortFuel)
 	--clear cobble slot
 	local initCobbleData = wrapt.getItemDetail(slots.get(BLOCK_SLOT))
 	if initCobbleData and initCobbleData.name ~= "minecraft:cobblestone" then
 		wrapt.select(slots.get(BLOCK_SLOT))
 		wrapt.drop()
 	end
 
 	--clear fuel slot
 	if sortFuel then
 		local initFuelData = wrapt.getItemDetail(slots.get(FUEL_SLOT))
 		if initFuelData and initFuelData.name ~= "minecraft:coal" then
 			wrapt.select(slots.get(FUEL_SLOT))
 			wrapt.drop()
 		end
 	end
 
 	--search inventory for cobble and fuel and put them in the right slots
 	local fuelData = sortFuel and wrapt.getItemDetail(slots.get(FUEL_SLOT)) or {count=64}
 	local cobbleData = wrapt.getItemDetail(slots.get(BLOCK_SLOT))
 
 	if fuelData and cobbleData and fuelData.count > 32 and cobbleData.count > 32 then
 		wrapt.select(slots.get(MISC_SLOT))
 		return
 	end
 
 	for i=slots.get(MISC_SLOT),16 do
 		local curData = wrapt.getItemDetail(i)
 		if curData then
 			if curData.name == "minecraft:cobblestone" then
 				wrapt.select(i)
 				wrapt.transferTo(slots.get(BLOCK_SLOT))
 			elseif sortFuel and curData.name == "minecraft:coal" then
 				wrapt.select(i)
 				wrapt.transferTo(slots.get(FUEL_SLOT))
 			end
 		end
 	end
 
 	wrapt.select(slots.get(MISC_SLOT))
 end
 
 
 
 local function dropIntoEntangled(dropFunction)
 	local result = false
 	repeat
 		result = dropInventory(dropFunction)
 		if not result then
 			helper.printWarning("Entangled chest is full, retrying..")
 ---@diagnostic disable-next-line: undefined-field
 			os.sleep(RETRY_DELAY)
 		end
 	until result
 end
 
 local function findSuitableEntangledChestPos(diggingArea)
 	local surroundings = helper.getSurroundings(wrapt.getPosition())
 	local options = {}
 	for key,value in pairs(surroundings) do
 		if diggingArea[key] and not diggingArea[key].preserve then
 			table.insert(options, value)
 		end
 	end
 	local selectedOption = table.remove(options)
 	if not selectedOption then
 		error("Did the turtle just surround itself with chests?")
 		return nil
 	end
 	return selectedOption
 end
 
 local function dropOffEntangledChest(diggingArea)
 	local selectedOption = findSuitableEntangledChestPos(diggingArea)
 	if not selectedOption then
 		return
 	end
 
 	local curPosition = wrapt.getPosition()
 	local delta = {x = selectedOption.x-curPosition.x, y = selectedOption.y-curPosition.y, z = selectedOption.z-curPosition.z}
 	if delta.y < 0 then
 		repeat digBelow() until execWithSlot(wrapt.placeDown, CHEST_SLOT)
 		dropIntoEntangled(wrapt.dropDown)
 		wrapt.select(slots.get(CHEST_SLOT))
 		digBelow()
 		wrapt.select(slots.get(MISC_SLOT))
 	elseif delta.y > 0 then
 		repeat digAbove() until execWithSlot(wrapt.placeUp, CHEST_SLOT)
 		dropIntoEntangled(wrapt.dropUp)
 		wrapt.select(slots.get(CHEST_SLOT))
 		digAbove()
 		wrapt.select(slots.get(MISC_SLOT))
 	elseif delta.x ~= 0 or delta.y ~= 0 or delta.z ~= 0 then
 		local direction = helper.deltaToDirection(delta.x, delta.z)
 		turnTowardsDirection(direction)
 		repeat digInFront() until execWithSlot(wrapt.place, CHEST_SLOT)
 		dropIntoEntangled(wrapt.drop)
 		wrapt.select(slots.get(CHEST_SLOT))
 		digInFront()
 		wrapt.select(slots.get(MISC_SLOT))
 	else
 		error("Something went really wrong")
 	end
 end
 
 local function makeNewChestInPlace(chestData, diggingArea)
 	local newPos = table.remove(chestData.reserved)
 	if not newPos then
 		error("Out of reserved chest spots")
 		return false
 	end
 	chestData.placed = newPos
 
 	local chestPosIndex = helper.getIndex(chestData.placed.x, chestData.placed.y, chestData.placed.z)
 	chestData.reserved[chestPosIndex] = nil
 	local blockAbove = {x = chestData.placed.x, y = chestData.placed.y+1, z = chestData.placed.z}
 	if not goToCoords(diggingArea[helper.getIndex(blockAbove.x, blockAbove.y, blockAbove.z)], diggingArea, PATHFIND_INSIDE_NONPRESERVED_AREA) then
 		helper.printWarning("Could not pathfind to new chest location, trying again ignoring walls...")
 		if not goToCoords(diggingArea[helper.getIndex(blockAbove.x, blockAbove.y, blockAbove.z)], diggingArea, PATHFIND_ANYWHERE_NONPRESERVED) then
 			helper.printWarning("Fallback pathfinding failed")
 			return false
 		end
 	end
 	digBelow()
 	while true do
 		local success = execWithSlot(wrapt.placeDown, CHEST_SLOT)
 		if success then
 			break
 		end
 		local chestData = wrapt.getItemDetail(slots.get(CHEST_SLOT))
 		if not chestData then
 			helper.printWarning("Out of chests. Add chests to slot", slots.get(CHEST_SLOT))
 		end
 ---@diagnostic disable-next-line: undefined-field
 		os.sleep(RETRY_DELAY)
 	end
 	diggingArea[chestPosIndex].preserve = true
 	return true
 end
 
 local function dropOffNormally(chestData, diggingArea)
 	if not chestData.placed then
 		makeNewChestInPlace(chestData, diggingArea)
 	end
 
 	local blockAbove = {x = chestData.placed.x, y = chestData.placed.y+1, z = chestData.placed.z}
 	if not goToCoords(diggingArea[helper.getIndex(blockAbove.x, blockAbove.y, blockAbove.z)], diggingArea, PATHFIND_INSIDE_NONPRESERVED_AREA) then
 		helper.printWarning("Could not pathfind to chest location, trying again ignoring walls...")
 		if not goToCoords(diggingArea[helper.getIndex(blockAbove.x, blockAbove.y, blockAbove.z)], diggingArea, PATHFIND_ANYWHERE_NONPRESERVED) then
 			helper.printWarning("Fallback pathfinding failed too")
 		end
 	end
 	repeat
 		for i=slots.get(MISC_SLOT),16 do
 			wrapt.select(i)
 			if not wrapt.dropDown() and wrapt.getItemDetail(i) then
 				makeNewChestInPlace(chestData, diggingArea)
 				wrapt.dropDown()
 			end
 		end
 	until not wrapt.getItemDetail(16)
 	wrapt.select(slots.get(MISC_SLOT))
 end
 
 local function tryDropOffThings(chestData, diggingArea, entangledChest, force)
 	if not wrapt.getItemDetail(16) and not force then
 		return
 	end
 
 	if entangledChest then
 		dropOffEntangledChest(diggingArea)
 		return
 	end
 
 	dropOffNormally(chestData, diggingArea)
 end
 
 
 
 local function getFuelAndConsumeFromEntangled(suckFunction, dropFunction)
 	local result = false
 	wrapt.select(16)
 	repeat
 		repeat
 			if not suckFunction(32) then
 				helper.printWarning("Refuel chest is empty, retrying...")
 				break
 			end
 			if not wrapt.refuel() then
 				helper.printWarning("Refuel chest contains garbage, retrying...")
 				while not dropFunction() do
 					helper.printWarning("Could not return garbage back to the chest, retrying...")
 ---@diagnostic disable-next-line: undefined-field
 					os.sleep(RETRY_DELAY)
 				end
 				break
 			end
 			result = wrapt.getFuelLevel() > REFUEL_THRESHOLD
 		until result
 		if not result then
 ---@diagnostic disable-next-line: undefined-field
 			os.sleep(RETRY_DELAY)
 		end
 	until result
 end
 
 local function refuelEntangled(chestData, diggingArea, dropOffEntangled)
 	tryDropOffThings(chestData, diggingArea, dropOffEntangled)
 
 	local selectedOption = findSuitableEntangledChestPos(diggingArea)
 	if not selectedOption then return end
 
 	local curPosition = wrapt.getPosition()
 	local delta = {x = selectedOption.x-curPosition.x, y = selectedOption.y-curPosition.y, z = selectedOption.z-curPosition.z}
 	if delta.y < 0 then
 		repeat digBelow() until execWithSlot(wrapt.placeDown, FUEL_CHEST_SLOT)
 		getFuelAndConsumeFromEntangled(wrapt.suckDown, wrapt.dropDown)
 		wrapt.select(slots.get(FUEL_CHEST_SLOT))
 		digBelow()
 		wrapt.select(slots.get(MISC_SLOT))
 	elseif delta.y > 0 then
 		repeat digAbove() until execWithSlot(wrapt.placeUp, FUEL_CHEST_SLOT)
 		getFuelAndConsumeFromEntangled(wrapt.suckUp, wrapt.dropUp)
 		wrapt.select(slots.get(FUEL_CHEST_SLOT))
 		digAbove()
 		wrapt.select(slots.get(MISC_SLOT))
 	elseif delta.x ~= 0 or delta.y ~= 0 or delta.z ~= 0 then
 		local direction = helper.deltaToDirection(delta.x, delta.z)
 		turnTowardsDirection(direction)
 		repeat digInFront() until execWithSlot(wrapt.place, FUEL_CHEST_SLOT)
 		getFuelAndConsumeFromEntangled(wrapt.suck, wrapt.drop)
 		wrapt.select(slots.get(FUEL_CHEST_SLOT))
 		digInFront()
 		wrapt.select(slots.get(MISC_SLOT))
 	else
 		error("Something went really wrong")
 	end
 end
 
 local function refuelNormally()
 	repeat
 		local fuelData = wrapt.getItemDetail(slots.get(FUEL_SLOT))
 		if not fuelData then
 			sortInventory(true)
 		end
 		repeat
 			local newFuelData = wrapt.getItemDetail(slots.get(FUEL_SLOT))
 			if not newFuelData then
 				helper.printWarning("Out of fuel. Put fuel in slot", slots.get(FUEL_SLOT))
 	---@diagnostic disable-next-line: undefined-field
 				os.sleep(RETRY_DELAY)
 				helper.osYield()
 			end
 		until newFuelData
 		execWithSlot(wrapt.refuel, FUEL_SLOT)
 	until wrapt.getFuelLevel() > REFUEL_THRESHOLD
 end
 
 local function tryToRefuel(chestData, diggingArea, dropOffEntangledChest, refuelEntangledChest)
 	if wrapt.getFuelLevel() < REFUEL_THRESHOLD then
 		if refuelEntangledChest then
 			refuelEntangled(chestData, diggingArea, dropOffEntangledChest)
 			return
 		else
 			refuelNormally()
 			return
 		end
 	end
 end
 
 
 
 local function executeDigging(layers, diggingArea, chestData, config)
 	local counter = 0
 	for layerIndex, layer in ipairs(layers) do
 		for blockIndex, block in ipairs(layer) do
 			if counter % 5 == 0 or not wrapt.getItemDetail(slots.get(BLOCK_SLOT)) then
 				sortInventory(not config.useFuelEntangledChest)
 			end
 			if counter % 5 == 0 then
 				tryToRefuel(chestData, diggingArea, config.useEntangledChests, config.useFuelEntangledChest)
 			end
 			tryDropOffThings(chestData, diggingArea, config.useEntangledChests)
 			if not diggingArea[helper.getIndex(block.x, block.y, block.z)].preserve then
 				if not goToCoords(block, diggingArea, PATHFIND_INSIDE_NONPRESERVED_AREA) then
 					helper.printWarning("Couldn't find a path to next block, trying again ingoring walls...")
 					if not goToCoords(block, diggingArea, PATHFIND_ANYWHERE_NONPRESERVED) then
 						helper.printWarning("Fallback pathfinding failed, skipping the block")
 						break
 					end
 				end
 				if block.adjacent then
 					processAdjacent(diggingArea, config)
 				elseif block.triple then
 					processTriple(diggingArea)
 				end
 			end
 			counter = counter + 1
 		end
 	end
 	tryDropOffThings(chestData, diggingArea, config.useEntangledChests, true)
 end
 
 local function getValidatedRegion(config, default)
 	ui.printInfo()
 	ui.printProgramsInfo()
 	while true do
 		local shape = nil
 		if default then
 			shape = ui.parseProgram(config.defaultCommand)
 			if not shape then
 				helper.printError("defaultCommand is invalid")
 				default = false
 			end
 		end
 
 		if not default then
 			shape = ui.promptForShape()
 		end
 
 		local genRegion = shape.shape.generate(table.unpack(shape.args))
 		local validationResult = region.validateRegion(genRegion)
 		if validationResult == SUCCESS then
 			return genRegion
 		end
 		ui.showValidationError(validationResult)
 	end
 end
 
 local function launchDigging(config, default)
 	local diggingArea = getValidatedRegion(config, default)
 	local layers = region.createLayersFromArea(diggingArea, config.layerSeparationAxis)
 	local chestData = region.reserveChests(diggingArea)
 	executeDigging(layers, diggingArea, chestData, config)
 end
 
 
 local function executeMineLoop(config)
 	local cumDelta = {x = 0, y = 0, z = 0}
 	local prevPos = nil
 	while true do
 		--create a region to dig
 		local shape = ui.parseProgram(config.mineLoopCommand)
 		local diggingArea = shape.shape.generate(table.unpack(shape.args))
 		diggingArea = region.shiftRegion(diggingArea, cumDelta)
 		local layers = region.createLayersFromArea(diggingArea, config.layerSeparationAxis)
 		local chestData = region.reserveChests(diggingArea)
 
 		--place chunk loader
 		local chunkLoaderPos = table.remove(chestData.reserved)
 		local chunkLoaderIndex = helper.getIndex(chunkLoaderPos.x, chunkLoaderPos.y, chunkLoaderPos.z)
 		local blockAbove = {x = chunkLoaderPos.x, y = chunkLoaderPos.y+1, z = chunkLoaderPos.z}
 		if prevPos then
 			prevPos.preserve = true
 			diggingArea[helper.getIndex(prevPos.x, prevPos.y, prevPos.z)] = prevPos
 		end
 		if not goToCoords(blockAbove, diggingArea, PATHFIND_ANYWHERE_NONPRESERVED) then
 			helper.printError("Could not navigate to new chunk loader position, aborting...")
 			return
 		end
 		repeat digBelow() until execWithSlot(wrapt.placeDown, CHUNK_LOADER_SLOT)
 		diggingArea[chunkLoaderIndex].preserve = true
 
 		--remove old chunk loader
 		if prevPos then
 			local prevBlockAbove = {x = prevPos.x, y = prevPos.y+1, z = prevPos.z}
 			if not goToCoords(prevBlockAbove, diggingArea, PATHFIND_ANYWHERE_NONPRESERVED) then
 				helper.printError("Could not navigate to previous chunkloader, aborting")
 			end
 			execWithSlot(digBelow, CHUNK_LOADER_SLOT)
 			if not goToCoords(blockAbove, diggingArea, PATHFIND_ANYWHERE_NONPRESERVED) then
 				helper.printError("Could not navigate back from old loader, aborting...")
 				return
 			end
 		end
 
 		--dig the region
 		executeDigging(layers, diggingArea, chestData, config)
 
 		prevPos = chunkLoaderPos
 		cumDelta = {x = cumDelta.x + config.mineLoopOffset.x,y = cumDelta.y + config.mineLoopOffset.y,z = cumDelta.z + config.mineLoopOffset.z}
 	end
 end
 
 local function launchMineLoop(config, autostart)
 	helper.print("Verifying mineLoopCommand...")
 	local shape = ui.parseProgram(config.mineLoopCommand)
 	if not shape then
 		helper.printError("mineLoopCommand is invalid")
 		return
 	end
 	local areaToValidate = shape.shape.generate(table.unpack(shape.args))
 	local validationResult = region.validateRegion(areaToValidate)
 	if validationResult ~= SUCCESS then
 		ui.showValidationError(validationResult)
 		return
 	end
 
 	if not autostart then
 		ui.printInfo()
 		helper.print("Press Enter to start the loop")
 		helper.read()
 	end
 	executeMineLoop(config)
 end
 
 
 
 local function main(...)
 	local args = {...}
 	local config = helper.readOnlyTable(cfg.processConfig())
 	slots.assignSlots(config)
 
 	local default = args[1] == "def"
 
 	if config.mineLoop then
 		launchMineLoop(config, default)
 		return
 	end
 
 	launchDigging(config, default)
 end
 
 main(...)