View difference between Paste ID: HkxvJcSF and ujchRSnU

 -- +--------------------------------------------------------+
 -- |                                                        |
 -- |                        BLittle                         |
 -- |                                                        |
 -- +--------------------------------------------------------+
 
 local version = "Version 1.1.6beta"
 
 -- By Jeffrey Alexander, aka Bomb Bloke.
 -- Convenience functions to make use of ComputerCraft 1.76's new "drawing" characters.
 -- http://www.computercraft.info/forums2/index.php?/topic/25354-cc-176-blittle-api/
 
 -------------------------------------------------------------
 
 if shell then
 	local arg = {...}
 
 	if #arg == 0 then
 		print("Usage:")
 		print("blittle <scriptName> [args]")
 		return
 	end
 
 	if not blittle then os.loadAPI(shell.getRunningProgram()) end
 	local oldTerm = term.redirect(blittle.createWindow())
 	shell.run(unpack(arg))
 	term.redirect(oldTerm)
 
 	return
 end
 
 local relations = {[0] = {8, 4, 3, 6, 5}, {4, 14, 8, 7}, {6, 10, 8, 7}, {9, 11, 8, 0}, {1, 14, 8, 0}, {13, 12, 8, 0}, {2, 10, 8, 0}, {15, 8, 10, 11, 12, 14},
 		{0, 7, 1, 9, 2, 13}, {3, 11, 8, 7}, {2, 6, 7, 15}, {9, 3, 7, 15}, {13, 5, 7, 15}, {5, 12, 8, 7}, {1, 4, 7, 15}, {7, 10, 11, 12, 14}}
 
 local colourNum, exponents, colourChar = {}, {}, {}
 for i = 0, 15 do exponents[2^i] = i end
 do
 	local hex = "0123456789abcdef"
 	for i = 1, 16 do
 		colourNum[hex:sub(i, i)] = i - 1
 		colourNum[i - 1] = hex:sub(i, i)
 		colourChar[hex:sub(i, i)] = 2 ^ (i - 1)
 		colourChar[2 ^ (i - 1)] = hex:sub(i, i)
 
 		local thisRel = relations[i - 1]
 		for i = 1, #thisRel do thisRel[i] = 2 ^ thisRel[i] end
 	end
 end
 
 local function getBestColourMatch(usage)
 	local lastCol = relations[exponents[usage[#usage][1]]]
 
 	for j = 1, #lastCol do
 		local thisRelation = lastCol[j]
 		for i = 1, #usage - 1 do if usage[i][1] == thisRelation then return i end end
 	end
 
 	return 1
 end
 
 local function colsToChar(pattern, totals)
 	if not totals then
 		local newPattern = {}
 		totals = {}
 		for i = 1, 6 do
 			local thisVal = pattern[i]
 			local thisTot = totals[thisVal]
 			totals[thisVal], newPattern[i] = thisTot and (thisTot + 1) or 1, thisVal
 		end
 		pattern = newPattern
 	end
 
 	local usage = {}
 	for key, value in pairs(totals) do usage[#usage + 1] = {key, value} end
 
 	if #usage > 1 then
 		-- Reduce the chunk to two colours:
 		while #usage > 2 do
 			table.sort(usage, function (a, b) return a[2] > b[2] end)
 			local matchToInd, usageLen = getBestColourMatch(usage), #usage
 			local matchFrom, matchTo = usage[usageLen][1], usage[matchToInd][1]
 			for i = 1, 6 do if pattern[i] == matchFrom then
 				pattern[i] = matchTo
 				usage[matchToInd][2] = usage[matchToInd][2] + 1
 			end end
 			usage[usageLen] = nil
 		end
 
 		-- Convert to character. Adapted from oli414's function:
 		-- http://www.computercraft.info/forums2/index.php?/topic/25340-cc-176-easy-drawing-characters/
 		local data = 128
 		for i = 1, #pattern - 1 do if pattern[i] ~= pattern[6] then data = data + 2^(i-1) end end
 		return string.char(data), colourChar[usage[1][1] == pattern[6] and usage[2][1] or usage[1][1]], colourChar[pattern[6]]
 	else
 		-- Solid colour character:
 		return "\128", colourChar[pattern[1]], colourChar[pattern[1]]
 	end
 end
 
 local function snooze()
 	local myEvent = tostring({})
 	os.queueEvent(myEvent)
 	os.pullEvent(myEvent)
 end
 
 function shrink(image, bgCol)
 	local results, width, height, bgCol = {{}, {}, {}}, 0, #image + #image % 3, bgCol or colours.black
 	for i = 1, #image do if #image[i] > width then width = #image[i] end end
 
 	for y = 0, height - 1, 3 do
 		local cRow, tRow, bRow, counter = {}, {}, {}, 1
 
 		for x = 0, width - 1, 2 do
 			-- Grab a 2x3 chunk:
 			local pattern, totals = {}, {}
 
 			for yy = 1, 3 do for xx = 1, 2 do
 				pattern[#pattern + 1] = (image[y + yy] and image[y + yy][x + xx]) and (image[y + yy][x + xx] == 0 and bgCol or image[y + yy][x + xx]) or bgCol
 				totals[pattern[#pattern]] = totals[pattern[#pattern]] and (totals[pattern[#pattern]] + 1) or 1
 			end end
 
 			cRow[counter], tRow[counter], bRow[counter] = colsToChar(pattern, totals)
 			counter = counter + 1
 		end
 
 		results[1][#results[1] + 1], results[2][#results[2] + 1], results[3][#results[3] + 1] = table.concat(cRow), table.concat(tRow), table.concat(bRow)
 	end
 
 	results.width, results.height = #results[1][1], #results[1]
 
 	return results
 end
 
 function shrinkGIF(image, bgCol)
 	if not GIF and not os.loadAPI("GIF") then error("blittle.shrinkGIF: Load GIF API first.", 2) end
 
 	image = GIF.flattenGIF(image)
 	snooze()
 
 	local prev = GIF.toPaintutils(image[1])
 	snooze()
 
 	prev = blittle.shrink(prev, bgCol)
 	prev.delay = image[1].delay
 	image[1] = prev
 	snooze()
 
 	image.width, image.height = prev.width, prev.height
 
 	for i = 2, #image do
 		local temp = GIF.toPaintutils(image[i])
 		snooze()
 
 		temp = blittle.shrink(temp, bgCol)
 		snooze()
 
 		local newImage = {{}, {}, {}, ["delay"] = image[i].delay, ["width"] = temp.width, ["height"] = 0}
 
 		local a, b, c, pa, pb, pc = temp[1], temp[2], temp[3], prev[1], prev[2], prev[3]
 		for i = 1, temp.height do
 			local a1, b1, c1, pa1, pb1, pc1 = a[i], b[i], c[i], pa[i], pb[i], pc[i]
 
 			if a1 ~= pa1 or b1 ~= pb1 or c1 ~= pc1 then
 				local min, max = 1, #a1
 				local a2, b2, c2, pa2, pb2, pc2 = {a1:byte(1, max)}, {b1:byte(1, max)}, {c1:byte(1, max)}, {pa1:byte(1, max)}, {pb1:byte(1, max)}, {pc1:byte(1, max)}
 
 				for j = 1, max do if a2[j] ~= pa2[j] or b2[j] ~= pb2[j] or c2[j] ~= pc2[j] then
 					min = j
 					break
 				end end
 
 				for j = max, min, -1 do if a2[j] ~= pa2[j] or b2[j] ~= pb2[j] or c2[j] ~= pc2[j] then
 					max = j
 					break
 				end end
 
 				newImage[1][i], newImage[2][i], newImage[3][i], newImage.height = min > 1 and {min - 1, a1:sub(min, max)} or a1:sub(min, max), b1:sub(min, max), c1:sub(min, max), i
 			end
 
 			snooze()
 		end
 
 		image[i], prev = newImage, temp
 
 		for j = 1, i - 1 do
 			local oldImage = image[j]
 
 			if type(oldImage[1]) == "table" and oldImage.height == newImage.height then
 				local same = true
 
 				for k = 1, oldImage.height do
 					local comp1, comp2 = oldImage[1][k], newImage[1][k]
 
 					if type(comp1) ~= type(comp2) or
 						(type(comp1) == "string" and comp1 ~= comp2) or
 						(type(comp1) == "table" and (comp1[1] ~= comp2[1] or comp1[2] ~= comp2[2])) or
 						oldImage[2][k] ~= newImage[2][k] or
 						oldImage[3][k] ~= newImage[3][k] then
 							same = false
 							break
 					end
 				end
 
 				if same then
 					newImage[1], newImage[2], newImage[3] = j
 					break
 				end
 			end
 
 			snooze()
 		end
 	end
 
 	return image
 end
 
 local function newLine(width, bCol)
 	local line = {}
 	for i = 1, width do line[i] = {bCol, bCol, bCol, bCol, bCol, bCol} end
 	return line
 end
 
 function createWindow(parent, x, y, width, height, visible)
 	if parent == term or not parent then
 		parent = term.current()
 	elseif type(parent) ~= "table" or not parent.write then
 		error("blittle.newWindow: \"parent\" does not appear to be a terminal object.", 2)
 	end
 
 	local workBuffer, backBuffer, frontBuffer, window, tCol, bCol, curX, curY, blink, cWidth, cHeight, pal = {}, {}, {}, {}, colours.white, colours.black, 1, 1, false
 	if type(visible) ~= "boolean" then visible = true end
 	x, y = x and math.floor(x) or 1, y and math.floor(y) or 1
 
 	do
 		local xSize, ySize = parent.getSize()
 		cWidth, cHeight = (width or xSize), (height or ySize)
 		width, height = cWidth * 2, cHeight * 3
 	end
 
 	if parent.setPaletteColour then
 		pal = {}
 
 		local counter = 1
 		for i = 1, 16 do
 			pal[counter] = {parent.getPaletteColour(counter)}
 			counter = counter * 2
 		end
 
 		window.getPaletteColour = function(colour)
 			return unpack(pal[colour])
 		end
 
 		window.setPaletteColour = function(colour, r, g, b)
 			pal[colour] = {r, g, b}
 			if visible then return parent.setPaletteColour(colour, r, g, b) end
 		end
 
 		window.getPaletteColor, window.setPaletteColor = window.getPaletteColour, window.setPaletteColour
 	end
 
 	window.blit = function(_, _, bC)
 		local bClen = #bC
 		if curX > width or curX + bClen < 2 or curY < 1 or curY > height then
 			curX = curX + bClen
 			return
 		end
 
 		if curX < 1 then
 			bC = bC:sub(2 - curX)
 			curX, bClen = 1, #bC
 		end
 
 		if curX + bClen - 1 > width then bC, bClen = bC:sub(1, width - curX + 1), width - curX + 1 end
 
 		local colNum, rowNum, thisX, yBump = math.floor((curX - 1) / 2) + 1, math.floor((curY - 1) / 3) + 1, (curX - 1) % 2, ((curY - 1) % 3) * 2
 		local firstColNum, lastColNum, thisRow = colNum, math.floor((curX + bClen) / 2), backBuffer[rowNum]
 		local thisChar = thisRow[colNum]
 
 		for i = 1, bClen do
 			thisChar[thisX + yBump + 1] = colourChar[bC:sub(i, i)]
 
 			if thisX == 1 then
 				thisX, colNum = 0, colNum + 1
 				thisChar = thisRow[colNum]
 				if not thisChar then break end
 			else thisX = 1 end
 		end
 
 		if visible then
 			local chars1, chars2, chars3, count = {}, {}, {}, 1
 
 			for i = firstColNum, lastColNum do
 				chars1[count], chars2[count], chars3[count] = colsToChar(thisRow[i])
 				count = count + 1
 			end
 
 			chars1, chars2, chars3 = table.concat(chars1), table.concat(chars2), table.concat(chars3)
 			parent.setCursorPos(x + math.floor((curX - 1) / 2), y + math.floor((curY - 1) / 3))
 			parent.blit(chars1, chars2, chars3)
 			local thisRow = frontBuffer[rowNum]
 			frontBuffer[rowNum] = {thisRow[1]:sub(1, firstColNum - 1) .. chars1 .. thisRow[1]:sub(lastColNum + 1), thisRow[2]:sub(1, firstColNum - 1) .. chars2 .. thisRow[2]:sub(lastColNum + 1), thisRow[3]:sub(1, firstColNum - 1) .. chars3 .. thisRow[3]:sub(lastColNum + 1)}
 		else
 			local thisRow = workBuffer[rowNum]
 
 			if (not thisRow[firstColNum]) or thisRow[firstColNum] < lastColNum then
 				local x, newLastColNum = 1, lastColNum
 
 				while x <= lastColNum + 1 do
 					local thisSpot = thisRow[x]
 
 					if thisSpot then
 						if thisSpot >= firstColNum - 1 then
 							if x < firstColNum then firstColNum = x else thisRow[x] = nil end
 							if thisSpot > newLastColNum then newLastColNum = thisSpot end
 						end
 						x = thisSpot + 1
 					else x = x + 1 end
 				end
 
 				thisRow[firstColNum] = newLastColNum
 				if thisRow.max <= newLastColNum then thisRow.max = firstColNum end
 			end
 		end
 
 		curX = curX + bClen
 	end
 
 	window.write = function(text)
 		window.blit(nil, nil, string.rep(colourChar[bCol], #tostring(text)))
 	end
 
 	window.clearLine = function()
 		local oldX = curX
 		curX = 1
 		window.blit(nil, nil, string.rep(colourChar[bCol], width))
 		curX = oldX
 	end
 
 	window.clear = function()
 		local t, fC, bC = string.rep("\128", cWidth), string.rep(colourChar[tCol], cWidth), string.rep(colourChar[bCol], cWidth)
 		for y = 1, cHeight do workBuffer[y], backBuffer[y], frontBuffer[y] = {["max"] = 0}, newLine(cWidth, bCol), {t, fC, bC} end
 		window.redraw()
 	end
 
 	window.getCursorPos = function()
 		return curX, curY
 	end
 
 	window.setCursorPos = function(newX, newY)
 		curX, curY = math.floor(newX), math.floor(newY)
 		if visible and blink then window.restoreCursor() end
 	end
 
 	window.restoreCursor = function() end
 	window.setCursorBlink = window.restoreCursor
 
 	window.isColour = function()
 		return parent.isColour()
 	end
 	window.isColor = window.isColour
 
 	window.getSize = function()
 		return width, height
 	end
 
 	window.scroll = function(lines)
 		lines = math.floor(lines)
 
 		if lines ~= 0 then
 			if lines % 3 == 0 then
 				local newWB, newBB, newFB, line1, line2, line3 = {}, {}, {}, string.rep("\128", cWidth), string.rep(colourChar[tCol], cWidth), string.rep(colourChar[bCol], cWidth)
 				for y = 1, cHeight do newWB[y], newBB[y], newFB[y] = workBuffer[y + lines] or {["max"] = 0}, backBuffer[y + lines] or newLine(cWidth, bCol), frontBuffer[y + lines] or {line1, line2, line3} end
 				workBuffer, backBuffer, frontBuffer = newWB, newBB, newFB
 			else
 				local newBB, tRowNum, tBump, sRowNum, sBump = {}, 1, 0, math.floor(lines / 3) + 1, (lines % 3) * 2
 				local sRow, tRow = backBuffer[sRowNum], {}
 				for x = 1, cWidth do tRow[x] = {} end
 
 				for y = 1, height do
 					if sRow then
 						for x = 1, cWidth do
 							local tChar, sChar = tRow[x], sRow[x]
 							tChar[tBump + 1], tChar[tBump + 2] = sChar[sBump + 1], sChar[sBump + 2]
 						end
 					else
 						for x = 1, cWidth do
 							local tChar = tRow[x]
 							tChar[tBump + 1], tChar[tBump + 2] = bCol, bCol
 						end
 					end
 
 					tBump, sBump = tBump + 2, sBump + 2
 
 					if tBump > 4 then
 						tBump, newBB[tRowNum] = 0, tRow
 						tRowNum, tRow = tRowNum + 1, {}
 						for x = 1, cWidth do tRow[x] = {} end
 					end
 
 					if sBump > 4 then
 						sRowNum, sBump = sRowNum + 1, 0
 						sRow = backBuffer[sRowNum]
 					end
 				end
 
 				for y = 1, cHeight do workBuffer[y] = {["max"] = 1, cWidth} end
 
 				backBuffer = newBB
 			end
 
 			window.redraw()
 		end
 	end
 
 	window.setTextColour = function(newCol)
 		tCol = newCol
 	end
 	window.setTextColor = window.setTextColour
 
 	window.setBackgroundColour = function(newCol)
 		bCol = newCol
 	end
 	window.setBackgroundColor = window.setBackgroundColour
 
 	window.getTextColour = function()
 		return tCol
 	end
 	window.getTextColor = window.getTextColour
 
 	window.getBackgroundColour = function()
 		return bCol
 	end
 	window.getBackgroundColor = window.getBackgroundColour
 
 	window.redraw = function()
 		if visible then
 			for i = 1, cHeight do
 				local work, front = workBuffer[i], frontBuffer[i]
 				local front1, front2, front3 = front[1], front[2], front[3]
 
 				if work.max > 0 then
 					local line1, line2, line3, lineLen, skip, back, count = {}, {}, {}, 1, 0, backBuffer[i], 1
 
 					while count <= work.max do if work[count] then
 						if skip > 0 then
 							line1[lineLen], line2[lineLen], line3[lineLen] = front1:sub(count - skip, count - 1), front2:sub(count - skip, count - 1), front3:sub(count - skip, count - 1)
 							skip, lineLen = 0, lineLen + 1
 						end
 
 						for i = count, work[count] do
 							line1[lineLen], line2[lineLen], line3[lineLen] = colsToChar(back[i])
 							lineLen = lineLen + 1
 						end
 
 						count = work[count] + 1
 					else skip, count = skip + 1, count + 1 end end
 
 					if count < cWidth + 1 then line1[lineLen], line2[lineLen], line3[lineLen] = front1:sub(count), front2:sub(count), front3:sub(count) end
 
 					front1, front2, front3 = table.concat(line1), table.concat(line2), table.concat(line3)
 					frontBuffer[i], workBuffer[i] = {front1, front2, front3}, {["max"] = 0}
 				end
 
 				parent.setCursorPos(x, y + i - 1)
 				parent.blit(front1, front2, front3)
 			end
 
 			if pal then
 				local counter = 1
 				for i = 1, 16 do
 					parent.setPaletteColour(counter, unpack(pal[counter]))
 					counter = counter * 2
 				end
 			end
 		end
 	end
 
 	window.setVisible = function(newVis)
 		newVis = newVis and true or false
 
 		if newVis and not visible then
 			visible = true
 			window.redraw()
 		else visible = newVis end
 	end
 
 	window.getPosition = function()
 		return x, y
 	end
 
 	window.reposition = function(newX, newY, newWidth, newHeight)
 		x, y = type(newX) == "number" and math.floor(newX) or x, type(newY) == "number" and math.floor(newY) or y
 
 		if type(newWidth) == "number" then
 			newWidth = math.floor(newWidth)
 			if newWidth > cWidth then
 				local line1, line2, line3 = string.rep("\128", newWidth - cWidth), string.rep(colourChar[tCol], newWidth - cWidth), string.rep(colourChar[bCol], newWidth - cWidth)
 				for y = 1, cHeight do
 					local bRow, fRow = backBuffer[y], frontBuffer[y]
 					for x = cWidth + 1, newWidth do bRow[x] = {bCol, bCol, bCol, bCol, bCol, bCol} end
 					frontBuffer[y] = {fRow[1] .. line3, fRow[2] .. line2, fRow[3] .. line3}
 				end
 			elseif newWidth < cWidth then
 				for y = 1, cHeight do
 					local wRow, bRow, fRow = workBuffer[y], backBuffer[y], frontBuffer[y]
 					for x = newWidth + 1, cWidth do bRow[x] = nil end
 					frontBuffer[y] = {fRow[1]:sub(1, newWidth), fRow[2]:sub(1, newWidth), fRow[3]:sub(1, newWidth)}
 
 					while wRow[wRow.max] and wRow[wRow.max] > newWidth do
 						wRow[wRow.max] = nil
 						wRow.max = table.maxn(wRow)
 					end
 				end
 			end
 			width, cWidth = newWidth * 2, newWidth
 		end
 
 		if type(newHeight) == "number" then
 			newHeight = math.floor(newHeight)
 			if newHeight > cHeight then
 				local line1, line2, line3 = string.rep("\128", cWidth), string.rep(colourChar[tCol], cWidth), string.rep(colourChar[bCol], cWidth)
 				for y = cHeight + 1, newHeight do workBuffer[y], backBuffer[y], frontBuffer[y] = {["max"] = 0}, newLine(cWidth, bCol), {line1, line2, line3} end
 			elseif newHeight < cHeight then
 				for y = newHeight + 1, cHeight do workBuffer[y], backBuffer[y], frontBuffer[y] = nil, nil, nil end
 			end
 			height, cHeight = newHeight * 3, newHeight
 		end
 
 		window.redraw()
 	end
 
 	window.clear()
 	return window
 end
 
 function draw(image, x, y, terminal)
 	local t, tC, bC = image[1], image[2], image[3]
 	x, y, terminal = x or 1, y or 1, terminal or term.current()
 
 	for i = 1, image.height do
 		local tI = t[i]
 		if type(tI) == "string" then
 			terminal.setCursorPos(x, y + i - 1)
 			terminal.blit(tI, tC[i], bC[i])
 		elseif type(tI) == "table" then
 			terminal.setCursorPos(x + tI[1], y + i - 1)
 			terminal.blit(tI[2], tC[i], bC[i])
 		end
 	end
 end
 
 function save(image, filename)
 	local output = fs.open(filename, "wb")
 	if not output then error("Can't open "..filename.." for output.") end
 
 	local writeByte = output.write
 
 	local function writeInt(num)
 		writeByte(bit.band(num, 255))
 		writeByte(bit.brshift(num, 8))
 	end
 
 	writeByte(66)  -- B
 	writeByte(76)  -- L
 	writeByte(84)  -- T
 
 	local animated = image[1].delay ~= nil
 	writeByte(animated and 1 or 0)
 
 	if animated then
 		writeInt(#image)
 	else
 		local tempImage = {image[1], image[2], image[3]}
 		image[1], image[2], image[3] = tempImage, nil, nil
 	end
 
 	local width, height = image.width, image.height
 
 	writeInt(width)
 	writeInt(height)
 
 	for k = 1, #image do
 		local thisImage = image[k]
 
 		if type(thisImage[1]) == "number" then
 			writeByte(3)
 			writeInt(thisImage[1])
 		else
 			for i = 1, height do
 				if thisImage[1][i] then
 					local rowType, len, thisRow = type(thisImage[1][i])
 
 					if rowType == "string" then
 						writeByte(1)
 						len = #thisImage[1][i]
 						writeInt(len)
 						thisRow = {thisImage[1][i]:byte(1, len)}
 					elseif rowType == "table" then
 						writeByte(2)
 						len = #thisImage[1][i][2]
 						writeInt(len)
 						writeInt(thisImage[1][i][1])
 						thisRow = {thisImage[1][i][2]:byte(1, len)}
 					else
 						error("Malformed row record #"..i.." in frame #"..k.." when attempting to save \""..filename.."\", type is "..rowType..".")
 					end
 
 					for x = 1, len do writeByte(thisRow[x]) end
 
 					local txt, bg = thisImage[2][i], thisImage[3][i]
 					for x = 1, len do writeByte(colourNum[txt:sub(x, x)] + colourNum[bg:sub(x, x)] * 16) end
 				else writeByte(0) end
 			end
 		end
 
 		if animated then writeInt(thisImage.delay * 20) end
 
 		snooze()
 	end
 
 	if image.pal then
 		writeByte(#image.pal)
 		for i = 0, #image.pal do for j = 1, 3 do writeByte(image.pal[i][j]) end end
 	end
 
 	if not animated then
 		image[2], image[3] = image[1][2], image[1][3]
 		image[1] = image[1][1]
 	end
 
 	output.close()
 end
 
 function load(filename)
 	local input = fs.open(filename, "rb")
 	if not input then error("Can't open "..filename.." for input.") end
 
 	local read = input.read
 
 	local function readInt()
 		local result = read()
 		return result + bit.blshift(read(), 8)
 	end
 
 	if string.char(read(), read(), read()) ~= "BLT" then
 		-- Assume legacy format.
 		input.close()
 		input = fs.open(filename, "rb")
 
 		read = input.read
 
 		function readInt()
 			local result = input.read()
 			return result + bit.blshift(input.read(), 8)
 		end
 
 		local image = {}
 		image.width, image.height = readInt(), readInt()
 
 		for i = 1, 3 do
 			local thisSet = {}
 			for y = 1, image.height do
 				local thisRow = {}
 				for x = 1, image.width do thisRow[x] = string.char(input.read()) end
 				thisSet[y] = table.concat(thisRow)
 			end
 			image[i] = thisSet
 		end
 
 		input.close()
 
 		return image
 	end
 
 	local image, animated, frames = {}, read() == 1
 	if animated then frames = readInt() else frames = 1 end
 
 	local width, height = readInt(), readInt()
 	image.width, image.height = width, height
 
 	for k = 1, frames do
 		local thisImage = {["width"] = width, ["height"] = 0}
 		local chr, txt, bg = {}, {}, {}
 
 		for i = 1, height do
 			local lineType = read()
 
 			if lineType == 3 then
 				chr, txt, bg = readInt()
 				break
 			elseif lineType > 0 then
 				local l1, l2, len, bump = {}, {}, readInt()
 				if lineType == 2 then bump = readInt() end
 
 				for x = 1, len do l1[x] = read() end
 				chr[i] = string.char(unpack(l1))
 				if lineType == 2 then chr[i] = {bump, chr[i]} end
 
 				for x = 1, len do
 					local thisVal = read()
 					l1[x], l2[x] = colourNum[bit.band(thisVal, 15)], colourNum[bit.brshift(thisVal, 4)]
 				end
 
 				txt[i], bg[i], thisImage.height = table.concat(l1), table.concat(l2), i
 			end
 		end
 
 		if animated then thisImage["delay"] = readInt() / 20 end
 		thisImage[1], thisImage[2], thisImage[3] = chr, txt, bg
 		image[k] = thisImage
 
 		snooze()
 	end
 
 	local palLength = read()
 	if palLength and palLength > 0 then
 		image.pal = {}
 		for i = 0, palLength do image.pal[i] = {read(), read(), read()} end
 	end
 
 	if not animated then
 		image[2], image[3] = image[1][2], image[1][3]
 		image[1] = image[1][1]
 	end
 
 	input.close()
 
 	return image
 end
 
 if term.setPaletteColour then
 	function applyPalette(image, terminal)
 		terminal = terminal or term
 
 		local col, pal = 1, image.pal
 
 		for i = 0, #pal do
 			local thisCol = pal[i]
 			terminal.setPaletteColour(col, thisCol[1] / 255, thisCol[2] / 255, thisCol[3] / 255)
 			col = col * 2
 		end
 	end
 end