Update halyde/kernel/modules/terminal.lua

(The text field for the save path needs improving though.)

halyde/apps/bedit.lua

@@ -69,6 +69,73 @@ local function removeLine(pos)
   lines[length] = nil
 end
 
+local function save()
+  gpu.setForeground(0xFFFFFF)
+  gpu.setBackground(0x000000)
+  gpu.set(1, resY, "Enter a location to save:")
+
+  local savepath = file or ""
+  local saveCursorX = 27 + #savepath
+  local ready = false
+  local eventArgs = {}
+
+  gpu.fill(27, resY, resX - 27, 1, " ")
+  gpu.set(27, resY, savepath)
+  gpu.setForeground(0x000000)
+  gpu.setBackground(0xFFFFFF)
+  gpu.set(saveCursorX, resY, " ")
+  gpu.setForeground(0xFFFFFF)
+  gpu.setBackground(0x000000)
+
+  repeat
+    local shouldRender = false
+    coroutine.yield()
+
+    eventArgs = {event.pull("key_down", 0)}
+    if keyboard.keys[eventArgs[4]] == "enter" then
+      ready = true
+    end
+    if keyboard.keys[eventArgs[4]] == "back" then
+      savepath = string.sub(savepath, 1, #savepath - 1)
+      if saveCursorX > 27 then
+        saveCursorX = saveCursorX - 1
+      end
+      shouldRender = true
+    end
+    if not keyboard.keys.special[eventArgs[4]] and keyboard.keys[eventArgs[4]] then
+      savepath = savepath .. (string.char(eventArgs[3]) or "")
+      saveCursorX = saveCursorX + 1
+      shouldRender = true
+    end
+
+    if shouldRender then
+      gpu.fill(27, resY, resX - 27, 1, " ")
+      gpu.set(27, resY, savepath)
+      gpu.setForeground(0x000000)
+      gpu.setBackground(0xFFFFFF)
+      gpu.set(saveCursorX, resY, " ")
+      gpu.setForeground(0xFFFFFF)
+      gpu.setBackground(0x000000)
+    end
+  until ready
+
+  gpu.fill(1, resY, resX, 1, " ")
+  gpu.setForeground(0x000000)
+  gpu.setBackground(0xFFFFFF)
+  gpu.set(1, resY, "^X")
+  gpu.set(10, resY, "^S")
+  gpu.setForeground(0xFFFFFF)
+  gpu.setBackground(0x000000)
+  gpu.set(4, resY, "Exit")
+  gpu.set(13, resY, "Save")
+
+  local text = table.concat(lines, "\n")
+  local handle = fs.open(savepath, "w")
+  handle:write(text)
+  handle:close()
+  file = savepath
+end
+
 -- Initialize screen
 renderText(0, 0)
 gpu.setForeground(0x000000)
@@ -118,99 +185,102 @@ while true do
         if keyboard.keys[eventArgs[4]] == "x" then
           goto exit
         end
-      end
+        if keyboard.keys[eventArgs[4]] == "s" then
-
+          save()
-      if keyboard.keys[eventArgs[4]] == "up" and cursorY > 1 then
+        end
-        if cursorY - scrollY <= 1 then
+      else
-          renderBufferFlag = true
+        if keyboard.keys[eventArgs[4]] == "up" and cursorY > 1 then
-          scrollY = scrollY - 1
+          if cursorY - scrollY <= 1 then
-        else
+            renderBufferFlag = true
-          if not previousCursorX and not previousCursorY then
+            scrollY = scrollY - 1
-            previousCursorX = cursorX
+          else
-            previousCursorY = cursorY
+            if not previousCursorX and not previousCursorY then
+              previousCursorX = cursorX
+              previousCursorY = cursorY
+            end
+          end
+          cursorY = cursorY - 1
+          -- The cursor absolute position still has to be moved, even if on-screen it won't move
+          if cursorX > string.len(lines[cursorY]) + 1 then -- cursor snapping, +1 to be 1 char in front of end of line
+              cursorX = string.len(lines[cursorY]) + 1
           end
         end
-        cursorY = cursorY - 1
+        if keyboard.keys[eventArgs[4]] == "down" then
-        -- The cursor absolute position still has to be moved, even if on-screen it won't move
+          if cursorY - scrollY >= resY - 1 then
-        if cursorX > string.len(lines[cursorY]) + 1 then -- cursor snapping, +1 to be 1 char in front of end of line
+            renderBufferFlag = true
-            cursorX = string.len(lines[cursorY]) + 1
+            scrollY = scrollY + 1
-        end
+          else
-      end
+            if not previousCursorX and not previousCursorY then
-      if keyboard.keys[eventArgs[4]] == "down" then
+              previousCursorX = cursorX
-        if cursorY - scrollY >= resY - 1 then
+              previousCursorY = cursorY
-          renderBufferFlag = true
+            end
-          scrollY = scrollY + 1
+          end
-        else
+          cursorY = cursorY + 1
-          if not previousCursorX and not previousCursorY then
+          if cursorX > string.len(lines[cursorY]) + 1 then
-            previousCursorX = cursorX
+              cursorX = string.len(lines[cursorY]) + 1
-            previousCursorY = cursorY
           end
         end
-        cursorY = cursorY + 1
+        if keyboard.keys[eventArgs[4]] == "left" and cursorX > 1 then
-        if cursorX > string.len(lines[cursorY]) + 1 then
+          if cursorX - scrollX <= 1 then
-            cursorX = string.len(lines[cursorY]) + 1
+            renderBufferFlag = true
-        end
+            scrollX = scrollX - 1
-      end
+          else
-      if keyboard.keys[eventArgs[4]] == "left" and cursorX > 1 then
+            if not previousCursorX and not previousCursorY then
-        if cursorX - scrollX <= 1 then
+              previousCursorX = cursorX
-          renderBufferFlag = true
+              previousCursorY = cursorY
-          scrollX = scrollX - 1
+            end
-        else
-          if not previousCursorX and not previousCursorY then
-            previousCursorX = cursorX
-            previousCursorY = cursorY
           end
-        end
-        cursorX = cursorX - 1
-      end
-      if keyboard.keys[eventArgs[4]] == "right" and cursorX < string.len(lines[cursorY]) + 1 then
-        if cursorX - scrollX >= resX then
-          renderBufferFlag = true
-          scrollX = scrollX + 1
-        else
-          if not previousCursorX and not previousCursorY then
-            previousCursorX = cursorX
-            previousCursorY = cursorY
-          end
-        end
-        cursorX = cursorX + 1
-      end
-      if not keyboard.keys.special[eventArgs[4]] then
-        local line = lines[cursorY] or ""
-        line = string.sub(line, 1, cursorX - 1) .. string.char(eventArgs[3]) .. string.sub(line, cursorX, -1)
-        lines[cursorY] = line
-        cursorX = cursorX + 1
-        renderBufferFlag = true
-      end
-      if keyboard.keys[eventArgs[4]] == "back" then
-        local line = lines[cursorY]
-        local prevline = lines[cursorY - 1]
-        if cursorX > 1 then
-          line = string.sub(line, 1, cursorX - 2) .. string.sub(line, cursorX, -1) -- remove 1 char
-        elseif prevline then
-          prevline = prevline .. line -- copy line up to the next before removing it
-          ocelot.log(prevline)
-          line = nil
-        end
-        if line then
-          lines[cursorY] = line
-        else
-          removeLine(cursorY)
-        end
-        lines[cursorY - 1] = prevline
-        if not line then
-          cursorY = cursorY - 1 -- this can only trigger if the line is not the first
-        end
-        if cursorX > 1 then
           cursorX = cursorX - 1
         end
-        renderBufferFlag = true
+        if keyboard.keys[eventArgs[4]] == "right" and cursorX < string.len(lines[cursorY]) + 1 then
-      end
+          if cursorX - scrollX >= resX then
-      if keyboard.keys[eventArgs[4]] == "enter" then
+            renderBufferFlag = true
-        addLine(cursorY + 1)
+            scrollX = scrollX + 1
-        cursorY = cursorY + 1
+          else
-        cursorX = 1
+            if not previousCursorX and not previousCursorY then
-        renderBufferFlag = true
+              previousCursorX = cursorX
+              previousCursorY = cursorY
+            end
+          end
+          cursorX = cursorX + 1
+        end
+        if not keyboard.keys.special[eventArgs[4]] then
+          local line = lines[cursorY] or ""
+          line = string.sub(line, 1, cursorX - 1) .. string.char(eventArgs[3]) .. string.sub(line, cursorX, -1)
+          lines[cursorY] = line
+          cursorX = cursorX + 1
+          renderBufferFlag = true
+        end
+        if keyboard.keys[eventArgs[4]] == "back" then
+          local line = lines[cursorY]
+          local prevline = lines[cursorY - 1]
+          if cursorX > 1 then
+            line = string.sub(line, 1, cursorX - 2) .. string.sub(line, cursorX, -1) -- remove 1 char
+          elseif prevline then
+            prevline = prevline .. line -- copy line up to the next before removing it
+            ocelot.log(prevline)
+            line = nil
+          end
+          if line then
+            lines[cursorY] = line
+          else
+            removeLine(cursorY)
+          end
+          lines[cursorY - 1] = prevline
+          if not line then
+            cursorY = cursorY - 1 -- this can only trigger if the line is not the first
+          end
+          if cursorX > 1 then
+            cursorX = cursorX - 1
+          end
+          renderBufferFlag = true
+        end
+        if keyboard.keys[eventArgs[4]] == "enter" then
+          addLine(cursorY + 1)
+          cursorY = cursorY + 1
+          cursorX = 1
+          renderBufferFlag = true
+        end
       end
     end
   until next(eventArgs) == nil

halyde/apps/boing.lua

@@ -0,0 +1,585 @@
+local raster = require("raster")
+local event = require("event")
+
+local color_table = {
+  0xAAAAAA, 0x666666, 0xFF0000, 0xFF0000, 0xFFDDDD, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF,
+  0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFF0000, 0xFF0000, 0xFF0000, 0xFF0000, 0xFF0000,
+  0xAA00AA, 0x660066, 0xFF0000, 0xFF0000, 0xFFDDDD, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF,
+  0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFF0000, 0xFF0000, 0xFF0000, 0xFF0000, 0xFF0000
+}
+
+local ball_bitplanes = {
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0007, 0xff80, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0x001f, 0xffff, 0xfc00, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x00f8, 0x007f, 0xffff, 0xff80, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0fe6, 0x03ff, 0xffff, 0xfff0, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0xfd1b, 0x980f, 0xffff, 0xfffc, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x000f, 0xc14e, 0xb410, 0xffff, 0xffff, 0x8000, 0x0000,
+  0x0000, 0x0000, 0x00fc, 0x927a, 0xe92a, 0x7fff, 0xffff, 0xf000, 0x0000,
+  0x0000, 0x0000, 0x00c5, 0x09db, 0xa26f, 0x6fff, 0xffff, 0xfe00, 0x0000,
+  0x0000, 0x0000, 0x01d0, 0x46ee, 0xc4d2, 0x0fff, 0xffff, 0xff80, 0x0000,
+  0x0000, 0x0000, 0x0bba, 0x3bbd, 0x99b2, 0xd5bf, 0xffff, 0xffc0, 0x0000,
+  0x0000, 0x0000, 0x0d76, 0x5ef6, 0x3324, 0xd57f, 0xffff, 0xffe0, 0x0000,
+  0x0000, 0x0000, 0x5dec, 0x8fdc, 0x4665, 0xd55f, 0xffff, 0xfff0, 0x0000,
+  0x0000, 0x0000, 0xab99, 0x18f8, 0x8ccd, 0x9455, 0xffff, 0xfff8, 0x0000,
+  0x0000, 0x0002, 0xd772, 0x3103, 0x19c9, 0x96aa, 0xffff, 0xfffc, 0x0000,
+  0x0000, 0x000d, 0xaecc, 0x6238, 0x3199, 0x96aa, 0x6fff, 0xfffe, 0x0000,
+  0x0000, 0x001a, 0xbd98, 0xc673, 0x8399, 0xb695, 0x97ff, 0xffff, 0x8000,
+  0x0000, 0x006d, 0x7331, 0x8c73, 0x1b39, 0xb255, 0xbbff, 0xffff, 0xc000,
+  0x0000, 0x00d2, 0xe663, 0x18e7, 0x30f3, 0x324a, 0x9dff, 0xffff, 0xe000,
+  0x0000, 0x0fa5, 0xccc3, 0x31ce, 0x31c3, 0x324b, 0xebff, 0xffff, 0xf000,
+  0x0000, 0x1917, 0xb986, 0x23ce, 0x618c, 0x336d, 0x71ff, 0xffff, 0xf800,
+  0x0000, 0x1ade, 0x670c, 0x639c, 0x639c, 0xc325, 0xa8ff, 0xffff, 0xfc00,
+  0x0000, 0x32a3, 0xce18, 0xc73c, 0xc319, 0xcf26, 0xf37f, 0xffff, 0xfe00,
+  0x0000, 0x35a6, 0x7c31, 0x8e38, 0xc719, 0xccf2, 0xd5df, 0xffff, 0xff00,
+  0x0000, 0x6946, 0xc463, 0x1e71, 0x8739, 0x8ccf, 0x7a6f, 0xffff, 0xff00,
+  0x0000, 0xcacc, 0xc707, 0x1c71, 0x8e31, 0x9ccc, 0x6d37, 0xffff, 0xff80,
+  0x0000, 0xd69d, 0x8e7e, 0x38e3, 0x0e33, 0x98cc, 0xcd4b, 0xffff, 0xff80,
+  0x0001, 0x9599, 0x8e73, 0xb9e3, 0x1c73, 0x98cc, 0xc9b7, 0xffff, 0xffc0,
+  0x0001, 0xad33, 0x1ce3, 0x81c6, 0x1c63, 0x98cc, 0xc92b, 0xffff, 0xffc0,
+  0x0003, 0x4b33, 0x1ce7, 0x0dc6, 0x3c63, 0x18cc, 0xc92b, 0xffff, 0xffe0,
+  0x0003, 0x5666, 0x39c7, 0x1c4c, 0x38e7, 0x18cc, 0xccaa, 0x3fff, 0xffe0,
+  0x0006, 0x96e6, 0x39ce, 0x1872, 0x78c7, 0x19cc, 0xc495, 0x3fff, 0xfff0,
+  0x000d, 0x2ccc, 0x738e, 0x38f3, 0xb0c7, 0x19cc, 0xc495, 0x1fff, 0xfff0,
+  0x000d, 0x5dcc, 0x739c, 0x30e7, 0x89c7, 0x39ce, 0xc495, 0x1fff, 0xfff0,
+  0x001a, 0x5b98, 0xe71c, 0x71e7, 0x0f8e, 0x31ce, 0x64d4, 0xffff, 0xfff8,
+  0x001a, 0xbb18, 0xe738, 0x71cf, 0x1e4e, 0x31ce, 0x64ca, 0x8fff, 0xfff8,
+  0x0008, 0xb731, 0xce38, 0xe1ce, 0x1c71, 0x31ce, 0x664a, 0x8fff, 0xfffc,
+  0x000a, 0xf631, 0xce78, 0xe38e, 0x3cf1, 0xf1ce, 0x664a, 0x77ff, 0xfffc,
+  0x000a, 0x9e63, 0x9c71, 0xc39e, 0x3ce3, 0xc9ce, 0x6649, 0x47ff, 0xfffe,
+  0x000a, 0x9063, 0x9cf1, 0xc71c, 0x38e3, 0x8ece, 0x6261, 0x5fff, 0xfffe,
+  0x0004, 0x9327, 0x38e3, 0x873c, 0x78e3, 0x9e36, 0x6265, 0x1bff, 0xffff,
+  0x0015, 0x933f, 0x39e3, 0x8e38, 0x79e3, 0x9c30, 0x6264, 0x23ff, 0xffff,
+  0x0015, 0x3339, 0xb1c7, 0x8e38, 0xf1c7, 0x9c71, 0x9324, 0xafff, 0xffff,
+  0x0015, 0x2639, 0x83c7, 0x0c78, 0xf1c7, 0x1c61, 0x9f30, 0x8dff, 0xffff,
+  0x0015, 0x2671, 0x8d8f, 0x1c70, 0xe3c7, 0x3c63, 0x9cf2, 0x91ff, 0xffff,
+  0x0015, 0x2673, 0x8c76, 0x1871, 0xe38f, 0x3863, 0x1cce, 0x16ff, 0xffff,
+  0x0009, 0x2673, 0x1c71, 0x38f1, 0xe38e, 0x38e3, 0x38cd, 0xc6ff, 0xffff,
+  0x000b, 0x2673, 0x1861, 0xf0e1, 0xc78e, 0x78c3, 0x39cd, 0xbbff, 0xffff,
+  0x000b, 0x6663, 0x18e3, 0xc9e3, 0xc70e, 0x70c7, 0x399d, 0xb47f, 0xffff,
+  0x000b, 0x6c67, 0x18e3, 0x8ec3, 0xc71e, 0x71c6, 0x3999, 0xb4ff, 0xffff,
+  0x004b, 0x6ce7, 0x38e3, 0x9e27, 0x871c, 0x71c6, 0x3199, 0x34ff, 0xffff,
+  0x002b, 0x6ce7, 0x30c3, 0x9c38, 0x4f1c, 0xf1c6, 0x339b, 0x2cff, 0xfffe,
+  0x0012, 0x6ce6, 0x31c7, 0x9c78, 0x761c, 0xe186, 0x739b, 0x6aff, 0xfffe,
+  0x0016, 0x4cc6, 0x31c7, 0x1c70, 0xf13c, 0xe38e, 0x739b, 0x69ff, 0xfffe,
+  0x0096, 0xccce, 0x3187, 0x3c70, 0xe1d8, 0xe38c, 0x733b, 0x69ff, 0xfffe,
+  0x00e6, 0xd8ce, 0x718f, 0x3871, 0xe3c1, 0xe38c, 0x6333, 0x69ff, 0xfffe,
+  0x0068, 0xd9ce, 0x618e, 0x38f1, 0xc386, 0xc30c, 0x6732, 0x69ff, 0xfffe,
+  0x0071, 0x198e, 0x638e, 0x78e1, 0xc78e, 0x271c, 0x6732, 0x59ff, 0xfffe,
+  0x0074, 0x219c, 0x630e, 0x70e3, 0xc70c, 0x3898, 0xe732, 0x55ff, 0xfffe,
+  0x0034, 0xa61c, 0xe31e, 0x71e3, 0x871c, 0x78f8, 0xc732, 0x55ff, 0xfffe,
+  0x0038, 0x866c, 0xc31c, 0x71c7, 0x8f18, 0x71e4, 0xce72, 0x55ff, 0xfffe,
+  0x003a, 0x9263, 0xc71c, 0xf1c7, 0x0e38, 0xf1c7, 0x0e66, 0xd5ff, 0xfffe,
+  0x001a, 0x1323, 0x261c, 0xe3c7, 0x1e38, 0xe3ce, 0x7664, 0xd5ff, 0xfffe,
+  0x001c, 0x5323, 0x393c, 0xe38f, 0x1c70, 0xe38e, 0x71e4, 0xb3ff, 0xfffc,
+  0x0015, 0x4323, 0x39d8, 0xe38e, 0x1c71, 0xc79c, 0xe304, 0xabff, 0xfffc,
+  0x0015, 0x0933, 0x39c1, 0xe38e, 0x3ce1, 0xc71c, 0xe33b, 0xabff, 0xfff8,
+  0x000f, 0x2933, 0x39c6, 0xc79e, 0x38e3, 0x8f39, 0xc636, 0x6bff, 0xfff8,
+  0x000a, 0xa933, 0x39c6, 0x3b1c, 0x39c3, 0x8e39, 0xc676, 0x97ff, 0xfff0,
+  0x000a, 0xa993, 0x39c6, 0x383c, 0x79c7, 0x0e73, 0x8c6c, 0xafff, 0xfff0,
+  0x0007, 0x9591, 0x39ce, 0x30d8, 0x73c7, 0x1c73, 0x8ccd, 0x2fff, 0xffe0,
+  0x0005, 0x5491, 0xb9cc, 0x71c4, 0xf386, 0x1ce7, 0x19db, 0x5fff, 0xffe0,
+  0x0005, 0x5491, 0x99cc, 0x7187, 0x678e, 0x38e7, 0x1992, 0x9fff, 0xffe0,
+  0x0002, 0xd491, 0x998c, 0x718e, 0x1b0c, 0x39ce, 0x33b4, 0xbfff, 0xffc0,
+  0x0001, 0x2a99, 0x998c, 0x638e, 0x389c, 0x71ce, 0x3325, 0x7fff, 0xffc0,
+  0x0000, 0x9249, 0x998c, 0x631c, 0x31f8, 0x739c, 0x6669, 0x7fff, 0xff80,
+  0x0000, 0x4849, 0x998c, 0xe31c, 0x71c4, 0xe39c, 0x665a, 0xffff, 0xff80,
+  0x0000, 0x26b9, 0x998c, 0xe718, 0x63cf, 0x0738, 0xccd4, 0xffff, 0xff00,
+  0x0000, 0x095f, 0x999c, 0xc638, 0xe38e, 0x3f38, 0xd8b5, 0xffff, 0xff00,
+  0x0000, 0x065b, 0x1998, 0xc630, 0xc71c, 0x71b1, 0x9969, 0xffff, 0xfe00,
+  0x0000, 0x032f, 0x6198, 0xce71, 0xc73c, 0xe301, 0xb153, 0xffff, 0xfe00,
+  0x0000, 0x01d5, 0xa619, 0xcc61, 0x8e38, 0xc61c, 0x32d7, 0xffff, 0xfc00,
+  0x0000, 0x02e7, 0xb279, 0x8c63, 0x9c71, 0xcc39, 0x82a7, 0xffff, 0xf800,
+  0x0000, 0x0112, 0xd367, 0x9cc3, 0x1ce3, 0x9873, 0x3baf, 0xffff, 0xe000,
+  0x0000, 0x0085, 0x5b26, 0x78c7, 0x39e7, 0x30e6, 0x748f, 0xffff, 0xc000,
+  0x0000, 0x004b, 0xe926, 0x6186, 0x39ce, 0x619d, 0xe96f, 0xffff, 0x8000,
+  0x0000, 0x001c, 0xad26, 0x664e, 0x739c, 0x6333, 0xa6df, 0xffff, 0x0000,
+  0x0000, 0x000e, 0xd5a6, 0xcefc, 0x6718, 0xc667, 0x4b7f, 0xfffe, 0x0000,
+  0x0000, 0x0004, 0xd4b6, 0xcce3, 0xe739, 0x8cce, 0xb6ff, 0xfff8, 0x0000,
+  0x0000, 0x000d, 0x2ab4, 0xcdc6, 0x3e73, 0x19bd, 0x6bff, 0xfff0, 0x0000,
+  0x0000, 0x0003, 0x6a94, 0xd9cc, 0x63e6, 0x3374, 0xb7ff, 0xffe0, 0x0000,
+  0x0000, 0x0000, 0xd954, 0xdb98, 0xc60c, 0x4eeb, 0x5fff, 0xffc0, 0x0000,
+  0x0000, 0x0000, 0x36d5, 0xd331, 0x1860, 0x99d6, 0x7fff, 0xff00, 0x0000,
+  0x0000, 0x0000, 0x0d85, 0x9662, 0x31ce, 0xf7ba, 0xffff, 0xfe00, 0x0000,
+  0x0000, 0x0000, 0x0313, 0xa6cc, 0x473b, 0x1eb3, 0xffff, 0xf800, 0x0000,
+  0x0000, 0x0000, 0x00c1, 0x4d99, 0x9cec, 0x42e7, 0xffff, 0xe000, 0x0000,
+  0x0000, 0x0000, 0x0030, 0x7722, 0x7362, 0x087f, 0xffff, 0x8000, 0x0000,
+  0x0000, 0x0000, 0x000c, 0xa185, 0xcb90, 0x81ff, 0xfffc, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0003, 0x0fef, 0x2e49, 0x1fff, 0xfff0, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0803, 0x7281, 0xffff, 0xff80, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0038, 0x481f, 0xffff, 0xfe00, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0xf100, 0x007f, 0xf800, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x00fe, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0f7b, 0xfc00, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0xf7ec, 0x3ff0, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x000f, 0x7e70, 0xc4ff, 0x8000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x00f7, 0xe383, 0x0fcd, 0xa000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x057e, 0x0e1c, 0x3f8f, 0x9800, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x1a60, 0x78f0, 0xff1c, 0xde00, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x2cc3, 0xc3c1, 0xfe3c, 0xeb80, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0xd187, 0xdf07, 0xfc38, 0xe7e0, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0001, 0x660f, 0xf01f, 0xf879, 0xe798, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0006, 0xcc1f, 0xe0ff, 0xf0f1, 0xe798, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x001b, 0x187f, 0xc1ff, 0xe1f1, 0xe7cd, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x002e, 0x30ff, 0x83c1, 0xc1e1, 0xe7cc, 0xa000, 0x0000, 0x0000,
+  0x0000, 0x00dc, 0xc1ff, 0x0783, 0xe3e1, 0xc7e6, 0xd000, 0x0000, 0x0000,
+  0x0000, 0x0171, 0x83fe, 0x0f83, 0xe3c1, 0xc3e6, 0x5800, 0x0000, 0x0000,
+  0x0000, 0x06e3, 0x07fc, 0x1f07, 0xc0c3, 0xc3f3, 0x2c00, 0x0000, 0x0000,
+  0x0000, 0x0bc6, 0x0ffc, 0x3e0f, 0xc1f3, 0xc3f3, 0x3500, 0x0000, 0x0000,
+  0x0000, 0x1198, 0x3ff8, 0x3c0f, 0x81ff, 0xc3f1, 0x9a80, 0x0000, 0x0000,
+  0x0000, 0x13e0, 0x7ff0, 0x7c1f, 0x83ff, 0x03f9, 0xcd40, 0x0000, 0x0000,
+  0x0000, 0x23c3, 0xffe0, 0xf83f, 0x03fe, 0x0ff8, 0xc5a0, 0x0000, 0x0000,
+  0x0000, 0x27c7, 0x9fc1, 0xf03f, 0x07fe, 0x0f3c, 0xe6c0, 0x0000, 0x0000,
+  0x0000, 0x4f87, 0x0783, 0xe07e, 0x07fe, 0x0f0c, 0x6360, 0x0000, 0x0000,
+  0x0000, 0x8f0f, 0x07c7, 0xe07e, 0x0ffe, 0x1f0f, 0x71b0, 0x0000, 0x0000,
+  0x0000, 0x9f1e, 0x0f8f, 0xc0fc, 0x0ffc, 0x1f0f, 0x0198, 0x0000, 0x0000,
+  0x0001, 0x1e1e, 0x0f83, 0xc1fc, 0x1ffc, 0x1f0f, 0x0fda, 0x0000, 0x0000,
+  0x0001, 0x3e3c, 0x1f03, 0xf1f8, 0x1ffc, 0x1f0f, 0x0fcd, 0x0000, 0x0000,
+  0x0002, 0x7c3c, 0x1f07, 0xfff8, 0x3ffc, 0x1f0f, 0x0fcc, 0x8000, 0x0000,
+  0x0002, 0x7878, 0x3e07, 0xffb0, 0x3ff8, 0x1f0f, 0x0fcc, 0x8000, 0x0000,
+  0x0004, 0xf8f8, 0x3e0f, 0xff82, 0x7ff8, 0x1e0f, 0x07e6, 0x8000, 0x0000,
+  0x0009, 0xf0f0, 0x7c0f, 0xff03, 0xfff8, 0x1e0f, 0x07e6, 0x4000, 0x0000,
+  0x0009, 0xe1f0, 0x7c1f, 0xff07, 0xf7f8, 0x3e0f, 0x07e6, 0x4000, 0x0000,
+  0x0013, 0xe3e0, 0xf81f, 0xfe07, 0xf1f0, 0x3e0f, 0x87e7, 0x4000, 0x0000,
+  0x0013, 0xc3e0, 0xf83f, 0xfe0f, 0xe070, 0x3e0f, 0x87f3, 0x2000, 0x0000,
+  0x002f, 0xc7c1, 0xf03f, 0xfe0f, 0xe07e, 0x3e0f, 0x87f3, 0x2000, 0x0000,
+  0x002c, 0x87c1, 0xf07f, 0xfc0f, 0xc0fe, 0x3e0f, 0x87f3, 0xa800, 0x0000,
+  0x002c, 0xef83, 0xe07f, 0xfc1f, 0xc0fc, 0x0e0f, 0x87f1, 0x9000, 0x0000,
+  0x002c, 0xe383, 0xe0ff, 0xf81f, 0xc0fc, 0x0f0f, 0x83f9, 0x9000, 0x0000,
+  0x0028, 0xe3e7, 0xc0ff, 0xf83f, 0x80fc, 0x1fff, 0x83f9, 0xd400, 0x0000,
+  0x0059, 0xe3ff, 0xc1ff, 0xf03f, 0x81fc, 0x1fff, 0x83f8, 0xcc00, 0x0000,
+  0x0059, 0xc3fe, 0x01ff, 0xf03f, 0x01f8, 0x1ffe, 0x13f8, 0xc800, 0x0000,
+  0x0059, 0xc7fe, 0x03ff, 0xf07f, 0x01f8, 0x1ffe, 0x1ffc, 0xea00, 0x0000,
+  0x0059, 0xc7fe, 0x0fff, 0xe07f, 0x03f8, 0x3ffc, 0x1f3c, 0xe600, 0x0000,
+  0x0059, 0xc7fc, 0x0f87, 0xe07e, 0x03f0, 0x3ffc, 0x1f0c, 0x6500, 0x0000,
+  0x0051, 0xc7fc, 0x1f81, 0xc0fe, 0x03f0, 0x3ffc, 0x3f0e, 0x7500, 0x0000,
+  0x0053, 0xc7fc, 0x1f81, 0xc0fe, 0x07f0, 0x7ffc, 0x3e0e, 0x3200, 0x0000,
+  0x0053, 0x87fc, 0x1f03, 0xf1fc, 0x07f0, 0x7ff8, 0x3e1e, 0x3e80, 0x0000,
+  0x0053, 0x8ff8, 0x1f03, 0xf0fc, 0x07e0, 0x7ff8, 0x3e1e, 0x3e00, 0x0000,
+  0x0093, 0x8ff8, 0x3f03, 0xe038, 0x07e0, 0x7ff8, 0x3e1e, 0x3e00, 0x0000,
+  0x00b3, 0x8ff8, 0x3f03, 0xe03f, 0xcfe0, 0xfff8, 0x3c1c, 0x3e00, 0x0000,
+  0x00a3, 0x8ff8, 0x3e07, 0xe07f, 0xffe0, 0xfff8, 0x7c1c, 0x7c00, 0x0000,
+  0x00a7, 0x8ff8, 0x3e07, 0xe07f, 0xfec0, 0xfff0, 0x7c1c, 0x7d00, 0x0000,
+  0x00a7, 0x0ff0, 0x3e07, 0xc07f, 0xfe00, 0xfff0, 0x7c3c, 0x7c00, 0x0000,
+  0x00b7, 0x1ff0, 0x7e0f, 0xc07f, 0xfc01, 0xfff0, 0x7c3c, 0x7c00, 0x0000,
+  0x00ff, 0x1ff0, 0x7e0f, 0xc0ff, 0xfc07, 0xfff0, 0x783c, 0x7c00, 0x0000,
+  0x005e, 0x1ff0, 0x7c0f, 0x80ff, 0xf80f, 0xdfe0, 0x783c, 0x7c00, 0x0000,
+  0x005f, 0x3fe0, 0x7c0f, 0x80ff, 0xf80f, 0xc0e0, 0xf83c, 0x7800, 0x0000,
+  0x003f, 0x3860, 0xfc1f, 0x81ff, 0xf81f, 0x80e0, 0xf83c, 0x7800, 0x0000,
+  0x002f, 0x1870, 0xfc1f, 0x81ff, 0xf01f, 0x81f8, 0xf07c, 0x7800, 0x0000,
+  0x002f, 0x1c7c, 0xf81f, 0x01ff, 0xf03f, 0x01f8, 0x3078, 0xf800, 0x0000,
+  0x001f, 0x9c3c, 0x381f, 0x03ff, 0xe03f, 0x03f0, 0x7878, 0xf800, 0x0000,
+  0x0017, 0x9c3c, 0x3f3f, 0x03ff, 0xe07f, 0x03f0, 0x7ff8, 0xf800, 0x0000,
+  0x001f, 0x8c3c, 0x3fff, 0x03ff, 0xe07e, 0x07e0, 0xfff8, 0xf000, 0x0000,
+  0x001f, 0xce3c, 0x3ffe, 0x03ff, 0xc0fe, 0x07e0, 0xffc3, 0xf000, 0x0000,
+  0x000b, 0xce3c, 0x3ff8, 0x07ff, 0xc0fc, 0x0fc1, 0xffc7, 0xb000, 0x0000,
+  0x000f, 0xce3c, 0x3ff8, 0x3fff, 0xc1fc, 0x0fc1, 0xff87, 0x1800, 0x0000,
+  0x000f, 0xce1c, 0x3ff8, 0x3fff, 0x81f8, 0x0f83, 0xff8f, 0x3000, 0x0000,
+  0x0005, 0xe61e, 0x3ff0, 0x3f1f, 0x83f8, 0x1f83, 0xff0e, 0x3000, 0x0000,
+  0x0007, 0xe71e, 0x3ff0, 0x7e07, 0x03f8, 0x1f07, 0xfe1c, 0x6000, 0x0000,
+  0x0007, 0xe71e, 0x1ff0, 0x7e07, 0x87f0, 0x3f07, 0xfe1c, 0xe000, 0x0000,
+  0x0003, 0xe71e, 0x1ff0, 0x7e0f, 0xe3f0, 0x3e0f, 0xfc38, 0xc000, 0x0000,
+  0x0002, 0xf31e, 0x1ff0, 0x7c0f, 0xc0e0, 0x7e0f, 0xfc39, 0x8000, 0x0000,
+  0x0001, 0x5b8e, 0x1ff0, 0x7c1f, 0xc1e0, 0x7c1f, 0xf871, 0x8000, 0x0000,
+  0x0000, 0xad8e, 0x1ff0, 0xfc1f, 0x81fc, 0xfc1f, 0xf863, 0x0000, 0x0000,
+  0x0000, 0x54fe, 0x1ff0, 0xf81f, 0x83ff, 0xf83f, 0xf0e7, 0x0000, 0x0000,
+  0x0000, 0x2278, 0x1fe0, 0xf83f, 0x03ff, 0xc03f, 0xe0c6, 0x0000, 0x0000,
+  0x0000, 0x137c, 0x1fe0, 0xf83f, 0x07ff, 0x81ff, 0xe18e, 0x0000, 0x0000,
+  0x0000, 0x09bc, 0x7fe0, 0xf07e, 0x07ff, 0x03ff, 0xc19c, 0x0000, 0x0000,
+  0x0000, 0x049e, 0x3861, 0xf07e, 0x0fff, 0x07e0, 0xc318, 0x0000, 0x0000,
+  0x0000, 0x054e, 0x3c61, 0xf07c, 0x1ffe, 0x0fc1, 0xe338, 0x0000, 0x0000,
+  0x0000, 0x02a7, 0x1c79, 0xe0fc, 0x1ffc, 0x1f83, 0xc230, 0x0000, 0x0000,
+  0x0000, 0x0157, 0x9c38, 0x60f8, 0x3ff8, 0x3f07, 0x87f0, 0x0000, 0x0000,
+  0x0000, 0x00a3, 0x8e38, 0x79f8, 0x3ff0, 0x7e1e, 0x0f80, 0x0000, 0x0000,
+  0x0000, 0x0049, 0xce38, 0x7fb0, 0x7fe0, 0x7c3c, 0x3f00, 0x0000, 0x0000,
+  0x0000, 0x0024, 0xe638, 0xff00, 0x7fe0, 0xf878, 0x7c00, 0x0000, 0x0000,
+  0x0000, 0x0012, 0xe738, 0xff03, 0xffc1, 0xf0f0, 0xf800, 0x0000, 0x0000,
+  0x0000, 0x000c, 0x7338, 0xfe07, 0xcf83, 0xe1c1, 0xf000, 0x0000, 0x0000,
+  0x0000, 0x0003, 0x7318, 0xfe0f, 0x8307, 0xc387, 0xc000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0xdd98, 0xfc1f, 0x07cf, 0x8f0f, 0x8000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x3799, 0xfc3e, 0x1f87, 0x1e1f, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0db9, 0xf87c, 0x3e0f, 0xf83c, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x033b, 0xf8f0, 0x783f, 0xe0f8, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x00cd, 0x91e1, 0xe0ff, 0x83f0, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0032, 0xbbc3, 0x83fc, 0x0c40, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x000c, 0xb1c6, 0x0fe0, 0xe100, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0003, 0x4ff0, 0x3f8e, 0x1000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0802, 0xfcf1, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0038, 0x6f90, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0xfd00, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x00ec, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0fbc, 0xf800, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0xf9f0, 0x3ff0, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x000f, 0x8f80, 0xfb1f, 0x8000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x00f8, 0xfc03, 0xf1ce, 0xa000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0687, 0xf01f, 0xc3f1, 0xd800, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x1c7f, 0x80ff, 0x07e0, 0xea00, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x30fc, 0x03fe, 0x1fc0, 0xf2c0, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0xe1f8, 0x5ff8, 0x3fc0, 0xf9b0, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0001, 0x87f0, 0xffe0, 0x7f81, 0xf9ec, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0007, 0x0fe1, 0xff00, 0xff01, 0xf8e3, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x001c, 0x1f83, 0xfe03, 0xfe01, 0xf8f1, 0xc000, 0x0000, 0x0000,
+  0x0000, 0x0030, 0x3f0f, 0xfc01, 0xfe01, 0xf8f0, 0xf000, 0x0000, 0x0000,
+  0x0000, 0x00e0, 0xfe1f, 0xf803, 0xfc01, 0xf8f8, 0xf800, 0x0000, 0x0000,
+  0x0000, 0x0181, 0xfc3f, 0xf003, 0xfc01, 0xfc78, 0x6c00, 0x0000, 0x0000,
+  0x0000, 0x0703, 0xf87f, 0xe007, 0xff03, 0xfc7c, 0x3600, 0x0000, 0x0000,
+  0x0000, 0x0c07, 0xf0ff, 0xc00f, 0xfe03, 0xfc7c, 0x3a00, 0x0000, 0x0000,
+  0x0000, 0x1e1f, 0xc1ff, 0xc00f, 0xfe0f, 0xfc7e, 0x1d00, 0x0000, 0x0000,
+  0x0000, 0x1cff, 0x87ff, 0x801f, 0xfc1f, 0xfc3e, 0x0e80, 0x0000, 0x0000,
+  0x0000, 0x3cfc, 0x0fff, 0x003f, 0xfc1f, 0xf03f, 0x0640, 0x0000, 0x0000,
+  0x0000, 0x39f8, 0x1ffe, 0x003f, 0xf81f, 0xf03f, 0x0760, 0x0000, 0x0000,
+  0x0000, 0x71f8, 0x07fc, 0x007f, 0xf83f, 0xf00f, 0x83b0, 0x0000, 0x0000,
+  0x0000, 0xf3f0, 0x07f8, 0x007f, 0xf03f, 0xe00f, 0x81d8, 0x0000, 0x0000,
+  0x0000, 0xe7e0, 0x0ff0, 0x00ff, 0xf03f, 0xe00f, 0xf1ec, 0x0000, 0x0000,
+  0x0001, 0xe7e0, 0x0ffc, 0x01ff, 0xe07f, 0xe00f, 0xf1e4, 0x0000, 0x0000,
+  0x0001, 0xcfc0, 0x1ffc, 0x01ff, 0xe07f, 0xe00f, 0xf1f2, 0x0000, 0x0000,
+  0x0003, 0x8fc0, 0x1ff8, 0x0fff, 0xc07f, 0xe00f, 0xf1f1, 0x0000, 0x0000,
+  0x0003, 0x9f80, 0x3ff8, 0x1fff, 0xc0ff, 0xe00f, 0xf0f0, 0xc000, 0x0000,
+  0x0007, 0x1f00, 0x3ff0, 0x1ffd, 0x80ff, 0xe00f, 0xf8f8, 0xc000, 0x0000,
+  0x000e, 0x3f00, 0x7ff0, 0x3ffc, 0x00ff, 0xe00f, 0xf8f8, 0x6000, 0x0000,
+  0x000e, 0x7e00, 0x7fe0, 0x3ff8, 0x01ff, 0xc00f, 0xf8f8, 0x6000, 0x0000,
+  0x001c, 0x7c00, 0xffe0, 0x7ff8, 0x01ff, 0xc00f, 0xf8f8, 0x6000, 0x0000,
+  0x001c, 0xfc00, 0xffc0, 0x7ff0, 0x007f, 0xc00f, 0xf8fc, 0x3000, 0x0000,
+  0x0030, 0xf801, 0xffc0, 0xfff0, 0x007f, 0xc00f, 0xf87c, 0x3000, 0x0000,
+  0x0030, 0xf801, 0xff80, 0xfff0, 0x00ff, 0xc00f, 0xf87c, 0x3000, 0x0000,
+  0x0030, 0xf003, 0xff81, 0xffe0, 0x00ff, 0xf00f, 0xf87e, 0x1800, 0x0000,
+  0x0030, 0xfc03, 0xff01, 0xffe0, 0x00ff, 0xf00f, 0xfc7e, 0x1800, 0x0000,
+  0x0030, 0xfc27, 0xff03, 0xffc0, 0x00ff, 0xe03f, 0xfc7e, 0x1800, 0x0000,
+  0x0061, 0xfc3f, 0xfe03, 0xffc0, 0x01ff, 0xe03f, 0xfc7f, 0x0800, 0x0000,
+  0x0061, 0xfc3f, 0xfe07, 0xffc0, 0x01ff, 0xe07f, 0xec3f, 0x0c00, 0x0000,
+  0x0061, 0xf83f, 0xfc07, 0xff80, 0x01ff, 0xe07f, 0xe03f, 0x0c00, 0x0000,
+  0x0061, 0xf87f, 0xf00f, 0xff80, 0x03ff, 0xc07f, 0xe03f, 0x0400, 0x0000,
+  0x0061, 0xf87f, 0xf007, 0xff80, 0x03ff, 0xc07f, 0xe00f, 0x8600, 0x0000,
+  0x0061, 0xf87f, 0xe001, 0xff00, 0x03ff, 0xc0ff, 0xc00f, 0x8600, 0x0000,
+  0x0063, 0xf87f, 0xe001, 0xff00, 0x07ff, 0x80ff, 0xc00f, 0xc300, 0x0000,
+  0x0063, 0xf87f, 0xe003, 0xfe00, 0x07ff, 0x80ff, 0xc01f, 0xc700, 0x0000,
+  0x0063, 0xf07f, 0xe003, 0xff00, 0x07ff, 0x81ff, 0xc01f, 0xc700, 0x0000,
+  0x00e3, 0xf0ff, 0xc003, 0xffc0, 0x07ff, 0x81ff, 0xc01f, 0xc700, 0x0000,
+  0x00c3, 0xf0ff, 0xc003, 0xffc0, 0x4fff, 0x01ff, 0xc01f, 0xcf00, 0x0000,
+  0x00c3, 0xf0ff, 0xc007, 0xff80, 0x7fff, 0x01ff, 0x801f, 0x8f00, 0x0000,
+  0x00c7, 0xf0ff, 0xc007, 0xff80, 0xffff, 0x03ff, 0x801f, 0x8e00, 0x0000,
+  0x00c7, 0xf0ff, 0xc007, 0xff80, 0xffff, 0x03ff, 0x803f, 0x8e00, 0x0000,
+  0x00c7, 0xe0ff, 0x800f, 0xff81, 0xfffe, 0x03ff, 0x803f, 0x8e00, 0x0000,
+  0x00cf, 0xe1ff, 0x800f, 0xff01, 0xfff8, 0x03ff, 0x803f, 0x8e00, 0x0000,
+  0x0067, 0xe1ff, 0x800f, 0xff01, 0xfff0, 0x07ff, 0x803f, 0x9e00, 0x0000,
+  0x0067, 0xc1ff, 0x800f, 0xff03, 0xfff0, 0x00ff, 0x003f, 0x9e00, 0x0000,
+  0x0027, 0xc07f, 0x001f, 0xfe03, 0xffe0, 0x00ff, 0x003f, 0x9e00, 0x0000,
+  0x0033, 0xe07f, 0x001f, 0xfe07, 0xffe0, 0x01ff, 0x007f, 0x9e00, 0x0000,
+  0x0033, 0xe07f, 0x001f, 0xfe07, 0xffc0, 0x01ff, 0xc07f, 0x1e00, 0x0000,
+  0x0013, 0xe03f, 0xc01f, 0xfc07, 0xffc0, 0x03ff, 0x807f, 0x1e00, 0x0000,
+  0x0019, 0xe03f, 0xc13f, 0xfc0f, 0xff80, 0x03ff, 0x81ff, 0x3c00, 0x0000,
+  0x0019, 0xf03f, 0xc1ff, 0xfc0f, 0xff80, 0x07ff, 0x03ff, 0x3c00, 0x0000,
+  0x0019, 0xf03f, 0xc1ff, 0xfc0f, 0xff00, 0x07ff, 0x03fc, 0x3c00, 0x0000,
+  0x000d, 0xf03f, 0xc1ff, 0xf81f, 0xff00, 0x0ffe, 0x07f8, 0x3c00, 0x0000,
+  0x000c, 0xf03f, 0xc1ff, 0xc01f, 0xfe00, 0x0ffe, 0x07f8, 0x1c00, 0x0000,
+  0x000c, 0xf01f, 0xc1ff, 0xc03f, 0xfe00, 0x0ffc, 0x0ff0, 0x3800, 0x0000,
+  0x0006, 0xf81f, 0xc1ff, 0xc01f, 0xfc00, 0x1ffc, 0x0ff0, 0x3800, 0x0000,
+  0x0006, 0x781f, 0xc1ff, 0x8007, 0xfc00, 0x1ff8, 0x1fe0, 0x7000, 0x0000,
+  0x0006, 0x781f, 0xe1ff, 0x8007, 0xf800, 0x3ff8, 0x1fe0, 0xf000, 0x0000,
+  0x0003, 0x781f, 0xe1ff, 0x800f, 0xfc00, 0x3ff0, 0x3fc0, 0xe000, 0x0000,
+  0x0003, 0x3c1f, 0xe1ff, 0x800f, 0xff00, 0x7ff0, 0x3fc1, 0xc000, 0x0000,
+  0x0001, 0x9c0f, 0xe1ff, 0x801f, 0xfe00, 0x7fe0, 0x7f81, 0xc000, 0x0000,
+  0x0000, 0xce0f, 0xe1ff, 0x001f, 0xfe04, 0xffe0, 0x7f83, 0x8000, 0x0000,
+  0x0000, 0x673f, 0xe1ff, 0x001f, 0xfc0f, 0xffc0, 0xff07, 0x8000, 0x0000,
+  0x0000, 0x339f, 0xe1ff, 0x003f, 0xfc0f, 0xffc0, 0xff07, 0x0000, 0x0000,
+  0x0000, 0x1b9f, 0xe1ff, 0x003f, 0xf81f, 0xfe01, 0xfe0f, 0x0000, 0x0000,
+  0x0000, 0x0dcf, 0x81ff, 0x007f, 0xf83f, 0xfc01, 0xfe1e, 0x0000, 0x0000,
+  0x0000, 0x06e7, 0xc07e, 0x007f, 0xf03f, 0xf800, 0xfc1c, 0x0000, 0x0000,
+  0x0000, 0x0677, 0xc07e, 0x007f, 0xe07f, 0xf001, 0xfc3c, 0x0000, 0x0000,
+  0x0000, 0x033b, 0xe07e, 0x00ff, 0xe0ff, 0xe003, 0xfc38, 0x0000, 0x0000,
+  0x0000, 0x0199, 0xe03f, 0x80ff, 0xc1ff, 0xc007, 0xf8f8, 0x0000, 0x0000,
+  0x0000, 0x00cd, 0xf03f, 0x81ff, 0xc1ff, 0x801f, 0xf1f0, 0x0000, 0x0000,
+  0x0000, 0x006e, 0xf03f, 0x87ff, 0x83ff, 0x803f, 0xc7e0, 0x0000, 0x0000,
+  0x0000, 0x0037, 0xf83f, 0x0fff, 0x87ff, 0x007f, 0x8f80, 0x0000, 0x0000,
+  0x0000, 0x001b, 0x783f, 0x0ffc, 0x07fe, 0x00ff, 0x3f00, 0x0000, 0x0000,
+  0x0000, 0x000f, 0xbc3f, 0x0ff8, 0x0ffc, 0x01fe, 0x7c00, 0x0000, 0x0000,
+  0x0000, 0x0003, 0xbc1f, 0x1ff0, 0x03f8, 0x03f8, 0xf800, 0x0000, 0x0000,
+  0x0000, 0x0000, 0xee1f, 0x1fe0, 0x07f0, 0x0ff3, 0xe000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x3b1e, 0x1fc0, 0x1ff8, 0x1fe7, 0x8000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0ede, 0x1f80, 0x3ff0, 0xffdf, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x03ac, 0x3f00, 0x7fc3, 0xff3c, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x00ee, 0x1e01, 0xff0f, 0xfcf8, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0039, 0x3c03, 0xfc7f, 0xf060, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x000e, 0x3e07, 0xf3ff, 0x0100, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0003, 0x77ff, 0xcff0, 0x1000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x09fc, 0x7f01, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0008, 0x7010, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0500, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x000f, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x003f, 0xfc00, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x01ff, 0xc7f0, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0fff, 0x030f, 0x8000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0xfffc, 0x01f0, 0xe000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0707, 0xffe0, 0x03f9, 0xe800, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x1f9f, 0xff00, 0x07ff, 0xf200, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x3f03, 0xfc00, 0x1fff, 0x0c80, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0xfe00, 0x6000, 0x3fff, 0x0020, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0001, 0xf800, 0xfc00, 0x7ffe, 0x01c8, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0007, 0xf001, 0xff80, 0xfffe, 0x00fe, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x001f, 0xe003, 0xffe3, 0xfffe, 0x00fe, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x003f, 0xc00f, 0xffff, 0xfffe, 0x00ff, 0x3000, 0x0000, 0x0000,
+  0x0000, 0x00ff, 0x001f, 0xfffc, 0x1ffe, 0x00ff, 0x1800, 0x0000, 0x0000,
+  0x0000, 0x01fe, 0x003f, 0xfffc, 0x03fe, 0x007f, 0x8c00, 0x0000, 0x0000,
+  0x0000, 0x07fc, 0x007f, 0xfff8, 0x003c, 0x007f, 0xc600, 0x0000, 0x0000,
+  0x0000, 0x03f8, 0x00ff, 0xfff0, 0x000c, 0x007f, 0xc300, 0x0000, 0x0000,
+  0x0000, 0x0060, 0x01ff, 0xfff0, 0x000f, 0x007f, 0xe180, 0x0000, 0x0000,
+  0x0000, 0x00f0, 0x07ff, 0xffe0, 0x001f, 0xf03f, 0xf0c0, 0x0000, 0x0000,
+  0x0000, 0x00ff, 0x0fff, 0xffc0, 0x001f, 0xfc3f, 0xf860, 0x0000, 0x0000,
+  0x0000, 0x01ff, 0xffff, 0xffc0, 0x001f, 0xffff, 0xf860, 0x0000, 0x0000,
+  0x0000, 0x01ff, 0xfbff, 0xff80, 0x003f, 0xfff3, 0xfc30, 0x0000, 0x0000,
+  0x0000, 0x03ff, 0xf83f, 0xff80, 0x003f, 0xfff0, 0xfe18, 0x0000, 0x0000,
+  0x0000, 0x07ff, 0xf00f, 0xff00, 0x003f, 0xfff0, 0x0e0c, 0x0000, 0x0000,
+  0x0000, 0x07ff, 0xf000, 0x3e00, 0x007f, 0xfff0, 0x0106, 0x0000, 0x0000,
+  0x0000, 0x0fff, 0xe000, 0x0e00, 0x007f, 0xfff0, 0x01e3, 0x0000, 0x0000,
+  0x0000, 0x0fff, 0xe000, 0x0e00, 0x007f, 0xfff0, 0x01ff, 0x8000, 0x0000,
+  0x0000, 0x1fff, 0xc000, 0x1fc0, 0x00ff, 0xfff0, 0x00ff, 0x0000, 0x0000,
+  0x0000, 0x1fff, 0xc000, 0x1ffe, 0x00ff, 0xfff0, 0x00ff, 0x0000, 0x0000,
+  0x0000, 0x3fff, 0x8000, 0x3fff, 0xc0ff, 0xfff0, 0x00ff, 0x8000, 0x0000,
+  0x0000, 0x7fff, 0x8000, 0x3fff, 0xf9ff, 0xfff0, 0x00ff, 0x8000, 0x0000,
+  0x0000, 0x7fff, 0x0000, 0x7fff, 0xffff, 0xfff0, 0x00ff, 0x8000, 0x0000,
+  0x0000, 0xffff, 0x0000, 0x7fff, 0xffbf, 0xfff0, 0x00ff, 0xc000, 0x0000,
+  0x003c, 0xfffe, 0x0000, 0xffff, 0xff80, 0xfff0, 0x007f, 0xc000, 0x0000,
+  0x003f, 0x7ffe, 0x0000, 0xffff, 0xff00, 0x3ff0, 0x007f, 0xc000, 0x0000,
+  0x003f, 0x0ffc, 0x0001, 0xffff, 0xff00, 0x07f0, 0x007f, 0xe000, 0x0000,
+  0x003f, 0x03fc, 0x0001, 0xffff, 0xff00, 0x00f0, 0x007f, 0xe000, 0x0000,
+  0x003f, 0x0038, 0x0003, 0xffff, 0xff00, 0x0038, 0x007f, 0xe000, 0x0000,
+  0x007e, 0x0038, 0x0003, 0xffff, 0xfe00, 0x003e, 0x007f, 0xf000, 0x0000,
+  0x007e, 0x003f, 0xc007, 0xffff, 0xfe00, 0x007f, 0xf03f, 0xf000, 0x0000,
+  0x007e, 0x003f, 0xf007, 0xffff, 0xfe00, 0x007f, 0xfc3f, 0xf000, 0x0000,
+  0x007e, 0x007f, 0xfe0f, 0xffff, 0xfc00, 0x007f, 0xffff, 0xf800, 0x0000,
+  0x007e, 0x007f, 0xffff, 0xffff, 0xfc00, 0x007f, 0xfff3, 0xf800, 0x0000,
+  0x007e, 0x007f, 0xfffe, 0xffff, 0xfc00, 0x00ff, 0xfff0, 0x7800, 0x0000,
+  0x007c, 0x007f, 0xfffe, 0x3fff, 0xf800, 0x00ff, 0xfff0, 0x0c00, 0x0000,
+  0x007c, 0x007f, 0xfffc, 0x07ff, 0xf800, 0x00ff, 0xffe0, 0x0700, 0x0000,
+  0x007c, 0x007f, 0xfffc, 0x00ff, 0xf800, 0x01ff, 0xffe0, 0x0780, 0x0000,
+  0x00fc, 0x00ff, 0xfffc, 0x001f, 0xf800, 0x01ff, 0xffe0, 0x0780, 0x0000,
+  0x00fc, 0x00ff, 0xfffc, 0x0000, 0x7000, 0x01ff, 0xffe0, 0x0f80, 0x0000,
+  0x00fc, 0x00ff, 0xfff8, 0x0000, 0x7800, 0x01ff, 0xffe0, 0x0f00, 0x0000,
+  0x00f8, 0x00ff, 0xfff8, 0x0000, 0xff00, 0x03ff, 0xffe0, 0x0f00, 0x0000,
+  0x0078, 0x00ff, 0xfff8, 0x0000, 0xffe0, 0x03ff, 0xffc0, 0x0f00, 0x0000,
+  0x0008, 0x00ff, 0xfff0, 0x0001, 0xfff8, 0x03ff, 0xffc0, 0x0f00, 0x0000,
+  0x000e, 0x01ff, 0xfff0, 0x0001, 0xffff, 0x03ff, 0xffc0, 0x0f00, 0x0000,
+  0x0007, 0xc1ff, 0xfff0, 0x0001, 0xffff, 0xe7ff, 0xffc0, 0x1f00, 0x0000,
+  0x0007, 0xf9ff, 0xfff0, 0x0003, 0xffff, 0xff7f, 0xffc0, 0x1e00, 0x0000,
+  0x0007, 0xffff, 0xffe0, 0x0003, 0xffff, 0xff1f, 0xffc0, 0x1e00, 0x0000,
+  0x0003, 0xff8f, 0xffe0, 0x0007, 0xffff, 0xfe03, 0xff80, 0x1e00, 0x0000,
+  0x0003, 0xff80, 0xffe0, 0x0007, 0xffff, 0xfe00, 0x3f80, 0x1e00, 0x0000,
+  0x0003, 0xffc0, 0x1fe0, 0x0007, 0xffff, 0xfc00, 0x0780, 0x1e00, 0x0000,
+  0x0001, 0xffc0, 0x01c0, 0x000f, 0xffff, 0xfc00, 0x0180, 0x3e00, 0x0000,
+  0x0001, 0xffc0, 0x01e0, 0x000f, 0xffff, 0xf800, 0x03e0, 0x3c00, 0x0000,
+  0x0001, 0xffc0, 0x01f8, 0x000f, 0xffff, 0xf800, 0x03ff, 0x3c00, 0x0000,
+  0x0001, 0xffc0, 0x01ff, 0x001f, 0xffff, 0xf000, 0x07ff, 0xfc00, 0x0000,
+  0x0000, 0xffc0, 0x01ff, 0xfc1f, 0xffff, 0xf000, 0x07ff, 0xe000, 0x0000,
+  0x0000, 0xffe0, 0x01ff, 0xff3f, 0xffff, 0xf000, 0x0fff, 0xc000, 0x0000,
+  0x0000, 0xffe0, 0x01ff, 0xffff, 0xffff, 0xe000, 0x0fff, 0xc000, 0x0000,
+  0x0000, 0x7fe0, 0x01ff, 0xfffb, 0xffff, 0xe000, 0x1fff, 0x8000, 0x0000,
+  0x0000, 0x7fe0, 0x01ff, 0xfff8, 0x7fff, 0xc000, 0x1fff, 0x0000, 0x0000,
+  0x0000, 0x7fe0, 0x01ff, 0xfff0, 0x03ff, 0xc000, 0x3fff, 0x0000, 0x0000,
+  0x0003, 0xbfe0, 0x01ff, 0xfff0, 0x007f, 0x8000, 0x3ffe, 0x0000, 0x0000,
+  0x0001, 0xe7f0, 0x01ff, 0xffe0, 0x001f, 0x8000, 0x7ffe, 0x0000, 0x0000,
+  0x0000, 0xf1f0, 0x01ff, 0xffe0, 0x0007, 0x0000, 0x7ffc, 0x0000, 0x0000,
+  0x0000, 0x7830, 0x01ff, 0xffe0, 0x000f, 0xe000, 0xfff8, 0x0000, 0x0000,
+  0x0000, 0x3c1e, 0x01ff, 0xffc0, 0x000f, 0xf800, 0xfff8, 0x0000, 0x0000,
+  0x0000, 0x1c1f, 0x81ff, 0xffc0, 0x001f, 0xffc1, 0xfff0, 0x0000, 0x0000,
+  0x0000, 0x0e0f, 0xf9ff, 0xff80, 0x003f, 0xfff1, 0xffe0, 0x0000, 0x0000,
+  0x0000, 0x0707, 0xffff, 0xff80, 0x003f, 0xffff, 0xffe0, 0x0000, 0x0000,
+  0x0000, 0x0787, 0xff9f, 0xff80, 0x007f, 0xfffe, 0x1fc0, 0x0000, 0x0000,
+  0x0000, 0x03c3, 0xff81, 0xff00, 0x00ff, 0xfffc, 0x01c0, 0x0000, 0x0000,
+  0x0000, 0x01e1, 0xffc0, 0x1f00, 0x01ff, 0xfff8, 0x00c0, 0x0000, 0x0000,
+  0x0000, 0x00f1, 0xffc0, 0x0600, 0x01ff, 0xffe0, 0x01f0, 0x0000, 0x0000,
+  0x0000, 0x0070, 0xffc0, 0x07c0, 0x03ff, 0xffc0, 0x07e0, 0x0000, 0x0000,
+  0x0000, 0x0038, 0xffc0, 0x0ff0, 0x07ff, 0xff80, 0x0f80, 0x0000, 0x0000,
+  0x0000, 0x001c, 0x7fc0, 0x0fff, 0x07ff, 0xff00, 0x3f00, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x3fc0, 0x0fff, 0xffff, 0xfe00, 0x7c00, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x7fe0, 0x1fff, 0xfcff, 0xfc00, 0xf800, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x13e0, 0x1fff, 0xf83f, 0xf003, 0xe000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0460, 0x1fff, 0xe007, 0xe007, 0x8000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0110, 0x1fff, 0xc000, 0xc01f, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x004e, 0x3fff, 0x8003, 0xf03c, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0017, 0xfffe, 0x000f, 0xfff8, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0005, 0xc3fc, 0x007f, 0xff80, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0001, 0xc038, 0x03ff, 0xfe00, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x87f8, 0x0fff, 0xe000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x07ff, 0x7ffe, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0007, 0x8fe0, 0x0000, 0x0000, 0x0000, 0x0000,
+  0x0000, 0x0000, 0x0000, 0x0000, 0x0600, 0x0000, 0x0000, 0x0000, 0x0000
+}
+
+--local SCREEN_W = 336
+--local SCREEN_H = 216
+local SCREEN_W = 320
+local SCREEN_H = 200
+local function l(x1, y1, x2, y2, c)
+  raster.drawLine(x1-8, y1-8, x2-8, y2-8, c)
+end
+local function g(x, y)
+  return raster.get(x-8, y-8)
+end
+local function s(x, y, c)
+  raster.set(x-8, y-8, c)
+end
+local BALL_W = 144
+local BALL_H = 100
+local ONE_PLANE_LEN = BALL_W * BALL_H / 16
+
+local function ball()
+  local color_cycle = 2
+  local pos = { x = 0.0, y = 0.0 }
+  local scroll = { x = -1, y = -1 }
+  local pixel_index = {}
+  local is_shadow = {}
+  local this = {}
+  function this.pos()
+    return -pos.x + 77, -pos.y
+  end
+  function this.step()
+    pos.x = pos.x + scroll.x
+    if pos.x <= -95 or pos.x >= 95 then scroll.x = -scroll.x end
+    local adj = scroll.y
+    if pos.y > -10.0 then adj = adj * 1.0
+    elseif pos.y > -30.0 then adj = adj * 2.0
+    elseif pos.y > -60.0 then adj = adj * 3.0
+    else adj = adj * 4.0 end
+    pos.y = pos.y + adj
+    if pos.y <= -100 or pos.y >= 0 then scroll.y = -scroll.y end
+  end
+  local function orderbits(value)
+    local result = 0
+    for i = 0, 15 do
+      if (value >> i) & 1 == 1 then
+        result = result | (1 << (15 - i))
+      end
+    end
+    return result
+  end
+  function this.decode()
+    for y = 0, BALL_H - 1 do
+      for x = 0, BALL_W - 1 do
+        local pos = y * BALL_W + x
+        local offset = pos // 16
+        local bitpos = pos % 16
+
+        local value = 0
+        for plane = 0, 3 do
+          local word = orderbits(ball_bitplanes[offset + plane * ONE_PLANE_LEN + 1])
+          if (word & (1 << bitpos)) ~= 0 then
+            value = value | (1 << plane)
+          end
+        end
+
+        if (value == 1) then
+          is_shadow[pos + 1] = true
+          pixel_index[pos + 1] = 0
+        else
+          is_shadow[pos + 1] = false
+          pixel_index[pos + 1] = value
+        end
+      end
+    end
+  end
+  function this.cycle_palette()
+    if scroll.x > 0 then color_cycle = color_cycle - 1
+    else color_cycle = color_cycle + 1 end
+
+    if color_cycle == -1 then color_cycle = 13
+    elseif color_cycle == 14 then color_cycle = 0 end
+
+    for i = 0, 6 do
+      if color_cycle + i < 14 then
+        color_table[color_cycle + i + 3] = 0xFFFFFF
+        color_table[color_cycle + i + 19] = 0xFFFFFF
+      else
+        color_table[color_cycle + i - 11] = 0xFFFFFF
+        color_table[color_cycle + i + 5] = 0xFFFFFF
+      end
+    end
+    for i = 7, 13 do
+      if color_cycle + i < 14 then
+        color_table[color_cycle + i + 3] = 0xFF0000
+        color_table[color_cycle + i + 19] = 0xFF0000
+      else
+        color_table[color_cycle + i - 11] = 0xFF0000
+        color_table[color_cycle + i + 5] = 0xFF0000
+      end
+    end
+    if scroll.x > -1 then
+      color_table[color_cycle + 3] = 0xFFDDDD
+      color_table[color_cycle + 19] = 0xFFDDDD
+    elseif color_cycle + 6 < 14 then
+      color_table[color_cycle + 9] = 0xFFDDDD
+      color_table[color_cycle + 25] = 0xFFDDDD
+    else
+      color_table[color_cycle - 5] = 0xFFDDDD
+      color_table[color_cycle + 11] = 0xFFDDDD
+    end
+  end
+  function this.draw(x, y, shadow)
+    for oy = 0, BALL_H - 1 do
+      for ox = 0, BALL_W - 1 do
+        local pos = oy * BALL_W + ox + 1
+        if shadow then
+          if is_shadow[pos] then
+            local c = g(ox+x, oy+y)
+            if c == 0xAAAAAA then s(ox+x, oy+y, 0x666666) end
+          end
+        else
+          local idx = pixel_index[pos]
+          if idx ~= 0 then
+            local c = color_table[idx + 1]
+            s(ox+x, oy+y, c)
+          end
+        end
+      end
+    end
+  end
+  return this
+end
+
+function draw_background()
+  raster.clear()
+
+  local lc = color_table[17]
+
+  local k = 20
+  for j = 48, 300, 16 do
+    l(j, 0, j, 192, lc)
+    l(j, 192, k, 215, lc)
+    k = k + 20
+  end
+  for j = 0, 200, 16 do
+    l(48, j, 288, j, lc)
+  end
+  l(45, 194, 291, 194, lc)
+  l(41, 197, 295, 197, lc)
+  l(37, 201, 300, 201, lc)
+  l(30, 207, 308, 207, lc)
+  l(20, 215, 319, 215, lc)
+end
+
+local b = ball()
+b.decode()
+raster.init(SCREEN_W/2, SCREEN_H/4, color_table[1])
+local i = 0
+while true do
+  i = i + 1
+  draw_background()
+  b.cycle_palette()
+  b.step()
+  local x, y = b.pos()
+  b.draw(x, y, true)
+  b.draw(x, y)
+  raster.update()
+
+  if event.pull("key_down", 0.01) then
+    break
+  end
+end
+
+raster.free()
+terminal.clear()

halyde/apps/helpdb/echo

@@ -1,9 +1,9 @@
 COMMAND echo
 USAGE [TEXT]...
-DESCRIPTION Concatenates and prints text to the terminal.
+DESCRIPTION Concatenates and prints text to the standard output.
 ARG1 TEXT
 ARG1DESCRIPTION Text to print.
 EXAMPLE1 echo test
 EXAMPLE2 echo Hello World!
-EXAMPLE1DESCRIPTION Prints "test" to the terminal.
+EXAMPLE1DESCRIPTION Prints "test" to the standard output.
-EXAMPLE2DESCRIPTION Prints "Hello World!" to the terminal.
+EXAMPLE2DESCRIPTION Prints "Hello World!" to the standard output.

halyde/apps/profile.lua

@@ -0,0 +1,222 @@
+-- TODO: make it somehow not depend on ESC s and ESC u
+local profiler = require("profiler")
+local PAL = {
+  { fg = "\27[31m", bg = "\27[41m" },
+  { fg = "\27[32m", bg = "\27[42m" },
+  { fg = "\27[33m", bg = "\27[43m" },
+  { fg = "\27[34m", bg = "\27[44m" },
+  { fg = "\27[35m", bg = "\27[45m" },
+  { fg = "\27[36m", bg = "\27[46m" },
+  { fg = "\27[37m", bg = "\27[47m" }
+}
+local function pal(i) return PAL[((i - 1) % #PAL) + 1] end
+
+local results = profiler.results()
+if not results then
+  print("No profiling data")
+  return
+end
+
+local radius
+local W = terminal.getResolution()
+if (W == 160) then radius = 20
+elseif (W == 80) then radius = 6
+else radius = 0; PAL = {{fg = "", bg = ""}} end
+
+local MIN_PC = math.min(3, 100 / (radius * 2))
+
+local total = 0
+for _, r in ipairs(results) do total = total + r.time end
+
+local main = {}
+local other = {}
+local ot = 0
+local on_ = 0
+for _, r in ipairs(results) do
+  if r.time / total * 100 >= MIN_PC then
+    table.insert(main, r)
+  else
+    table.insert(other, r)
+    ot = ot + r.time;
+    on_ = on_ + 1
+  end
+end
+if on_ then
+  table.insert(main, { label = "other (" .. on_ .. ")", time = ot })
+end
+
+local START = -math.pi / 2
+local slices = {}
+local cur = START
+for i, m in ipairs(main) do
+  local sw = m.time / total * 2 * math.pi
+  slices[i] = {
+    label = m.label,
+    time = m.time,
+    pc = ("%.1f%%"):format(m.time / total * 100),
+    color = pal(i),
+    sa = cur,
+    sw = sw
+  }
+  cur = cur + sw
+end
+if on_ then slices[#slices].color={fg = "\27[30m", bg = "\27[40m"} end
+
+local ASP = 2
+local cx = radius * ASP
+local cy = radius
+
+local function slice_at(sx, sy)
+  local dy = sy - cy
+  local dx = (sx - cx) / ASP
+  if dx * dx + dy * dy > radius * radius then return nil end
+  local a = math.atan2(dy, dx)
+  if a < START then a = a + 2 * math.pi end
+  for i, sl in ipairs(slices) do
+    if a >= sl.sa and a < sl.sa + sl.sw then return i end
+  end
+  return #slices
+end
+
+local SUB = {
+  { dx = -0.25, dy = -0.375 },
+  { dx = -0.25, dy = -0.125 },
+  { dx = -0.25, dy =  0.125 },
+  { dx =  0.25, dy = -0.375 },
+  { dx =  0.25, dy = -0.125 },
+  { dx =  0.25, dy =  0.125 },
+  { dx = -0.25, dy =  0.375 },
+  { dx =  0.25, dy =  0.375 },
+}
+
+for y = 0, radius * 2 do
+  local lx, rx = math.ceil(cx - radius * ASP), math.floor(cx + radius * ASP)
+
+  terminal.write(("\27[%dC"):format(lx))
+  for x = lx, rx do
+    local c = {}
+    local n = 0
+    for k = 1, 8 do
+      local s = slice_at(x + SUB[k].dx, y + SUB[k].dy)
+      c[k] = s
+      if s then n = n + 1 end
+    end
+
+    if n == 0 then
+      terminal.write("\27[0m ")
+    else
+      local counts = {}
+      local order = {}
+      for k = 1, 8 do
+        if c[k] then
+          local key = c[k]
+          if not counts[key] then
+            counts[key] = 0
+            table.insert(order, key)
+          end
+          counts[key] = counts[key] + 1
+        end
+      end
+      table.sort(order, function(a, b) return counts[a] > counts[b] end)
+      local dom = order[1]
+      local sub = order[2]
+
+      if n == 8 then
+        terminal.write(slices[dom].color.bg)
+        if sub == nil then
+          terminal.write(" ")
+        else
+          local mask = 0
+          for k = 1, 8 do
+            if c[k] == sub then mask = mask + (1 << (k - 1)) end
+          end
+          terminal.write(slices[sub].color.fg)
+          terminal.write(utf8.char(0x2800 + mask))
+        end
+      else
+        local mask = 0
+        for k = 1, 8 do
+          if c[k] == dom then mask = mask + (1 << (k - 1)) end
+        end
+        terminal.write("\27[0m")
+        terminal.write(slices[dom].color.fg)
+        terminal.write(utf8.char(0x2800 + mask))
+      end
+    end
+  end
+  terminal.write('\n')
+end
+
+terminal.write("\27[" .. radius * 2 + 1 .. "A\27[s")
+local function draw_text(col, row, s)
+  terminal.write("\27[u\27[" .. col .. "C\27[" .. row - 1 .. "B" .. s)
+end
+
+terminal.write("\27[0m")
+if radius == 0 then goto tier1gpu end
+for _, sl in ipairs(slices) do
+  local y = math.floor(cy + radius * 0.62 * math.sin(sl.sa + sl.sw / 2) + 0.5)
+
+  local function in_slice(x, row)
+    local a = math.atan2(row - cy, (x - cx) / ASP)
+    if a < START then
+      a = a + 2 * math.pi
+    end
+    return a >= sl.sa and a < sl.sa + sl.sw
+  end
+  local function centered_draw(row, text)
+    local dy = row - cy
+    local half_w = math.sqrt(radius * radius - dy * dy) * ASP
+    local lx, rx = math.ceil(cx - half_w), math.floor(cx + half_w)
+    while lx <= rx and not in_slice(lx, row) do
+      lx = lx + 1
+    end
+    while rx >= lx and not in_slice(rx, row) do
+      rx = rx - 1
+    end
+    local avail = rx - lx + 1
+    if avail < 3 then
+      return
+    end
+    local t = #text > avail and text:sub(1, avail - 3) .. "..." or text
+    local start_x = lx + math.floor((avail - #t) / 2)
+    draw_text(start_x, row, sl.color.bg .. t)
+  end
+  centered_draw(y, sl.label)
+  centered_draw(y + 1, sl.pc)
+end
+::tier1gpu::
+
+local max_w = 0
+for _, sl in pairs(slices) do
+  max_w = math.max(#sl.label + 1, max_w)
+end
+for _, sl in pairs(other) do
+  max_w = math.max(#sl.label + 3, max_w)
+end
+local x = radius * 2 * ASP + 2
+if radius == 0 then x = 0 end
+local cw = W - x - 1
+local suffix_w = 18
+local max_lbl = math.max(4, cw - suffix_w)
+terminal.write("\27[u\27[" .. x .. "C" .. ("\27[0m%" .. max_w .. "s  %9s   %6s"):format("label", "time", "share"))
+terminal.write("\n")
+for _, sl in ipairs(slices) do
+  local lbl = sl.label
+  if #lbl > max_lbl then
+    lbl = sl.label:sub(1, max_lbl - 1) .. "…"
+  end
+  terminal.write("\n\27[" .. x .. "C" .. ("%s%" .. max_w .. "s\27[0m  %9.4fs  %6s"):format(sl.color.bg, lbl, sl.time, sl.pc))
+end
+for _, sl in ipairs(other) do
+  local lbl = sl.label
+  if #lbl > max_lbl - 2 then
+    lbl = sl.label:sub(1, max_lbl - 3) .. "…"
+  end
+  terminal.write("\n\27[" .. x .. "C" .. ("%s%" .. max_w .. "s\27[0m  %9.4fs  %6s"):format(slices[#slices].color.bg, lbl, sl.time, ("%.1f%%"):format(sl.time / total * 100)))
+end
+
+if radius * 2 + 2 > #slices + #other then
+  terminal.write("\27[" .. radius * 2 + 2 .. "B")
+end
+terminal.write("\n")

halyde/kernel/boot.lua

@@ -11,6 +11,7 @@ gpu.bind(screenAddress)
 gpu.setResolution(gpu.maxResolution())
 
 local log = assert(loadfile("/lib/log.lua")(loadfile))
+_G.profiler = assert(loadfile("/lib/profiler.lua")())
 
 log.kernel.info("Bound GPU to screen " .. tostring(screenAddress))
 
@@ -67,10 +68,10 @@ require("/halyde/kernel/datatools.lua") -- If this is not imported BEFORE modloa
 log.kernel.info("Loading modules")
 require("/halyde/kernel/modload.lua")
 
-package.preload("component")
+local toPreload = { "component", "computer", "log", "event" }
-package.preload("computer")
+for _, p in pairs(toPreload) do
-package.preload("log")
+  profiler.profile("pre-loading " .. p, package.preload, p)
-package.preload("event")
+end
 
 local computer = require("computer")
 function wait(seconds)

halyde/kernel/modload.lua

@@ -19,8 +19,10 @@ local moduleTypes = {}
 local modulesLoaded = {}
 
 local function loadModule(modName)
+  local stop = profiler.start("loadModule(" .. tostring(modName) .. ")")
   if table.find(modulesLoaded, modName) then
     log.kernel.warn(string.format("[modload: %s] Module was already loaded - skipping", modName))
+    stop()
     return true
   end
 
@@ -28,6 +30,7 @@ local function loadModule(modName)
   if not moduleData then
     log.kernel.warn(string.format("[modload: %s] Could not find module data.", modName))
     table.remove(moduleList, table.find(moduleList, modName))
+    stop()
     return true
   end
   local ready = false
@@ -42,6 +45,7 @@ local function loadModule(modName)
   end
   if not ready then
     log.kernel.info(string.format("[modload: %s] Module not ready - skipping", modName))
+    stop()
     return false
   end
   if type(moduleData.dependencies) == "table" then
@@ -74,16 +78,19 @@ local function loadModule(modName)
           tostring(err or "unknown error")
         )
       )
+      stop()
       return false
     else
       table.insert(modulesLoaded, modName)
       table.remove(moduleList, table.find(moduleList, modName))
     end
   end
+  stop()
   return true
 end
 
 for _, modName in pairs(moduleList) do -- Get all the module types
+  local stop = profiler.start("getting module " .. modName .. ")")
   log.kernel.info(string.format("[modload: %s] Getting data from module", modName))
   local moduleData
   local status, err = pcall(function()
@@ -123,6 +130,7 @@ for _, modName in pairs(moduleList) do -- Get all the module types
     moduleTypes[modName] = moduleData.type -- Not the other way around because there can be multiple modules of the same type, but there can't be multiple entries with the same key
   end
   ::continue::
+  stop()
 end
 
 local function loadAllModules() -- attempt at loading all modules, unless if they're not ready

halyde/kernel/modules/terminal.lua

@@ -17,7 +17,6 @@ function module.init()
   local event = require("event")
 
   local component = require("component")
-  local computer = require("computer")
   local gpu = component.gpu
   _G._PUBLIC.terminal = {}
 
@@ -145,9 +144,6 @@ function module.init()
 
   local ANSIColorPalette = getColorPalette(gpu.maxDepth())
 
-  local expecting_unicode_bytes = 0
-  local unicode_bytes_left = 0
-  local unicode_codepoint = 0
   local cursor = { x = 1, y = 1, X = nil, Y = nil } -- X and Y are managed by ESC s and ESC u
   local printState = 0 -- 0:none 1:in ESC 2:in CSI
   local color = {
@@ -509,10 +505,10 @@ function module.init()
     if byte >= 0x20 and byte <= 0x7F then
       table.insert(writeBuf, string.char(byte))
       cursor.x = cursor.x + 1
-      check_wrap_and_scroll()
+      if cursor.x > width then
-      if cursor.y ~= writeBufY or #writeBuf >= 32 then
         _PUBLIC.terminal.flush()
       end
+      check_wrap_and_scroll()
     elseif byte >= 0xC2 and byte <= 0xDF then
       current_codepoint = (byte & 0x1F)
       bytes_remaining = 1
@@ -528,10 +524,10 @@ function module.init()
       if bytes_remaining == 0 then
         table.insert(writeBuf, utf8.char(current_codepoint))
         cursor.x = cursor.x + 1
-        check_wrap_and_scroll()
+        if cursor.x > width then
-        if cursor.y ~= writeBufY or #writeBuf >= 32 then
           _PUBLIC.terminal.flush()
         end
+        check_wrap_and_scroll()
         current_codepoint = 0
       end
     else
@@ -566,7 +562,7 @@ function module.init()
     local args = {...}
     local stringArgs = {}
     for _, arg in pairs(args) do
-      if type(arg)=="table" then
+      if type(arg) == "table" then
         table.insert(stringArgs, serialize(arg))
       elseif tostring(arg) then
         table.insert(stringArgs, tostring(arg))
@@ -593,8 +589,6 @@ function module.init()
 
     local text = options.defaultText or ""
 
-    _G._PUBLIC.terminal.flush()
-
     local historyIdx
     if options.readHistoryType then
       if not readHistory[options.readHistoryType] then
@@ -613,6 +607,7 @@ function module.init()
 
     local cur = unicode.len(text)+1
     if options.prefix then _PUBLIC.terminal.write(options.prefix) end
+    _G._PUBLIC.terminal.flush()
     local startX, startY = cursor.x, cursor.y
     local fg, bg = gpu.getForeground(), gpu.getBackground()
     local cursorBlink = true

lib/event.lua

@@ -47,15 +47,13 @@ function event.pull(...)
       end
     end
 
-    -- Check if we've timed out
+    if timeout ~= nil and computer.uptime() >= startTime + timeout then
-    if timeout and computer.uptime() >= startTime + timeout then
+      return nil
-      return nil -- Timed out, return nil
     end
 
-    -- Yield to allow other processes to run and more events to be added
+    if timeout == nil then
-    if timeout and timeout > 0 then
       coroutine.yield()
-    elseif not timeout then
+    elseif timeout > 0 then
       coroutine.yield()
     end
   end

lib/profiler.lua

@@ -0,0 +1,35 @@
+local thing = _G._PUBLIC or _G
+thing.__PROFILER_INSTANCE = thing.__PROFILER_INSTANCE or { timers = {} }
+local timers = thing.__PROFILER_INSTANCE.timers
+local profiler = {}
+
+function profiler.start(label, overwrite)
+  thing.__PROFILER_INSTANCE.lastadded = label
+  timers[label] = timers[label] or {}
+  if not timers[label].start or overwrite then
+    timers[label].start = os.clock()
+  end
+  return function() timers[label].time = timers[label].time or os.clock() - timers[label].start end
+end
+
+function profiler.results()
+  local _now = nil
+  local function now()
+    _now = _now or os.clock()
+    return _now
+  end
+  local out = {}
+  for label, t in pairs(timers) do
+    table.insert(out, { label = label, time = t.time or now() - t.start })
+  end
+  table.sort(out, function(a, b) return a.time > b.time end)
+  return out
+end
+
+function profiler.profile(label, func, ...)
+  local stop = profiler.start(label)
+  func(...)
+  stop()
+end
+
+return profiler

lib/raster.lua

@@ -39,7 +39,7 @@ function raster.init(width, height, bgcolor)
   raster.charHeight = height
 
   width, height = raster.units.charToBraille(width, height)
-  
+
   bgcolor = bgcolor or raster.defaultBackgroundColor
   if bgcolor~=0 then
     for i=1,width*height do
@@ -204,29 +204,29 @@ end
 
 function raster.drawLine(x1, y1, x2, y2, color)
   x1, y1, x2, y2 = math.floor(x1), math.floor(y1), math.floor(x2), math.floor(y2)
-  
+
   local dx = math.abs(x2 - x1)
   local dy = math.abs(y2 - y1)
-  
+
   local sx = x1 < x2 and 1 or -1
   local sy = y1 < y2 and 1 or -1
-  
+
   local err = dx - dy
-  
+
   while true do
     raster.set(x1, y1, color)
-    
+
     if x1 == x2 and y1 == y2 then
       break
     end
-    
+
     local e2 = 2 * err
-    
+
     if e2 > -dy then
       err = err - dy
       x1 = x1 + sx
     end
-    
+
     if e2 < dx then
       err = err + dx
       y1 = y1 + sy
@@ -266,7 +266,7 @@ function raster.drawCircle(xc, yc, radius, color)
   local x = 0
   local y = radius
   local d = 3 - 2 * radius
-  
+
   while y >= x do
     -- Draw 8 symmetric points
     raster.set(xc + x, yc + y, color)
@@ -277,7 +277,7 @@ function raster.drawCircle(xc, yc, radius, color)
     raster.set(xc - y, yc + x, color)
     raster.set(xc + y, yc - x, color)
     raster.set(xc - y, yc - x, color)
-    
+
     if d < 0 then
       d = d + 4 * x + 6
     else
@@ -291,22 +291,22 @@ end
 function raster.drawEllipse(x1, y1, x2, y2, color)
   if x1 > x2 then x1, x2 = x2, x1 end
   if y1 > y2 then y1, y2 = y2, y1 end
-  
+
   local xc = math.floor((x1 + x2) / 2)
   local yc = math.floor((y1 + y2) / 2)
-  
+
   local a = math.floor((x2 - x1) / 2)
   local b = math.floor((y2 - y1) / 2)
-  
+
   if a <= 0 or b <= 0 then
     return
   end
-  
+
   if a == b then
     raster.drawCircle(xc, yc, a, color)
     return
   end
-  
+
   if a <= 1 and b <= 1 then
     raster.set(xc, yc, color)
     return
@@ -321,21 +321,21 @@ function raster.drawEllipse(x1, y1, x2, y2, color)
     end
     return
   end
-  
+
   local x = 0
   local y = b
   local a2 = a * a
   local b2 = b * b
-  
+
   local d1 = b2 - (a2 * b) + (0.25 * a2)
   local dx = 2 * b2 * x
   local dy = 2 * a2 * y
-  
+
   while dx < dy do
     raster.set(xc + x, yc + y, color)
     raster.set(xc - x, yc + y, color)
     raster.set(xc + x, yc - y, color)
-    
+
     if d1 < 0 then
       x = x + 1
       dx = dx + (2 * b2)
@@ -348,15 +348,15 @@ function raster.drawEllipse(x1, y1, x2, y2, color)
       d1 = d1 + dx - dy + b2
     end
   end
-  
+
   local d2 = b2 * (x + 0.5) * (x + 0.5) + a2 * (y - 1) * (y - 1) - a2 * b2
-  
+
   while y >= 0 do
     raster.set(xc + x, yc + y, color)
     raster.set(xc - x, yc + y, color)
     raster.set(xc + x, yc - y, color)
     raster.set(xc - x, yc - y, color)
-    
+
     if d2 > 0 then
       y = y - 1
       dy = dy - (2 * a2)
@@ -374,17 +374,17 @@ end
 function raster.fillCircle(x, y, r, color)
   x, y = math.floor(x + 0.5), math.floor(y + 0.5)
   r = math.floor(r + 0.5)
-  
+
   if r <= 0 then return end
-  
+
   local minX, maxX = x - r, x + r
   local minY, maxY = y - r, y + r
-  
+
   for py = minY, maxY do
     for px = minX, maxX do
       local dx, dy = px - x, py - y
       local distSquared = dx*dx + dy*dy
-      
+
       if distSquared <= r*r then
         raster.set(px, py, color)
       end
@@ -395,33 +395,33 @@ end
 function raster.fillEllipse(x1, y1, x2, y2, color)
   local centerX = (x1 + x2) / 2
   local centerY = (y1 + y2) / 2
-  
+
   local a = math.abs(x2 - x1) / 2
   local b = math.abs(y2 - y1) / 2
-  
+
   centerX = math.floor(centerX + 0.5)
   centerY = math.floor(centerY + 0.5)
   a = math.floor(a + 0.5)
   b = math.floor(b + 0.5)
-  
+
   if a <= 0 or b <= 0 then return end
-  
+
   if a == b then
     raster.fillCircle(centerX, centerY, a, color)
     return
   end
-  
+
   local minX = centerX - a
   local maxX = centerX + a
   local minY = centerY - b
   local maxY = centerY + b
-  
+
   for y = minY, maxY do
     for x = minX, maxX do
       local dx = x - centerX
       local dy = y - centerY
       local value = (dx*dx)/(a*a) + (dy*dy)/(b*b)
-      
+
       if value <= 1 then
         raster.set(x, y, color)
       end