From 9616a8236bded5d687985ff4b6b06ef041b94a08 Mon Sep 17 00:00:00 2001
From: Richard <richard@example.com>
Date: Thu, 26 Mar 2026 18:43:01 +0100
Subject: [PATCH] initial

---
 .gitignore              |    7 +
 analyze/trace_parser.py |   60 +++
 asm/asm.py              |  239 +++++++++
 asm/test.ant            |   11 +
 asm/twotrail.ant        |  135 +++++
 dev.sh                  |    7 +
 farm/Dockerfile         |    6 +
 farm/Makefile           |  194 +++++++
 farm/ant.c              |   19 +
 farm/ant.h              |   25 +
 farm/farm.c             |  392 ++++++++++++++
 farm/maps.c             |   26 +
 farm/maps.h             |   23 +
 farm/program.c          |   24 +
 farm/program.h          |   70 +++
 generate_maps.sh        |    9 +
 maps/Dockerfile         |    7 +
 maps/maps.js            | 1065 +++++++++++++++++++++++++++++++++++++++
 maps/package-lock.json  |   20 +
 maps/package.json       |    5 +
 readme.md               |   63 +++
 reference/example.ant   |  110 ++++
 reference/fetch_site.sh |    2 +
 reference/random.js     |   19 +
 reference/reference.txt |  235 +++++++++
 25 files changed, 2773 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 analyze/trace_parser.py
 create mode 100755 asm/asm.py
 create mode 100644 asm/test.ant
 create mode 100644 asm/twotrail.ant
 create mode 100755 dev.sh
 create mode 100644 farm/Dockerfile
 create mode 100644 farm/Makefile
 create mode 100644 farm/ant.c
 create mode 100644 farm/ant.h
 create mode 100644 farm/farm.c
 create mode 100644 farm/maps.c
 create mode 100644 farm/maps.h
 create mode 100644 farm/program.c
 create mode 100644 farm/program.h
 create mode 100755 generate_maps.sh
 create mode 100644 maps/Dockerfile
 create mode 100755 maps/maps.js
 create mode 100644 maps/package-lock.json
 create mode 100644 maps/package.json
 create mode 100644 readme.md
 create mode 100644 reference/example.ant
 create mode 100644 reference/fetch_site.sh
 create mode 100644 reference/random.js
 create mode 100644 reference/reference.txt

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ed37a16
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,7 @@
+node_modules
+data
+reference/dev.moment.com
+farm/core*
+farm/build
+farm/bin
+farm/farm
diff --git a/analyze/trace_parser.py b/analyze/trace_parser.py
new file mode 100644
index 0000000..1cc4130
--- /dev/null
+++ b/analyze/trace_parser.py
@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+import os
+import sys
+import argparse
+import logging
+import re
+
+class TraceparserError(Exception):
+    pass
+
+
+class Traceparser:
+    def __init__(self, file):
+        self.logger = logging.getLogger("Traceparser")
+        self.file = file
+
+    def run(self):
+        current_map = None
+        pos = (0, 0)
+        lid = 0
+        for line in self.file:
+            lid += 1
+            line = line.strip()
+            if line.startswith("MAP"):
+                current_map = line.split()[1]
+                print(f"Current map: {current_map}")
+            elif line.startswith("A"):
+                m = re.match(r'A(\d+) @(\d+):(\d+) R:([0-9a-f]+) ([0-9a-f]+) ([0-9a-f]+) ([0-9a-f]+) ([0-9a-f]+) ([0-9a-f]+) ([0-9a-f]+) ([0-9a-f]+)', line)
+                if m:
+                    new_pos = (int(m.group(2)), int(m.group(3)))
+                    if new_pos != pos:
+                        pos = new_pos
+                        print(f"{lid} POS: {pos}")
+
+
+def main(args):
+    traceparser = Traceparser(args.file)
+    traceparser.run()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--debug", "-d", action="store_true")
+    parser.add_argument("file", type=argparse.FileType('r'))
+    args = parser.parse_args()
+    log_format = "%(asctime)s [%(levelname)s] %(message)s"
+    log_date_format = "%Y-%m-%dT%H%M%S%z"
+    log_level = logging.DEBUG if args.debug else logging.INFO
+    logging.basicConfig(format=log_format, level=log_level, datefmt=log_date_format)
+    try:
+        main(args)
+    except TraceparserError as e:
+        logging.error(e)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        logging.error("Interrupted")
+        sys.exit(2)
+    except Exception as e:
+        logging.error(e, exc_info=True)
+        sys.exit(3)
diff --git a/asm/asm.py b/asm/asm.py
new file mode 100755
index 0000000..9259bb6
--- /dev/null
+++ b/asm/asm.py
@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+import os
+import sys
+import argparse
+import logging
+from typing import List
+from dataclasses import dataclass
+from struct import pack
+
+class AssemblerError(Exception):
+    pass
+
+@dataclass
+class Instruction:
+    name: str
+    number: int
+    load_jr: bool = False
+
+class Assembler:
+    def __init__(self):
+        self.prog = bytearray()
+        self.lineno = 0
+        self.labels = {}
+        self.label_references = []
+        self.logger = logging.getLogger("asm")
+        instructions = [
+            Instruction("NOOP", 0), # Come on, we just need one
+            Instruction("ID", 1),
+            Instruction("TAG", 2),
+
+            Instruction("MOVE", 3),
+            Instruction("SENSE", 4),
+            Instruction("PROBE", 5),
+
+            Instruction("PICKUP", 6),
+            Instruction("CARRYING", 7),
+            Instruction("DROP", 8),
+
+            Instruction("SMELL", 9),
+            Instruction("SNIFF", 0xa),
+            Instruction("MARK", 0xb),
+
+            Instruction("SET", 0x10),
+            Instruction("AND", 0x11),
+            Instruction("OR", 0x12),
+            Instruction("XOR", 0x13),
+            Instruction("LSHIFT", 0x14),
+            Instruction("RSHIFT", 0x15),
+            Instruction("ADD", 0x16),
+            Instruction("SUB", 0x17),
+            Instruction("MUL", 0x18),
+            Instruction("DIV", 0x19),
+            Instruction("MOD", 0x1a),
+            Instruction("RANDOM", 0x1b),
+
+            Instruction("SJR", 0x20), # New 'hidden' instruction to support jmp instructions
+            Instruction("MJR", 0x21), # New 'hidden' instruction to support jmp instruction from reg
+            Instruction("JMP", 0x22, True),
+            Instruction("CALL", 0x23, True),
+            Instruction("JEQ", 0x24, True),
+            Instruction("JNE", 0x25, True),
+            Instruction("JGT", 0x26, True),
+            Instruction("JLT", 0x27, True)
+
+
+        ]
+        self.instructions = {i.name:i for i in instructions}
+        self.constants = {
+            "r0": 0x80,
+            "r1": 0x81,
+            "r2": 0x82,
+            "r3": 0x83,
+            "r4": 0x84,
+            "r5": 0x85,
+            "r6": 0x86,
+            "r7": 0x87,
+            "jr": 0x88,
+            "empty": 0,
+            "wall": 1,
+            "food": 2,
+            "nest": 3,
+            "ant": 4,
+            "here": 0,
+            "n": 1,
+            "e": 2,
+            "s": 3,
+            "w": 4,
+            "north": 1,
+            "east": 2,
+            "south": 3,
+            "west": 4,
+            "random": 5,
+            "ch_red": 0,
+            "ch_blue": 1,
+            "ch_green": 2,
+            "ch_yellow": 3,
+
+        }
+
+    def write(self, bt):
+        if type(bt) == int:
+            self.prog += bytes([bt])
+        else:
+            self.prog += bt
+        #print(self.prog.hex())
+
+    def handle_label(self, iname):
+        lblname = iname[:-1].lower()
+        if lblname in self.labels:
+            raise AssemblerError(f"Label {lblname} defined twice")
+        self.labels[lblname] = len(self.prog) // 4
+
+    def handle_directive(self, iname, args):
+        if iname in ['.alias', '.const', '.tag']:
+            source = args[0] if iname == '.tag' else args[1]
+            dest = args[1].lower() if iname == '.tag' else args[0].lower()
+
+            self.logger.debug(f"{iname} {dest} = {self.resolve_arg(source)}")
+            if dest in self.constants:
+                raise AssemblerError(f"Overwriting const {dest}")
+            self.constants[dest] = self.resolve_arg(source)
+        else:
+            raise AssemblerError(f"Invalid directive {iname}")
+
+    def resolve_arg(self, arg, raise_if_fail=True):
+        arg = arg.lower()
+        if arg in self.constants:
+            result = self.constants[arg]
+        elif arg.isnumeric():
+            result = int(arg)
+        elif arg.startswith("0x"):
+            result = int(arg, 16)
+        elif raise_if_fail:
+            raise AssemblerError(f"Cant parse argument {arg}")
+        else:
+            result = 0
+        if result > 255:
+            raise AssemblerError(f"Arg {arg} value bigger than 255")
+        return result
+
+    def handle_load_jr(self, instruction, target):
+        target_reg = self.resolve_arg(target, raise_if_fail=False)
+        if instruction.name == "JMP" and target_reg in range(0x80, 0x88):
+            mjr = self.instructions["MJR"]
+            data = [mjr.number, target_reg, 0, 0]
+        else:
+            sjr = self.instructions["SJR"]
+            data = [sjr.number, 0, 0, 0]
+            offset = len(self.prog) + 1
+            self.label_references.append((target, offset))
+        self.write(bytes(data))
+
+    def handle_instruction(self, iname, args):
+        instruction = self.instructions[iname.upper()]
+        if len(args) > 3:
+            raise AssemblerError("Too many arguments")
+        data = [instruction.number]
+        if instruction.load_jr:
+            target = args[-1]
+            self.handle_load_jr(instruction, target)
+            args = args[:-1]
+        for i in range(3):
+            if i >= len(args):
+                data.append(0)
+            else:
+                data.append(self.resolve_arg(args[i]))
+
+        self.write(bytes(data))
+
+    def assemble_line(self, line):
+        pre_offset = len(self.prog)
+        line = line.strip()
+        # remove comments
+        parts = line.split(";", 1)
+        if len(parts) == 2:
+            line = parts[0]
+
+        # split into parts
+        parts = line.split()
+        if len(parts) == 0:
+            return
+        iname = parts[0]
+
+        if iname.endswith(":"):
+            self.handle_label(iname)
+        elif iname.startswith("."):
+            self.handle_directive(iname, parts[1:])
+        elif iname.upper() in self.instructions:
+            self.handle_instruction(iname, parts[1:])
+        else:
+            raise AssemblerError(f"Instruction {iname} not found")
+        new_data = self.prog[pre_offset:]
+        self.logger.debug(f"{line.strip()} : {new_data.hex()}")
+
+    def resolve_references(self):
+        for reflabel, refoffset in self.label_references:
+            if not reflabel in self.labels:
+                raise AssemblerError(f"Could not resolve label {reflabel}")
+            lblloc = self.labels[reflabel]
+            self.prog[refoffset] = lblloc & 0xff
+            self.prog[refoffset + 1] = lblloc >> 8 & 0xff
+            self.prog[refoffset + 2] = lblloc >> 16 & 0xff
+
+    def assemble_text(self, data):
+        for line in data.split("\n"):
+            self.lineno += 1
+            self.assemble_line(line)
+        self.resolve_references()
+        return self.prog
+
+    def assemble_file(self, inf, outf):
+        with open(inf) as asm:
+            assy = asm.read()
+
+        assy = "JMP main\n" + assy
+        prog = self.assemble_text(assy)
+
+        output = sys.stdout.buffer if outf is None else open(outf, 'wb')
+        output.write(pack("<I", len(prog) >> 2)) # This is the header of the file: num_instructions
+        output.write(prog)
+        if output != sys.stdout:
+            output.close()
+
+
+
+if __name__ == '__main__':
+    assembler = Assembler()
+    parser = argparse.ArgumentParser(description='Assemble a program.')
+    parser.add_argument('file', help='File to assemble')
+    parser.add_argument('--output', metavar='FILE',
+                        help='Output file (stdout if ommitted)')
+    parser.add_argument('--debug', '-d', action='store_true')
+    args = parser.parse_args()
+    logging.basicConfig(level=logging.DEBUG  if args.debug else logging.INFO)
+    try:
+      assembler.assemble_file(args.file, args.output)
+    except AssemblerError as e:
+      sys.stderr.write(f"Error at line: {assembler.lineno}: {e}\n")
+      sys.exit(1)
diff --git a/asm/test.ant b/asm/test.ant
new file mode 100644
index 0000000..a436573
--- /dev/null
+++ b/asm/test.ant
@@ -0,0 +1,11 @@
+SET r5 0xaa
+main:
+    ID r0
+    SET r5 0x55
+    ADD r5 0x5
+    RSHIFT r5 4
+    LSHIFT r5 4
+    RANDOM r1 0x1f
+    RANDOM r2 10
+    SNIFF CH_RED
+    MOVE RANDOM
diff --git a/asm/twotrail.ant b/asm/twotrail.ant
new file mode 100644
index 0000000..2028daf
--- /dev/null
+++ b/asm/twotrail.ant
@@ -0,0 +1,135 @@
+; ── SWARM FORAGER ────────────────────────────
+; Random walk to find food, dead reckoning to
+; navigate home. Pheromone marks food for others.
+; Hit play, then try improving it!
+
+; ── Registers ──
+.alias dx   r1           ; x displacement from nest
+.alias dy   r2           ; y displacement from nest
+.alias ret  r3           ; return address for CALL
+
+; ── Pheromone ──
+.const PH_FOOD CH_RED      ; marks food locations
+.const PH_NEST CH_BLUE
+.const PHER_INIT 255
+.const PHER_DECAY 2
+; ── Roles (visible in simulation viewer) ──
+.tag 0 foraging
+.tag 1 homing
+
+; ──────────────────────────────────────────────
+main:
+    set r7 PHER_INIT
+loop:
+    CARRYING
+    JNE r0 0 go_home
+    TAG foraging
+
+; ── SEARCH: find food ─────────────────────────
+search:
+    SENSE FOOD
+    JNE r0 0 grab
+
+; if we are too far from the food, dont mark
+    JLT r7 PHER_DECAY smell_trail
+    SUB r7 PHER_DECAY
+; if there is already a trail here, dont mark
+    SNIFF PH_NEST HERE r0
+    JNE r0 0 smell_trail
+    MARK PH_NEST r7
+
+smell_trail:
+    SMELL PH_FOOD
+    JNE r0 0 step
+    SENSE EMPTY
+step:
+    CALL ret move_track
+    JMP loop
+
+grab:
+    CALL ret move_track
+    PICKUP
+    MARK PH_FOOD 255
+    SET r6 PHER_INIT
+    JMP loop
+
+; ── GO HOME: dead reckon toward nest ──────────
+go_home:
+    TAG homing
+; if we are too far from the food, dont mark
+    JLT r6 PHER_DECAY sense_nest
+    SUB r6 PHER_DECAY
+; if there is already a trail here, dont mark
+    SNIFF PH_FOOD HERE r0
+    JNE r0 0 sense_nest
+    MARK PH_FOOD r6
+sense_nest:
+    SENSE NEST
+    JNE r0 0 deliver
+smell_nest:
+    SMELL PH_NEST
+    JNE r0 0 move_track
+    RANDOM r0 4
+    JEQ r0 0 wander       ; 25% random to unstick walls
+    CALL ret home_dir
+    CALL ret move_track
+    JMP main
+wander:
+    SENSE EMPTY
+    CALL ret move_track
+    JMP main
+
+deliver:
+    CALL ret move_track
+    DROP
+    SET r7 PHER_INIT
+    JMP main
+
+; ══════════════════════════════════════════════
+; SUBROUTINES — CALL ret <label>, return JMP ret
+; ══════════════════════════════════════════════
+
+; home_dir: set r0 = direction toward nest
+home_dir:
+    SET r4 dx
+    JGT dx 0 hd_dxp
+    SET r4 0
+    SUB r4 dx
+hd_dxp:
+    SET r5 dy
+    JGT dy 0 hd_dyp
+    SET r5 0
+    SUB r5 dy
+hd_dyp:
+    JGT r5 r4 hd_y
+    JGT dx 0 hd_w
+    SET r0 2
+    JMP ret
+hd_w:
+    SET r0 4
+    JMP ret
+hd_y:
+    JGT dy 0 hd_n
+    SET r0 3
+    JMP ret
+hd_n:
+    SET r0 1
+    JMP ret
+
+; move_track: MOVE r0, then update dx/dy
+move_track:
+    MOVE r0
+    JEQ r0 1 mt_n
+    JEQ r0 2 mt_e
+    JEQ r0 3 mt_s
+    SUB dx 1
+    JMP ret
+mt_n:
+    SUB dy 1
+    JMP ret
+mt_e:
+    ADD dx 1
+    JMP ret
+mt_s:
+    ADD dy 1
+    JMP ret
diff --git a/dev.sh b/dev.sh
new file mode 100755
index 0000000..319ca09
--- /dev/null
+++ b/dev.sh
@@ -0,0 +1,7 @@
+#!/bin/bash
+echo "Building image..."
+pushd farm
+docker build -qt ants-dev .
+popd
+echo "Dropping into shell..."
+docker run --rm -ti -v $PWD/data:/data -v $PWD/farm:/home/dev/farm ants-dev
diff --git a/farm/Dockerfile b/farm/Dockerfile
new file mode 100644
index 0000000..7ef1ff2
--- /dev/null
+++ b/farm/Dockerfile
@@ -0,0 +1,6 @@
+FROM debian
+RUN apt update && apt install -y curl vim wget xz-utils build-essential less
+RUN useradd -m dev
+USER dev
+WORKDIR /home/dev/farm
+ADD . /home/dev/farm
diff --git a/farm/Makefile b/farm/Makefile
new file mode 100644
index 0000000..5b4ef07
--- /dev/null
+++ b/farm/Makefile
@@ -0,0 +1,194 @@
+#### PROJECT SETTINGS ####
+# The name of the executable to be created
+BIN_NAME := farm
+# Compiler used
+CC ?= gcc
+# Extension of source files used in the project
+SRC_EXT = c
+# Path to the source directory, relative to the makefile
+SRC_PATH = .
+# Space-separated pkg-config libraries used by this project
+LIBS =
+# General compiler flags
+COMPILE_FLAGS = -std=c99 -Wall -Wextra -g
+# Additional release-specific flags
+RCOMPILE_FLAGS = -D NDEBUG
+# Additional debug-specific flags
+DCOMPILE_FLAGS = -D DEBUG
+# Add additional include paths
+INCLUDES = -I $(SRC_PATH)
+# General linker settings
+LINK_FLAGS =
+# Additional release-specific linker settings
+RLINK_FLAGS =
+# Additional debug-specific linker settings
+DLINK_FLAGS =
+# Destination directory, like a jail or mounted system
+DESTDIR = /
+# Install path (bin/ is appended automatically)
+INSTALL_PREFIX = usr/local
+#### END PROJECT SETTINGS ####
+
+# Optionally you may move the section above to a separate config.mk file, and
+# uncomment the line below
+# include config.mk
+
+# Generally should not need to edit below this line
+
+# Obtains the OS type, either 'Darwin' (OS X) or 'Linux'
+UNAME_S:=$(shell uname -s)
+
+# Function used to check variables. Use on the command line:
+# make print-VARNAME
+# Useful for debugging and adding features
+print-%: ; @echo $*=$($*)
+
+# Shell used in this makefile
+# bash is used for 'echo -en'
+SHELL = /bin/bash
+# Clear built-in rules
+.SUFFIXES:
+# Programs for installation
+INSTALL = install
+INSTALL_PROGRAM = $(INSTALL)
+INSTALL_DATA = $(INSTALL) -m 644
+
+# Append pkg-config specific libraries if need be
+ifneq ($(LIBS),)
+	COMPILE_FLAGS += $(shell pkg-config --cflags $(LIBS))
+	LINK_FLAGS += $(shell pkg-config --libs $(LIBS))
+endif
+
+# Verbose option, to output compile and link commands
+export V := false
+export CMD_PREFIX := @
+ifeq ($(V),true)
+	CMD_PREFIX :=
+endif
+
+# Combine compiler and linker flags
+release: export CFLAGS := $(CFLAGS) $(COMPILE_FLAGS) $(RCOMPILE_FLAGS)
+release: export LDFLAGS := $(LDFLAGS) $(LINK_FLAGS) $(RLINK_FLAGS)
+debug: export CFLAGS := $(CFLAGS) $(COMPILE_FLAGS) $(DCOMPILE_FLAGS)
+debug: export LDFLAGS := $(LDFLAGS) $(LINK_FLAGS) $(DLINK_FLAGS)
+
+# Build and output paths
+release: export BUILD_PATH := build/release
+release: export BIN_PATH := bin/release
+debug: export BUILD_PATH := build/debug
+debug: export BIN_PATH := bin/debug
+install: export BIN_PATH := bin/release
+
+# Find all source files in the source directory, sorted by most
+# recently modified
+ifeq ($(UNAME_S),Darwin)
+	SOURCES = $(shell find $(SRC_PATH) -name '*.$(SRC_EXT)' | sort -k 1nr | cut -f2-)
+else
+	SOURCES = $(shell find $(SRC_PATH) -name '*.$(SRC_EXT)' -printf '%T@\t%p\n' \
+						| sort -k 1nr | cut -f2-)
+endif
+
+# fallback in case the above fails
+rwildcard = $(foreach d, $(wildcard $1*), $(call rwildcard,$d/,$2) \
+						$(filter $(subst *,%,$2), $d))
+ifeq ($(SOURCES),)
+	SOURCES := $(call rwildcard, $(SRC_PATH), *.$(SRC_EXT))
+endif
+
+# Set the object file names, with the source directory stripped
+# from the path, and the build path prepended in its place
+OBJECTS = $(SOURCES:$(SRC_PATH)/%.$(SRC_EXT)=$(BUILD_PATH)/%.o)
+# Set the dependency files that will be used to add header dependencies
+DEPS = $(OBJECTS:.o=.d)
+
+# Version macros
+# Comment/remove this section to remove versioning
+USE_VERSION := false
+# If this isn't a git repo or the repo has no tags, git describe will return non-zero
+ifeq ($(shell git describe > /dev/null 2>&1 ; echo $$?), 0)
+	USE_VERSION := true
+	VERSION := $(shell git describe --tags --long --dirty --always | \
+		sed 's/v\([0-9]*\)\.\([0-9]*\)\.\([0-9]*\)-\?.*-\([0-9]*\)-\(.*\)/\1 \2 \3 \4 \5/g')
+	VERSION_MAJOR := $(word 1, $(VERSION))
+	VERSION_MINOR := $(word 2, $(VERSION))
+	VERSION_PATCH := $(word 3, $(VERSION))
+	VERSION_REVISION := $(word 4, $(VERSION))
+	VERSION_HASH := $(word 5, $(VERSION))
+	VERSION_STRING := \
+		"$(VERSION_MAJOR).$(VERSION_MINOR).$(VERSION_PATCH).$(VERSION_REVISION)-$(VERSION_HASH)"
+	override CFLAGS := $(CFLAGS) \
+		-D VERSION_MAJOR=$(VERSION_MAJOR) \
+		-D VERSION_MINOR=$(VERSION_MINOR) \
+		-D VERSION_PATCH=$(VERSION_PATCH) \
+		-D VERSION_REVISION=$(VERSION_REVISION) \
+		-D VERSION_HASH=\"$(VERSION_HASH)\"
+endif
+
+# Standard, non-optimized release build
+.PHONY: release
+release: dirs
+ifeq ($(USE_VERSION), true)
+	@echo "Beginning release build v$(VERSION_STRING)"
+else
+	@echo "Beginning release build"
+endif
+	@$(MAKE) all --no-print-directory
+
+# Debug build for gdb debugging
+.PHONY: debug
+debug: dirs
+ifeq ($(USE_VERSION), true)
+	@echo "Beginning debug build v$(VERSION_STRING)"
+else
+	@echo "Beginning debug build"
+endif
+	@$(MAKE) all --no-print-directory
+
+# Create the directories used in the build
+.PHONY: dirs
+dirs:
+	@echo "Creating directories"
+	@mkdir -p $(dir $(OBJECTS))
+	@mkdir -p $(BIN_PATH)
+
+# Installs to the set path
+.PHONY: install
+install:
+	@echo "Installing to $(DESTDIR)$(INSTALL_PREFIX)/bin"
+	@$(INSTALL_PROGRAM) $(BIN_PATH)/$(BIN_NAME) $(DESTDIR)$(INSTALL_PREFIX)/bin
+
+# Uninstalls the program
+.PHONY: uninstall
+uninstall:
+	@echo "Removing $(DESTDIR)$(INSTALL_PREFIX)/bin/$(BIN_NAME)"
+	@$(RM) $(DESTDIR)$(INSTALL_PREFIX)/bin/$(BIN_NAME)
+
+# Removes all build files
+.PHONY: clean
+clean:
+	@echo "Deleting $(BIN_NAME) symlink"
+	@$(RM) $(BIN_NAME)
+	@echo "Deleting directories"
+	@$(RM) -r build
+	@$(RM) -r bin
+
+# Main rule, checks the executable and symlinks to the output
+all: $(BIN_PATH)/$(BIN_NAME)
+	@echo "Making symlink: $(BIN_NAME) -> $<"
+	@$(RM) $(BIN_NAME)
+	@ln -s $(BIN_PATH)/$(BIN_NAME) $(BIN_NAME)
+
+# Link the executable
+$(BIN_PATH)/$(BIN_NAME): $(OBJECTS)
+	@echo "Linking: $@"
+	$(CMD_PREFIX)$(CC) $(OBJECTS) $(LDFLAGS) -o $@
+
+# Add dependency files, if they exist
+-include $(DEPS)
+
+# Source file rules
+# After the first compilation they will be joined with the rules from the
+# dependency files to provide header dependencies
+$(BUILD_PATH)/%.o: $(SRC_PATH)/%.$(SRC_EXT)
+	@echo "Compiling: $< -> $@"
+	$(CMD_PREFIX)$(CC) $(CFLAGS) $(INCLUDES) -MP -MMD -c $< -o $@
diff --git a/farm/ant.c b/farm/ant.c
new file mode 100644
index 0000000..ecf3d5a
--- /dev/null
+++ b/farm/ant.c
@@ -0,0 +1,19 @@
+#include "ant.h"
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+void reset_ants(struct Ant* ants, unsigned short nest) {
+    memset(ants, 0, sizeof(struct Ant) * NUM_ANTS);
+    for (int i = 0; i < NUM_ANTS; i++) {
+        ants[i].id = i;
+        ants[i].cell = nest;
+    }
+}
+
+struct Ant* create_ants() {
+    int ants_size = sizeof(struct Ant) * NUM_ANTS;
+    struct Ant *ants = (struct Ant *)malloc(ants_size);
+    return ants;
+}
diff --git a/farm/ant.h b/farm/ant.h
new file mode 100644
index 0000000..bd76710
--- /dev/null
+++ b/farm/ant.h
@@ -0,0 +1,25 @@
+#ifdef DEBUG
+#define NUM_ANTS 1
+#else
+#define NUM_ANTS 200
+#endif
+
+struct Ant {
+    unsigned char id;
+    unsigned int pc;
+    unsigned short cell;
+    unsigned char carrying;
+    int r0;
+    int r1;
+    int r2;
+    int r3;
+    int r4;
+    int r5;
+    int r6;
+    int r7;
+    int jr;
+
+};
+
+struct Ant* create_ants();
+void reset_ants(struct Ant* ants, unsigned short nest);
diff --git a/farm/farm.c b/farm/farm.c
new file mode 100644
index 0000000..99d92c2
--- /dev/null
+++ b/farm/farm.c
@@ -0,0 +1,392 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "maps.h"
+#include "program.h"
+#include "ant.h"
+
+#define TICKS 2000
+#define MAX_OPS 64
+#define NUM_CHANNELS 4
+
+const char map_offsets[] = { 0, -MAP_WIDTH , 1, MAP_WIDTH, -1 };
+#define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
+#define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
+#define cell_from(org, dir) (org) + map_offsets[(dir)]
+#define reg_id(rid) (rid) < 8 ? (rid) : (rid) - 0x80
+
+#define get_value(ant, v) (v) < 0x80 ? (v) : get_reg((ant), (v))
+
+static inline unsigned int rnum(unsigned int* rstate) {
+    unsigned int e = *rstate + 0x9e3779b9;
+    *rstate = e;
+    e = (e ^ (e >> 16)) * 0x85ebca6b;
+    e = (e ^ (e >> 13)) * 0xc2b2ae35;
+    e = e ^ (e >> 16);
+    //e = e / 0x100000000;
+    return e;
+}
+
+// static inline unsigned int rnum(unsigned int* rstate) {
+//     return rand();
+// }
+
+
+
+static inline void set_reg(struct Ant* ant, unsigned char rid, unsigned int v) {
+    switch(reg_id(rid)) {
+        case 0:
+            ant->r0 = v;
+            break;
+        case 1:
+            ant->r1 = v;
+            break;
+        case 2:
+            ant->r2 = v;
+            break;
+        case 3:
+            ant->r3 = v;
+            break;
+        case 4:
+            ant->r4 = v;
+            break;
+        case 5:
+            ant->r5 = v;
+            break;
+        case 6:
+            ant->r6 = v;
+            break;
+        case 7:
+            ant->r7 = v;
+            break;
+    }
+}
+static inline unsigned int get_reg(struct Ant* ant, unsigned char rid) {
+    switch(reg_id(rid)) {
+        case 0:
+            return ant->r0;
+        case 1:
+            return ant->r1;
+        case 2:
+            return ant->r2;
+        case 3:
+            return ant->r3;
+        case 4:
+            return ant->r4;
+        case 5:
+            return ant->r5;
+        case 6:
+            return ant->r6;
+        case 7:
+            return ant->r7;
+        default:
+            return 0;
+    }
+}
+
+#ifdef DEBUG
+#define debug(msg, ...) printf((msg), ##__VA_ARGS__)
+#else
+#define debug(msg, ...)
+#endif
+
+#define debug_ant(ant) debug("A%d @%d:%d R:%02x %02x %02x %02x %02x %02x %02x %02x\n", (ant)->id, (ant)->cell % MAP_WIDTH, (ant)->cell / MAP_WIDTH, (ant)->r0, (ant)->r1, (ant)->r2, (ant)->r3, (ant)->r4, (ant)->r5, (ant)->r6, (ant)->r7)
+#define debug_ins(pc, ins) debug("I%02d %s %02x %02x %02x\n", pc, instruction_names[ins->op], ins->arg1, ins->arg2, ins->arg3)
+
+int run_simulations(struct Maps* maps, struct Program* program) {
+    int ops;
+    int cost;
+    int score;
+    int dirs[4];
+    unsigned int rstate;
+    int cell;
+    int found_dirs = 0;
+    struct Map* map;
+    int v1, v2, v3, res;
+    struct Ant* ant;
+    unsigned int pc;
+    struct Instruction* ins;
+    struct Ant* ants = create_ants();
+    unsigned char food[NUM_CELLS];
+    unsigned char smells[NUM_CHANNELS][NUM_CELLS];
+
+
+    for (unsigned int mi = 0; mi < maps->num_maps; mi++) {
+        map = &maps->maps + mi;
+        debug("MAP %s\n", map->name);
+        memset(&smells, 0, NUM_CHANNELS * NUM_CELLS);
+        reset_ants(ants, map->nest);
+        score = 0;
+        rstate = 2;
+        for (int i = 0; i < NUM_CELLS; i++ ) {
+            food[i] = map->cells[i] == CELL_FOOD ? 1 : 0;
+        }
+
+        for (int t=0; t < TICKS; t++) {
+            for (int ai=0; ai < NUM_ANTS; ai++) {
+
+                ops = 0;
+                while (ops < MAX_OPS) {
+                    cost = 1;
+                    ant = &ants[ai];
+                    pc = ant->pc;
+                    ins = &program->instructions + pc;
+                    debug_ins(pc, ins);
+                    ant->pc = (pc + 1) % program->num_instructions;
+                    switch(ins->op) {
+                        case INS_ID:
+                            set_reg(ant, ins->arg1, ant->id);
+                            break;
+                        case INS_TAG:
+                            //noop
+                            break;
+                        case INS_MOVE:
+                            v1 = get_value(ant, ins->arg1);
+                            if (v1 == 5) {
+                                v1 = rnum(&rstate) % 4 + 1;
+                            }
+                            cell = cell_from(ant->cell, v1);
+                            if (cell > 0 && cell < NUM_CELLS && map->cells[cell] != CELL_WALL) {
+                                ant->cell = cell;
+                            }
+                            cost += MAX_OPS;
+                            break;
+                        case INS_SENSE:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = ins->arg2;
+                            found_dirs = 0;
+
+                            if (map->cells[cell_from(ant->cell, 1)] == v1) dirs[found_dirs++] = 1;
+                            if (map->cells[cell_from(ant->cell, 2)] == v1) dirs[found_dirs++] = 2;
+                            if (map->cells[cell_from(ant->cell, 3)] == v1) dirs[found_dirs++] = 3;
+                            if (map->cells[cell_from(ant->cell, 4)] == v1) dirs[found_dirs++] = 4;
+                            if (found_dirs == 0) {
+                                res = 0;
+                            } else if (found_dirs == 1) {
+                                res = dirs[0];
+                            } else {
+                                res = dirs[rnum(&rstate) % found_dirs];
+                            }
+                            set_reg(ant, v2, res);
+                            break;
+
+                        case INS_PROBE:
+                            v1 = get_value(ant, ins->arg1);
+                            v1 = cell_from(ant->cell, v1);
+                            v1 = map->cells[v1];
+                            set_reg(ant, ins->arg2, v1);
+                            break;
+                        case INS_PICKUP:
+                            debug("PICKUP?\n");
+                            if (!ant->carrying && food[ant->cell] > 0) {
+                                ant->carrying = food[ant->cell]--;
+                                debug("PICKUP!\n");
+                            }
+                            cost += MAX_OPS;
+                            break;
+                        case INS_CARRYING:
+                            set_reg(ant, ins->arg1, ant->carrying);
+                            break;
+                        case INS_DROP:
+                            debug("DROP?\n");
+                            if (ant->carrying) {
+                                ant -> carrying = 0;
+                                if (map->nest == ant->cell){
+                                    debug("DROP SCORE\n");
+                                    score += 1;
+                                } else {
+                                    food[ant->cell] += 1;
+                                    debug("DROP!\n");
+                                }
+                            }
+                            cost += MAX_OPS;
+                            break;
+                        case INS_SMELL:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = ins->arg2;
+                            res = 0;
+
+                            v3 = smells[v1][cell_from(ant->cell, 1)];
+                            if (v3 > res) found_dirs = 0;
+                            if (v3 >= res) dirs[found_dirs++] = 1;
+
+                            v3 = smells[v1][cell_from(ant->cell, 2)];
+                            if (v3 > res) found_dirs = 0;
+                            if (v3 >= res) dirs[found_dirs++] = 2;
+
+                            v3 = smells[v1][cell_from(ant->cell, 3)];
+                            if (v3 > res) found_dirs = 0;
+                            if (v3 >= res) dirs[found_dirs++] = 3;
+
+                            v3 = smells[v1][cell_from(ant->cell, 4)];
+                            if (v3 > res) found_dirs = 0;
+                            if (v3 >= res) dirs[found_dirs++] = 4;
+                            if (res == 0) {
+                                res = (rnum(&rstate) % 4) + 1;
+                            }else if (found_dirs == 1) {
+                                res = dirs[0];
+                            } else {
+                                res = dirs[rnum(&rstate) % found_dirs];
+                            }
+                            set_reg(ant, v2, res);
+                            break;
+                        case INS_SNIFF:
+                            v1 = ins->arg1;
+                            v2 = get_value(ant, ins->arg2);
+                            v2 = cell_from(ant->cell, v2);
+                            v1 = smells[v1][v2];
+                            set_reg(ant, ins->arg3, v1);
+                            break;
+                        case INS_MARK:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            v3 = smells[v1][ant->cell];
+                            smells[v1][ant->cell] = MAX(v3+v2, 255);
+                            break;
+                        case INS_SET:
+                            set_reg(ant, ins->arg1, ins->arg2);
+                            break;
+                        case INS_AND:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            set_reg(ant, ins->arg1, v1 & v2);
+                            break;
+                        case INS_OR:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            set_reg(ant, ins->arg1, v1 | v2);
+                            break;
+                        case INS_XOR:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            set_reg(ant, ins->arg1, v1 | v2);
+                            break;
+                        case INS_LSHIFT:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            set_reg(ant, ins->arg1, v1 << v2);
+                            break;
+                        case INS_RSHIFT:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            set_reg(ant, ins->arg1, v1 >> v2);
+                            break;
+                        case INS_ADD:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            set_reg(ant, ins->arg1, v1 + v2);
+                            break;
+                        case INS_SUB:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            set_reg(ant, ins->arg1, v1 - v2);
+                            break;
+                        case INS_MUL:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            set_reg(ant, ins->arg1, v1 * v2);
+                            break;
+                        case INS_DIV:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            if (v2 != 0) {
+                                set_reg(ant, ins->arg1, v1 / v2);
+                            }
+                            break;
+                        case INS_MOD:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            set_reg(ant, ins->arg1, v1 % v2);
+                            break;
+                        case INS_RANDOM:
+                            v2 = get_value(ant, ins->arg2);
+                            if (v2 != 0) {
+                                v1 = rnum(&rstate) % v2;
+                                set_reg(ant, ins->arg1, v1);
+                            }
+                            break;
+                        case INS_SJR:
+                            ant->jr = *((int*)ins) >> 8;
+                            break;
+                        case INS_MJR:
+                            ant->jr = get_value(ant, ins->arg1);
+                            break;
+                        case INS_JMP:
+                            ant->pc = ant->jr;
+                            break;
+                        case INS_CALL:
+                            set_reg(ant, ins->arg1, ant->pc);
+                            ant->pc = ant->jr;
+                            break;
+                        case INS_JEQ:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            if (v1 == v2) {
+                                ant->pc = ant->jr;
+                            }
+                            break;
+                        case INS_JNE:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            if (v1 != v2) {
+                                ant->pc = ant->jr;
+                            }
+                            break;
+                        case INS_JGT:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            if (v1 > v2) {
+                                ant->pc = ant->jr;
+                            }
+                            break;
+                        case INS_JLT:
+                            v1 = get_value(ant, ins->arg1);
+                            v2 = get_value(ant, ins->arg2);
+                            if (v1 < v2) {
+                                ant->pc = ant->jr;
+                            }
+                            break;
+                    };
+                    debug_ant(ant);
+                    ops += cost;
+                }
+            }
+            for (int pi = 0; pi < NUM_CHANNELS; pi++) {
+                for (int ci = 0; ci < NUM_CELLS; ci++) {
+                    if (smells[pi][ci] > 0) smells[pi][ci]--;
+                }
+            }
+        }
+    }
+    return score;
+}
+
+int main(int argc, char* argv[])
+{
+  struct Program* program = NULL;
+  struct Maps* maps = NULL;
+  int score = 0;
+  if (argc < 3) {
+      printf("Usage: farm <maps file> <program file>\n");
+      return 1;
+  }
+  char* maps_filename = argv[1];
+  char* program_filename = argv[2];
+
+  maps = load_maps(maps_filename);
+  program = load_program(program_filename);
+  int result = 0;
+  if (maps == NULL) {
+      printf("Could not load maps\n");
+      result = 2;
+  }else if (program == NULL) {
+      printf("Could not load program\n");
+      result = 3;
+  } else {
+      score = run_simulations(maps, program);
+  }
+  free(program);
+  free(maps);
+  printf("Score: %d\n", score);
+  return result;
+}
diff --git a/farm/maps.c b/farm/maps.c
new file mode 100644
index 0000000..71136fb
--- /dev/null
+++ b/farm/maps.c
@@ -0,0 +1,26 @@
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "maps.h"
+struct Maps* load_maps(char* filename) {
+    FILE* f = fopen(filename, "r");
+    if (f == NULL) {
+        return NULL;
+    }
+    int num_maps;
+    int num_read = fread(&num_maps, 4, 1, f);
+
+    if (num_read != 1 || num_maps > 10000) {
+        return NULL;
+    }
+
+    int mapfile_size = sizeof(struct Map) * num_maps;
+    struct Maps *maps = (struct Maps *)malloc(mapfile_size + 4);
+    maps->num_maps = num_maps;
+    num_read = fread(&maps->maps, 1, mapfile_size, f);
+    if (num_read != mapfile_size) {
+        return NULL;
+    }
+    fclose(f);
+    return maps;
+}
diff --git a/farm/maps.h b/farm/maps.h
new file mode 100644
index 0000000..dcf961a
--- /dev/null
+++ b/farm/maps.h
@@ -0,0 +1,23 @@
+
+#define MAP_WIDTH 128
+#define MAP_HEIGHT 128
+#define NUM_CELLS MAP_WIDTH * MAP_HEIGHT
+#define MAP_NAME_LENGTH 32
+#define CELL_EMPTY 0
+#define CELL_WALL 1
+#define CELL_FOOD 2
+#define CELL_NEST 3
+
+
+struct Map {
+    char name[MAP_NAME_LENGTH];
+    unsigned short nest;
+    unsigned char cells[MAP_WIDTH * MAP_HEIGHT];
+};
+
+struct Maps {
+    unsigned int num_maps;
+    struct Map maps;
+};
+
+struct Maps* load_maps(char* filename);
diff --git a/farm/program.c b/farm/program.c
new file mode 100644
index 0000000..e8dca19
--- /dev/null
+++ b/farm/program.c
@@ -0,0 +1,24 @@
+#include "program.h"
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+struct Program* load_program(char* filename) {
+    FILE* f = fopen(filename, "r");
+    if (f == NULL) {
+        return NULL;
+    }
+    int num_instructions;
+    int num_read = fread(&num_instructions, 4, 1, f);
+    if (num_read != 1) {
+        return NULL;
+    }
+    int program_size = 4 + num_instructions * 4;
+    struct Program* program = (struct Program *)malloc(program_size);
+    program->num_instructions = num_instructions;
+    num_read = fread(&program->instructions, 1, program_size-4, f);
+    if (num_read != program_size-4) {
+        return NULL;
+    }
+    fclose(f);
+    return program;
+}
diff --git a/farm/program.h b/farm/program.h
new file mode 100644
index 0000000..9875e23
--- /dev/null
+++ b/farm/program.h
@@ -0,0 +1,70 @@
+#define INS_NOOP 0
+#define INS_ID 1
+#define INS_TAG 2
+#define INS_MOVE 3
+
+#define INS_SENSE 4
+#define INS_PROBE 5
+
+#define INS_PICKUP 6
+#define INS_CARRYING 7
+#define INS_DROP 8
+
+#define INS_SMELL 9
+#define INS_SNIFF 0xa
+#define INS_MARK 0xb
+
+#define INS_SET 0x10
+#define INS_AND 0x11
+#define INS_OR 0x12
+#define INS_XOR 0x13
+#define INS_LSHIFT 0x14
+#define INS_RSHIFT 0x15
+#define INS_ADD 0x16
+#define INS_SUB 0x17
+#define INS_MUL 0x18
+#define INS_DIV 0x19
+#define INS_MOD 0x1a
+#define INS_RANDOM 0x1b
+
+#define INS_SJR 0x20
+#define INS_MJR 0x21
+#define INS_JMP 0x22
+#define INS_CALL 0x23
+#define INS_JEQ 0x24
+#define INS_JNE 0x25
+#define INS_JGT 0x26
+#define INS_JLT 0x27
+
+static char* instruction_names[256] = {
+    /* 0x00 */ "NOOP", "ID  ", "TAG ", "MOVE", "SENS", "PROB", "PICK", "CARY", "DROP", "SMEL", "SNIF", "MARK", "?", "?", "?", "?",
+    /* 0x10 */ "SET ", "AND ", "OR  ", "XOR ", "SHL ", "SHR ", "ADD ", "SUB ", "MUL ", "DIV ", "MOD", "RAND", "?", "?", "?", "?",
+    /* 0x20 */ "SJR ", "MJR ", "JMP ", "CALL", "JEQ", "JNE ", "JGT ", "JLT ", "?", "?", "?", "?", "?", "?", "?", "?",
+    /* 0x30 */ "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?",
+    /* 0x40 */ "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?",
+    /* 0x50 */ "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?",
+    /* 0x60 */ "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?",
+    /* 0x70 */ "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?",
+    /* 0x80 */ "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?",
+    /* 0x90 */ "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?",
+    /* 0xa0 */ "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?",
+    /* 0xb0 */ "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?",
+    /* 0xc0 */ "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?",
+    /* 0xd0 */ "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?",
+    /* 0xe0 */ "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?",
+    /* 0xf0 */ "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?",
+};
+
+struct Instruction {
+    unsigned char op;
+    unsigned char arg1;
+    unsigned char arg2;
+    unsigned char arg3;
+};
+
+struct Program {
+    unsigned int num_instructions;
+    struct Instruction instructions;
+};
+
+struct Program* load_program(char* filename);
diff --git a/generate_maps.sh b/generate_maps.sh
new file mode 100755
index 0000000..e277b07
--- /dev/null
+++ b/generate_maps.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+echo "Building image..."
+pushd maps
+docker build -qt ants-maps .
+popd
+echo "Generating maps..."
+docker run --rm -ti -v $PWD/data:/maps ants-maps generate -n 120 -t open -o /maps/open.maps
+docker run --rm -ti -v $PWD/data:/maps ants-maps generate -n 120 -t random -o /maps/random.maps
+echo "DONE"
diff --git a/maps/Dockerfile b/maps/Dockerfile
new file mode 100644
index 0000000..1b93198
--- /dev/null
+++ b/maps/Dockerfile
@@ -0,0 +1,7 @@
+FROM node
+WORKDIR /app
+ADD package.json* .
+RUN npm install
+ADD *.js /app
+VOLUME /maps
+ENTRYPOINT ["./maps.js"]
diff --git a/maps/maps.js b/maps/maps.js
new file mode 100755
index 0000000..aa76bcc
--- /dev/null
+++ b/maps/maps.js
@@ -0,0 +1,1065 @@
+#!/usr/bin/env nodejs
+const fs = require("fs");
+
+let CellType = {
+    EMPTY: 0,
+    WALL: 1,
+    FOOD: 2,
+    NEST: 3,
+};
+class C {
+    state;
+    constructor(e) {
+        ((this.state = 0 | e), 0 === this.state && (this.state = 1));
+    }
+    next() {
+        let e = 0 | (this.state += 0x9e3779b9);
+        return (
+            (((e = Math.imul(
+                (e = Math.imul(e ^ (e >>> 16), 0x85ebca6b)) ^ (e >>> 13),
+                0xc2b2ae35,
+            )) ^
+                (e >>> 16)) >>>
+                0) /
+            0x100000000
+        );
+    }
+    nextInt(e) {
+        return (this.next() * e) | 0;
+    }
+    nextIntRange(e, t) {
+        return e + this.nextInt(t - e);
+    }
+    shuffle(e) {
+        for (let t = e.length - 1; t > 0; t--) {
+            let r = this.nextInt(t + 1);
+            [e[t], e[r]] = [e[r], e[t]];
+        }
+        return e;
+    }
+}
+
+function P(e, t, r, l) {
+    let a = e * t;
+    return {
+        width: e,
+        height: t,
+        cells: new Uint8Array(a),
+        food: new Uint16Array(a),
+        pheromones: new Uint16Array(a * 4),
+        visitCounts: new Uint32Array(a),
+        nestX: Math.floor(e / 2),
+        nestY: Math.floor(t / 2),
+        totalFood: 0,
+        seed: r,
+        name: l,
+    };
+}
+
+function H(e) {
+    for (let t = 0; t < e.width; t++)
+        (_(e, t, 0, CellType.WALL), _(e, t, e.height - 1, CellType.WALL));
+    for (let t = 0; t < e.height; t++)
+        (_(e, 0, t, CellType.WALL), _(e, e.width - 1, t, CellType.WALL));
+}
+
+let V = {
+    open: function (e, t, r) {
+        let n = P(e, t, r, `open-${r}`),
+            l = new C(r),
+            a = e / 128;
+        (H(n), J(n, l), $(n));
+        let s = 5 + l.nextInt(4);
+        for (let r = 0; r < s; r++) {
+            let r = 4 + l.nextInt(e - 8),
+                s = 4 + l.nextInt(t - 8);
+            if (W(r, s, n.nestX, n.nestY) < 15 * a) continue;
+            let o = 3 + l.nextInt(3),
+                i = 2 + l.nextInt(3);
+            for (let e = -o; e <= o; e++)
+                for (let t = -o; t <= o; t++) {
+                    if (t * t + e * e > o * o) continue;
+                    let l = r + t,
+                        a = s + e;
+                    G(n, l, a) && F(n, l, a, i);
+                }
+        }
+        return n;
+    },
+    maze: function (e, t, r) {
+        let l = P(e, t, r, `maze-${r}`),
+            a = new C(r),
+            s = e / 128;
+        H(l);
+        for (let r = 1; r < t - 1; r++)
+            for (let t = 1; t < e - 1; t++) _(l, t, r, CellType.WALL);
+        let o = Math.floor((e - 2) / 4),
+            i = Math.floor((t - 2) / 4),
+            c = new Uint8Array(o * i),
+            d = [];
+        function u(e, t) {
+            return [1 + 4 * e + 1, 1 + 4 * t + 1];
+        }
+        function h(r, a) {
+            let [s, i] = u(r, a);
+            for (let r = 0; r < 2; r++)
+                for (let a = 0; a < 2; a++)
+                    s + a < e - 1 &&
+                        i + r < t - 1 &&
+                        _(l, s + a, i + r, CellType.EMPTY);
+            c[a * o + r] = 1;
+        }
+        function p(r, a, s, o) {
+            let [i, c] = u(r, a),
+                [d, h] = u(s, o),
+                p = Math.min(i, d),
+                f = Math.min(c, h),
+                m = Math.max(i, d) + 1,
+                x = Math.max(c, h) + 1;
+            for (let r = f; r <= x; r++)
+                for (let a = p; a <= m; a++)
+                    a > 0 &&
+                        a < e - 1 &&
+                        r > 0 &&
+                        r < t - 1 &&
+                        _(l, a, r, CellType.EMPTY);
+        }
+        let f = Math.floor(o / 2),
+            m = Math.floor(i / 2);
+        (h(f, m), d.push(f, m));
+        let x = [
+            [0, -1],
+            [1, 0],
+            [0, 1],
+            [-1, 0],
+        ];
+        for (; d.length > 0; ) {
+            let e = d[d.length - 1],
+                t = d[d.length - 2],
+                r = [];
+            for (let n = 0; n < 4; n++) {
+                let l = t + x[n][0],
+                    a = e + x[n][1];
+                l >= 0 &&
+                    l < o &&
+                    a >= 0 &&
+                    a < i &&
+                    !c[a * o + l] &&
+                    r.push(n);
+            }
+            if (0 === r.length) {
+                d.length -= 2;
+                continue;
+            }
+            let n = r[a.nextInt(r.length)],
+                l = t + x[n][0],
+                s = e + x[n][1];
+            (p(t, e, l, s), h(l, s), d.push(l, s));
+        }
+        for (let e = 0; e < i; e++)
+            for (let t = 0; t < o; t++)
+                if (c[e * o + t])
+                    for (let [r, n] of [
+                        [1, 0],
+                        [0, 1],
+                    ]) {
+                        let l = t + r,
+                            s = e + n;
+                        !(l >= o) &&
+                            !(s >= i) &&
+                            c[s * o + l] &&
+                            0.25 > a.next() &&
+                            p(t, e, l, s);
+                    }
+        for (let r = 0; r < 100; r++) {
+            let r = 4 + a.nextInt(e - 8),
+                s = 4 + a.nextInt(t - 8);
+            if (l.cells[U(l, r, s)] === CellType.EMPTY) {
+                ((l.nestX = r), (l.nestY = s));
+                break;
+            }
+        }
+        $(l);
+        let g = 16 + a.nextInt(7);
+        for (let r = 0; r < g; r++)
+            for (let r = 0; r < 50; r++) {
+                let r = 2 + a.nextInt(e - 4),
+                    o = 2 + a.nextInt(t - 4);
+                if (
+                    l.cells[U(l, r, o)] === CellType.EMPTY &&
+                    W(r, o, l.nestX, l.nestY) > 12 * s
+                ) {
+                    let e = 1 + a.nextInt(3),
+                        t = 3 + a.nextInt(6);
+                    for (let a = -e; a <= e; a++)
+                        for (let s = -e; s <= e; s++)
+                            !(s * s + a * a > e * e) &&
+                                G(l, r + s, o + a) &&
+                                l.cells[U(l, r + s, o + a)] ===
+                                    CellType.EMPTY &&
+                                F(l, r + s, o + a, t);
+                    break;
+                }
+            }
+        return (Y(l), l);
+    },
+    spiral: function (e, t, r) {
+        let l = P(e, t, r, `spiral-${r}`),
+            a = new C(r);
+        (H(l), $(l));
+        let s = e / 2,
+            o = t / 2,
+            i = Math.min(e, t) / 2 - 2,
+            c = Math.max(5, Math.floor(0.06 * e));
+        for (let e = c + 2; e < i; e += c) {
+            let t = a.next() * Math.PI * 2,
+                r = 0.6 + 0.4 * a.next(),
+                i = 2 + a.nextInt(3),
+                c = 1 + 1.5 * a.next(),
+                d = a.next() * Math.PI * 2;
+            for (let a = 0; a < 2 * Math.PI; a += 0.02) {
+                let u = Math.abs(
+                    ((a - t + 3 * Math.PI) % (2 * Math.PI)) - Math.PI,
+                );
+                if (u < r) continue;
+                let h =
+                        e +
+                        c * Math.min(1, (u - r) / 0.5) * Math.sin(a * i + d),
+                    p = Math.floor(s + Math.cos(a) * h),
+                    f = Math.floor(o + Math.sin(a) * h);
+                G(l, p, f) && _(l, p, f, CellType.WALL);
+            }
+        }
+        for (let e = c; e < i; e += c) {
+            let t = e + c / 2,
+                r = 3 + a.nextInt(3);
+            for (let e = 0; e < r; e++) {
+                let e = a.next() * Math.PI * 2,
+                    r = t + (a.next() - 0.5) * (0.3 * c),
+                    n = Math.floor(s + Math.cos(e) * r),
+                    i = Math.floor(o + Math.sin(e) * r),
+                    d = 1 + a.nextInt(2),
+                    u = 3 + a.nextInt(3);
+                for (let e = -d; e <= d; e++)
+                    for (let t = -d; t <= d; t++) {
+                        if (t * t + e * e > d * d) continue;
+                        let r = n + t,
+                            a = i + e;
+                        G(l, r, a) && F(l, r, a, u);
+                    }
+            }
+        }
+        return (Y(l), l);
+    },
+    field: function (e, t, r) {
+        let l = P(e, t, r, `field-${r}`),
+            a = new C(r),
+            s = e / 128;
+        (H(l),
+            J(l, a),
+            $(l),
+            (function (e, t, r, l) {
+                for (let a = 0; a < r; a++) {
+                    let r = 4 + t.nextInt(e.width - 8),
+                        a = 4 + t.nextInt(e.height - 8);
+                    if (8 > W(r, a, e.nestX, e.nestY)) continue;
+                    let s = l[0] + t.nextInt(l[1] - l[0]),
+                        o = t.next() * Math.PI * 2,
+                        i = 0,
+                        c = !1;
+                    for (
+                        let l = 0;
+                        l < s &&
+                        ((o += (t.next() - 0.5) * 1),
+                        G(
+                            e,
+                            (r += Math.round(Math.cos(o))),
+                            (a += Math.round(Math.sin(o))),
+                        ));
+                        l++
+                    )
+                        !(5 > W(r, a, e.nestX, e.nestY)) &&
+                            (i++,
+                            !c && i > 8 + t.nextInt(12)
+                                ? ((c = !0), (i = 0))
+                                : c &&
+                                  i > 2 + t.nextInt(3) &&
+                                  ((c = !1), (i = 0)),
+                            c || _(e, r, a, CellType.WALL));
+                }
+            })(l, a, 3 + a.nextInt(3), [70, 130]));
+        let o = 6 + a.nextInt(3);
+        for (let r = 0; r < o; r++) {
+            let r = 4 + a.nextInt(e - 8),
+                n = 4 + a.nextInt(t - 8);
+            if (W(r, n, l.nestX, l.nestY) < 12 * s) continue;
+            let o = 2 + a.nextInt(4),
+                i = 2 + a.nextInt(4);
+            for (let e = -o; e <= o; e++)
+                for (let t = -o; t <= o; t++) {
+                    if (t * t + e * e > o * o) continue;
+                    let a = r + t,
+                        s = n + e;
+                    G(l, a, s) && F(l, a, s, i);
+                }
+        }
+        return (Y(l), l);
+    },
+    bridge: function (e, t, r) {
+        let l = P(e, t, r, `bridge-${r}`),
+            a = new C(r);
+        H(l);
+        let s = Math.floor(e / 2),
+            o = Math.floor(0.1 * e),
+            i = new Int32Array(t),
+            c = s;
+        for (let r = 1; r < t - 1; r++) {
+            (0.3 > a.next() && (c += a.nextInt(3) - 1),
+                (c = Math.max(s - o, Math.min(s + o, c))),
+                (i[r] = c));
+            for (let t = -1; t <= 1; t++) {
+                let a = c + t;
+                a > 0 && a < e - 1 && _(l, a, r, CellType.WALL);
+            }
+        }
+        let d = 2 + a.nextInt(3),
+            u = Math.floor(t / (d + 1));
+        for (let r = 0; r < d; r++) {
+            let s = u * (r + 1),
+                o = 2 + a.nextInt(2);
+            for (let r = -o; r <= o; r++) {
+                let a = s + r;
+                if (a > 0 && a < t - 1)
+                    for (let t = -1; t <= 1; t++) {
+                        let r = i[a] + t;
+                        r > 0 && r < e - 1 && _(l, r, a, CellType.EMPTY);
+                    }
+            }
+        }
+        ((l.nestX = Math.floor(e / 4)), (l.nestY = Math.floor(t / 2)), $(l));
+        let h = 6 + a.nextInt(4);
+        for (let r = 0; r < h; r++) {
+            let r = s + 4 + a.nextInt(Math.floor(e / 2) - 6),
+                o = 4 + a.nextInt(t - 8),
+                i = 2 + a.nextInt(3),
+                c = 3 + a.nextInt(4);
+            for (let e = -i; e <= i; e++)
+                for (let t = -i; t <= i; t++) {
+                    if (t * t + e * e > i * i) continue;
+                    let a = r + t,
+                        s = o + e;
+                    G(l, a, s) &&
+                        l.cells[U(l, a, s)] !== CellType.WALL &&
+                        F(l, a, s, c);
+                }
+        }
+        return (B(l, a), l);
+    },
+    gauntlet: function (e, t, r) {
+        let l = P(e, t, r, `gauntlet-${r}`),
+            a = new C(r);
+        (H(l), (l.nestX = 5), (l.nestY = Math.floor(t / 2)), $(l));
+        let s = 3 + a.nextInt(2),
+            o = Math.floor((e - 20) / (s + 1));
+        for (let r = 0; r < s; r++) {
+            let s = 12 + o * (r + 1),
+                i =
+                    r % 2 == 0
+                        ? 4 + a.nextInt(Math.floor(t / 3))
+                        : Math.floor((2 * t) / 3) +
+                          a.nextInt(Math.floor(t / 3) - 4),
+                c = 4 + a.nextInt(4);
+            for (let r = 1; r < t - 1; r++)
+                !(Math.abs(r - i) < c) &&
+                    s > 0 &&
+                    s < e - 1 &&
+                    _(l, s, r, CellType.WALL);
+        }
+        for (let r = 1; r <= s; r++) {
+            let n = 12 + r * o + 4,
+                i = r < s ? 12 + (r + 1) * o - 4 : e - 6;
+            if (i <= n) continue;
+            let c = (r - 1) / Math.max(1, s - 1),
+                d = 2 + a.nextInt(2) + Math.round(2 * c),
+                u = 1 + Math.round(2 * c),
+                h = 2 + a.nextInt(2) + Math.round(3 * c);
+            for (let e = 0; e < d; e++) {
+                let e = n + a.nextInt(Math.max(1, i - n)),
+                    r = 4 + a.nextInt(t - 8);
+                for (let t = -u; t <= u; t++)
+                    for (let n = -u; n <= u; n++) {
+                        if (n * n + t * t > u * u) continue;
+                        let a = e + n,
+                            s = r + t;
+                        G(l, a, s) && F(l, a, s, h);
+                    }
+            }
+        }
+        return (B(l, a), l);
+    },
+    pockets: function (e, t, r) {
+        let l = P(e, t, r, `pockets-${r}`),
+            a = new C(r);
+        (H(l), J(l, a), $(l));
+        let s = [],
+            o = 7 + a.nextInt(4);
+        for (let r = 0; r < 300 && s.length < o; r++) {
+            let r = 7 + a.nextInt(6),
+                o = r + 4 + a.nextInt(e - 2 * r - 8),
+                i = r + 4 + a.nextInt(t - 2 * r - 8);
+            if (W(o, i, l.nestX, l.nestY) < r + 8) continue;
+            let c = !1;
+            for (let e of s)
+                if (W(o, i, e.cx, e.cy) < r + e.r + 5) {
+                    c = !0;
+                    break;
+                }
+            if (c) continue;
+            s.push({ cx: o, cy: i, r });
+            let d = a.next() * Math.PI * 2,
+                u = 0.2 + 0.1 * a.next();
+            for (let e = 0; e < 2 * Math.PI; e += 0.025) {
+                if (
+                    Math.abs(
+                        ((e - d + 3 * Math.PI) % (2 * Math.PI)) - Math.PI,
+                    ) < u
+                )
+                    continue;
+                let t = Math.round(o + Math.cos(e) * r),
+                    a = Math.round(i + Math.sin(e) * r);
+                G(l, t, a) && _(l, t, a, CellType.WALL);
+            }
+            let h = 3 + a.nextInt(2),
+                p = 2 + a.nextInt(3);
+            for (let e = -h; e <= h; e++)
+                for (let t = -h; t <= h; t++) {
+                    if (t * t + e * e > h * h) continue;
+                    let r = o + t,
+                        a = i + e;
+                    G(l, r, a) &&
+                        l.cells[U(l, r, a)] === CellType.EMPTY &&
+                        F(l, r, a, p);
+                }
+        }
+        return (Y(l), l);
+    },
+    fortress: function (e, t, r) {
+        let l = P(e, t, r, `fortress-${r}`),
+            a = new C(r);
+        H(l);
+        let s = Math.floor(e / 2),
+            o = Math.floor(t / 2),
+            i = 3 + a.nextInt(2),
+            c = Math.max(4, Math.floor(Math.min(e, t) / (2 * i + 4)));
+        ((l.nestX = 4), (l.nestY = 4), $(l));
+        for (let e = 1; e <= i; e++) {
+            let t = e * c,
+                r = a.next() * Math.PI * 2,
+                i = 0.35 + 0.2 * a.next(),
+                d = 3 + a.nextInt(3),
+                u = 1.5 + 2 * a.next(),
+                h = a.next() * Math.PI * 2;
+            for (let e = 0; e < 2 * Math.PI; e += 0.015) {
+                if (
+                    Math.abs(
+                        ((e - r + 3 * Math.PI) % (2 * Math.PI)) - Math.PI,
+                    ) < i
+                )
+                    continue;
+                let a = t + Math.sin(e * d + h) * u,
+                    c = Math.floor(s + Math.cos(e) * a),
+                    p = Math.floor(o + Math.sin(e) * a);
+                G(l, c, p) && _(l, c, p, CellType.WALL);
+            }
+        }
+        let d = c - 2;
+        for (let e = -d; e <= d; e++)
+            for (let t = -d; t <= d; t++) {
+                if (t * t + e * e > d * d) continue;
+                let r = s + t,
+                    n = o + e;
+                G(l, r, n) && F(l, r, n, 3 + a.nextInt(3));
+            }
+        for (let r = 1; r < i; r++) {
+            let i = r * c + Math.floor(c / 2),
+                d = 4 + a.nextInt(4);
+            for (let r = 0; r < d; r++) {
+                let r = a.next() * Math.PI * 2,
+                    c = Math.floor(s + Math.cos(r) * i),
+                    d = Math.floor(o + Math.sin(r) * i);
+                c > 1 &&
+                    c < e - 2 &&
+                    d > 1 &&
+                    d < t - 2 &&
+                    l.cells[U(l, c, d)] === CellType.EMPTY &&
+                    F(l, c, d, 2 + a.nextInt(4));
+            }
+        }
+        return (Y(l), l);
+    },
+    islands: function (e, t, r) {
+        let l = P(e, t, r, `islands-${r}`),
+            a = new C(r);
+        for (let r = 0; r < t; r++)
+            for (let t = 0; t < e; t++) _(l, t, r, CellType.WALL);
+        let s = Math.floor((e - 2) / 4),
+            o = Math.floor((t - 2) / 4),
+            i = [];
+        for (let e = 0; e < 4; e++)
+            for (let t = 0; t < 4; t++) {
+                let r = 1 + t * s + 2,
+                    a = 1 + e * o + 2,
+                    c = 1 + (t + 1) * s - 2,
+                    d = 1 + (e + 1) * o - 2,
+                    u = Math.floor((r + c) / 2),
+                    h = Math.floor((a + d) / 2);
+                i.push({ cx: u, cy: h, ri: e, ci: t });
+                for (let e = a; e <= d; e++)
+                    for (let t = r; t <= c; t++)
+                        G(l, t, e) && _(l, t, e, CellType.EMPTY);
+            }
+        let c = i.map(() => []),
+            d = 2 + a.nextInt(2);
+        for (let e = 0; e < 4; e++)
+            for (let t = 0; t < 4; t++) {
+                let r = 4 * e + t;
+                if (t < 3) {
+                    let i = 1 + (t + 1) * s,
+                        u = 1 + e * o + 2 + a.nextInt(Math.max(1, o - 4 - d)),
+                        h = u + Math.floor(d / 2);
+                    (c[r].push({ x: i, y: h }), c[r + 1].push({ x: i, y: h }));
+                    for (let e = 0; e < d; e++)
+                        for (let t = -2; t <= 2; t++)
+                            G(l, i + t, u + e) &&
+                                _(l, i + t, u + e, CellType.EMPTY);
+                }
+                if (e < 3) {
+                    let i = 1 + (e + 1) * o,
+                        u = 1 + t * s + 2 + a.nextInt(Math.max(1, s - 4 - d)),
+                        h = u + Math.floor(d / 2);
+                    (c[r].push({ x: h, y: i }), c[r + 4].push({ x: h, y: i }));
+                    for (let e = 0; e < d; e++)
+                        for (let t = -2; t <= 2; t++)
+                            G(l, u + e, i + t) &&
+                                _(l, u + e, i + t, CellType.EMPTY);
+                }
+            }
+        let u = i[a.nextInt(i.length)];
+        ((l.nestX = u.cx), (l.nestY = u.cy), $(l));
+        let h = s - 4,
+            p = o - 4,
+            f = ["empty", "blob", "walls", "diffuse", "corners"],
+            m = [],
+            x = d + 5;
+        for (let e = 0; e < i.length; e++) {
+            let t = i[e];
+            if (t === u) continue;
+            0 === m.length && (m.push(...f), a.shuffle(m));
+            let r = m.pop(),
+                n = t.cx - Math.floor(h / 2),
+                s = t.cy - Math.floor(p / 2),
+                o = c[e];
+            if ("empty" !== r) {
+                if ("blob" === r) {
+                    let e = Math.max(1, Math.floor(Math.min(h, p) / 8)),
+                        r = t.cx + a.nextInt(5) - 2,
+                        n = t.cy + a.nextInt(5) - 2,
+                        s = 1 + a.nextInt(2);
+                    for (let t = -e; t <= e; t++)
+                        for (let a = -e; a <= e; a++)
+                            !(a * a + t * t > e * e) &&
+                                G(l, r + a, n + t) &&
+                                F(l, r + a, n + t, s);
+                } else if ("walls" === r) {
+                    let e = n + h - 1,
+                        t = s + p - 1,
+                        r = (e, t) =>
+                            o.some(
+                                (r) =>
+                                    Math.abs(e - r.x) + Math.abs(t - r.y) < x,
+                            );
+                    for (let o = n; o <= e; o++)
+                        (0.5 > a.next() &&
+                            G(l, o, s) &&
+                            !r(o, s) &&
+                            F(l, o, s, 1),
+                            0.5 > a.next() &&
+                                G(l, o, t) &&
+                                !r(o, t) &&
+                                F(l, o, t, 1));
+                    for (let o = s + 1; o < t; o++)
+                        (0.5 > a.next() &&
+                            G(l, n, o) &&
+                            !r(n, o) &&
+                            F(l, n, o, 1),
+                            0.5 > a.next() &&
+                                G(l, e, o) &&
+                                !r(e, o) &&
+                                F(l, e, o, 1));
+                } else if ("diffuse" === r)
+                    for (let e = s; e < s + p; e++)
+                        for (let t = n; t < n + h; t++)
+                            0.12 > a.next() && G(l, t, e) && F(l, t, e, 1);
+                else if ("corners" === r) {
+                    let e = Math.max(1, Math.floor(Math.min(h, p) / 7));
+                    for (let [t, r] of [
+                        [n + e + 1, s + e + 1],
+                        [n + h - e - 2, s + e + 1],
+                        [n + e + 1, s + p - e - 2],
+                        [n + h - e - 2, s + p - e - 2],
+                    ]) {
+                        if (0.3 > a.next()) continue;
+                        let n = 1 + a.nextInt(3);
+                        for (let a = -e; a <= e; a++)
+                            for (let s = -e; s <= e; s++)
+                                !(s * s + a * a > e * e) &&
+                                    G(l, t + s, r + a) &&
+                                    F(l, t + s, r + a, n);
+                    }
+                }
+            }
+        }
+        return l;
+    },
+    chambers: function (e, t, r) {
+        let l = P(e, t, r, `chambers-${r}`),
+            a = new C(r);
+        for (let r = 0; r < t; r++)
+            for (let t = 0; t < e; t++) _(l, t, r, CellType.WALL);
+        let s = [],
+            o = 11 + a.nextInt(3);
+        for (let r = 0; r < o; r++) {
+            let r = 4 + a.nextInt(4),
+                o = 4 + a.nextInt(4),
+                i = r + 2 + a.nextInt(Math.max(1, e - 2 * r - 4)),
+                c = o + 2 + a.nextInt(Math.max(1, t - 2 * o - 4)),
+                d = !1;
+            for (let e of s)
+                if (
+                    Math.abs(i - e.cx) < r + e.hw + 2 &&
+                    Math.abs(c - e.cy) < o + e.hh + 2
+                ) {
+                    d = !0;
+                    break;
+                }
+            if (!d) {
+                s.push({ cx: i, cy: c, hw: r, hh: o });
+                for (let e = c - o; e <= c + o; e++)
+                    for (let t = i - r; t <= i + r; t++)
+                        G(l, t, e) && _(l, t, e, CellType.EMPTY);
+            }
+        }
+        for (let e = 1; e < s.length; e++) {
+            let t = s[e - 1],
+                r = s[e],
+                a = t.cx,
+                o = t.cy;
+            for (; a !== r.cx; ) {
+                for (let e = -1; e <= 1; e++)
+                    G(l, a, o + e) && _(l, a, o + e, CellType.EMPTY);
+                a += a < r.cx ? 1 : -1;
+            }
+            for (; o !== r.cy; ) {
+                for (let e = -1; e <= 1; e++)
+                    G(l, a + e, o) && _(l, a + e, o, CellType.EMPTY);
+                o += o < r.cy ? 1 : -1;
+            }
+        }
+        {
+            let e = s[s.length - 1],
+                t = s[0],
+                r = e.cx,
+                a = e.cy;
+            for (; r !== t.cx; ) {
+                for (let e = -1; e <= 1; e++)
+                    G(l, r, a + e) && _(l, r, a + e, CellType.EMPTY);
+                r += r < t.cx ? 1 : -1;
+            }
+            for (; a !== t.cy; ) {
+                for (let e = -1; e <= 1; e++)
+                    G(l, r + e, a) && _(l, r + e, a, CellType.EMPTY);
+                a += a < t.cy ? 1 : -1;
+            }
+        }
+        let i = s.reduce(
+            (r, n) => {
+                let l = W(n.cx, n.cy, e / 2, t / 2);
+                return l < r.d ? { c: n, d: l } : r;
+            },
+            { c: s[0], d: 1 / 0 },
+        );
+        for (let e of ((l.nestX = i.c.cx), (l.nestY = i.c.cy), $(l), s)) {
+            if (e === i.c) continue;
+            let t = Math.min(Math.min(e.hw, e.hh) - 1, 3);
+            if (t < 1) continue;
+            let r = 3 + a.nextInt(3);
+            for (let n = -t; n <= t; n++)
+                for (let a = -t; a <= t; a++) {
+                    if (a * a + n * n > t * t) continue;
+                    let s = e.cx + a,
+                        o = e.cy + n;
+                    G(l, s, o) && F(l, s, o, r);
+                }
+        }
+        return l;
+    },
+    prairie: function (e, t, r) {
+        let n = P(e, t, r, `prairie-${r}`),
+            l = new C(r);
+        (H(n), J(n, l), $(n));
+        let a = 6 + l.nextInt(4),
+            s = [];
+        for (let r = 0; r < a; r++)
+            s.push({
+                x: 4 + l.nextInt(e - 8),
+                y: 4 + l.nextInt(t - 8),
+                strength: 0.25 + 0.3 * l.next(),
+                radius: 6 + l.nextInt(10),
+            });
+        for (let r = 2; r < t - 2; r++)
+            for (let t = 2; t < e - 2; t++) {
+                if (5 > W(t, r, n.nestX, n.nestY)) continue;
+                let e = 0.016;
+                for (let n of s) {
+                    let l = W(t, r, n.x, n.y);
+                    l < n.radius && (e += n.strength * (1 - l / n.radius));
+                }
+                ((e = Math.min(e, 0.25)),
+                    l.next() < e &&
+                        F(
+                            n,
+                            t,
+                            r,
+                            e > 0.12 ? 1 + l.nextInt(3) : 1 + l.nextInt(2),
+                        ));
+            }
+        return n;
+    },
+    brush: function (e, t, r) {
+        let l = P(e, t, r, `brush-${r}`),
+            a = new C(r),
+            s = e / 128;
+        (H(l), J(l, a), $(l));
+        for (let r = 2; r < t - 2; r++)
+            for (let t = 2; t < e - 2; t++)
+                !(5 > W(t, r, l.nestX, l.nestY)) &&
+                    0.28 > a.next() &&
+                    _(l, t, r, CellType.WALL);
+        for (let e = -3; e <= 3; e++)
+            for (let t = -3; t <= 3; t++) {
+                let r = l.nestX + t,
+                    a = l.nestY + e;
+                G(l, r, a) &&
+                    l.cells[U(l, r, a)] === CellType.WALL &&
+                    _(l, r, a, CellType.EMPTY);
+            }
+        let o = 10 + a.nextInt(3);
+        for (let r = 0; r < o; r++)
+            for (let r = 0; r < 80; r++) {
+                let r = 4 + a.nextInt(e - 8),
+                    o = 4 + a.nextInt(t - 8);
+                if (
+                    W(r, o, l.nestX, l.nestY) < 10 * s ||
+                    l.cells[U(l, r, o)] !== CellType.EMPTY
+                )
+                    continue;
+                let i = 2 + a.nextInt(3),
+                    c = 3 + a.nextInt(3);
+                for (let e = -i; e <= i; e++)
+                    for (let t = -i; t <= i; t++) {
+                        if (t * t + e * e > i * i) continue;
+                        let n = r + t,
+                            a = o + e;
+                        G(l, n, a) && F(l, n, a, c);
+                    }
+                break;
+            }
+        return (Y(l), l);
+    },
+};
+
+function Y(e) {
+    let t = new Uint8Array(e.width * e.height),
+        r = [e.nestX, e.nestY];
+    t[e.nestY * e.width + e.nestX] = 1;
+    let l = 0;
+    for (; l < r.length; ) {
+        let a = r[l++],
+            s = r[l++];
+        for (let [l, o] of [
+            [0, -1],
+            [1, 0],
+            [0, 1],
+            [-1, 0],
+        ]) {
+            let i = a + l,
+                c = s + o;
+            if (i < 0 || i >= e.width || c < 0 || c >= e.height) continue;
+            let d = c * e.width + i;
+            t[d] || e.cells[d] === CellType.WALL || ((t[d] = 1), r.push(i, c));
+        }
+    }
+    for (let r = 0; r < e.width * e.height; r++)
+        if (e.cells[r] === CellType.FOOD && !t[r]) {
+            let l = Math.floor(r / e.width),
+                a = r % e.width,
+                s = new Uint8Array(e.width * e.height),
+                o = new Int32Array(e.width * e.height).fill(-1),
+                i = [a, l];
+            s[r] = 1;
+            let c = -1,
+                d = 0;
+            for (; d < i.length && c < 0; ) {
+                let r = i[d++],
+                    n = i[d++];
+                for (let [l, a] of [
+                    [0, -1],
+                    [1, 0],
+                    [0, 1],
+                    [-1, 0],
+                ]) {
+                    let d = r + l,
+                        u = n + a;
+                    if (d < 1 || d >= e.width - 1 || u < 1 || u >= e.height - 1)
+                        continue;
+                    let h = u * e.width + d;
+                    if (!s[h]) {
+                        if (((s[h] = 1), (o[h] = n * e.width + r), t[h])) {
+                            c = h;
+                            break;
+                        }
+                        i.push(d, u);
+                    }
+                }
+            }
+            if (c >= 0) {
+                let r = c;
+                for (; r >= 0; )
+                    (e.cells[r] === CellType.WALL &&
+                        (e.cells[r] = CellType.EMPTY),
+                        (t[r] = 1),
+                        (r = o[r]));
+            }
+        }
+}
+function W(e, t, r, n) {
+    return Math.sqrt((e - r) ** 2 + (t - n) ** 2);
+}
+function G(e, t, r) {
+    return t > 0 && t < e.width - 1 && r > 0 && r < e.height - 1;
+}
+function J(e, t, r) {
+    let n = r ?? Math.floor(0.15 * Math.min(e.width, e.height));
+    ((e.nestX = n + t.nextInt(e.width - 2 * n)),
+        (e.nestY = n + t.nextInt(e.height - 2 * n)));
+}
+function $(e) {
+    let t = e.nestX,
+        r = e.nestY;
+    for (let l = -1; l <= 1; l++)
+        for (let a = -1; a <= 1; a++) {
+            let s = t + a,
+                o = r + l;
+            s >= 0 &&
+                s < e.width &&
+                o >= 0 &&
+                o < e.height &&
+                _(e, s, o, CellType.NEST);
+        }
+}
+
+function U(e, t, r) {
+    return r * e.width + t;
+}
+
+function _(e, t, r, n) {
+    e.cells[U(e, t, r)] = n;
+}
+
+function X(e, t, r) {
+    return e.cells[U(e, t, r)];
+}
+
+function G(e, t, r) {
+    return t > 0 && t < e.width - 1 && r > 0 && r < e.height - 1;
+}
+
+function F(e, t, r, l) {
+    let a = U(e, t, r);
+    e.cells[a] === CellType.EMPTY &&
+        ((e.cells[a] = CellType.FOOD), (e.food[a] = l), (e.totalFood += l));
+}
+
+function B(e, t) {
+    if (e.width !== e.height) return;
+    let r = e.width,
+        n = 1 === t.nextInt(2),
+        l = 1 === t.nextInt(2),
+        a = 1 === t.nextInt(2);
+    if (!n && !l && !a) return;
+    let s = new Uint8Array(r * r),
+        o = new Uint16Array(r * r);
+    for (let t = 0; t < r; t++)
+        for (let i = 0; i < r; i++) {
+            let c = n ? r - 1 - i : i,
+                d = l ? r - 1 - t : t;
+            if (a) {
+                let e = c;
+                ((c = d), (d = e));
+            }
+            ((s[d * r + c] = e.cells[t * r + i]),
+                (o[d * r + c] = e.food[t * r + i]));
+        }
+    (e.cells.set(s), e.food.set(o));
+    let i = n ? r - 1 - e.nestX : e.nestX,
+        c = l ? r - 1 - e.nestY : e.nestY;
+    if (a) {
+        let e = i;
+        ((i = c), (c = e));
+    }
+    ((e.nestX = i), (e.nestY = c));
+}
+
+function renderMapASCII(map) {
+    const symbols = {
+        0: " ", // EMPTY
+        1: "#", // WALL
+        2: "o", // FOOD
+        3: "S", // NEST
+    };
+
+    let output = "";
+
+    for (let y = 0; y < map.height; y++) {
+        let row = "";
+
+        for (let x = 0; x < map.width; x++) {
+            const cell = X(map, x, y);
+
+            if (symbols[cell] !== undefined) {
+                row += symbols[cell];
+            }
+        }
+
+        output += row + "\n";
+    }
+
+    console.log(output);
+}
+
+function randomize_r(r, n) {
+    return (
+        0xfffffff &
+            Math.imul(
+                (l =
+                    Math.imul(0x45d9f3b ^ r, 0x9e3779b9) ^
+                    Math.imul(n + 1, 0x6c62272e)) ^
+                    (l >>> 16),
+                0x85ebca6b,
+            ) || 1
+    );
+}
+function generate_random_maps(e, t, r, n) {
+    let l = [];
+    for (let a = 0; a < n; a++)
+        l.push(
+            (function (e, t, r, n) {
+                let l,
+                    a = new C(0x5a5a5a5a ^ r),
+                    s = Object.entries(V);
+                a.shuffle(s);
+                let [o, i] = s[n % s.length],
+                    c = randomize_r(r, n);
+                d = i(e, t, c);
+                return ((d.name = `${o}-${c.toString(36)}`), d);
+            })(e, t, r, a),
+        );
+    return l;
+}
+
+function generate_maps(e, t, r, n, typ) {
+    let l = [];
+    for (let a = 0; a < n; a++)
+        l.push(
+            (function (e, t, r, n) {
+                let a = new C(0x5a5a5a5a ^ r);
+                let i = V[typ];
+                let c = randomize_r(r, n);
+                d = i(e, t, c);
+                return ((d.name = `${typ}-${c.toString(36)}`), d);
+            })(e, t, r, a),
+        );
+    return l;
+}
+
+function map_from_name(name) {
+    let parts = name.split("-");
+    let generator = parts[0];
+    let code = parts[1];
+    let c = Number.parseInt(code, 36);
+    return V[generator](WIDTH, HEIGHT, c);
+}
+
+const WIDTH = 128;
+const HEIGHT = 128;
+r = 42;
+n = 120;
+
+const { program } = require("commander");
+
+program.name("maps").description("Generate and view maps").version("1.0.0");
+
+program.command("view <name>").action((name, options) => {
+    console.log(`Viewing ${name}`);
+    let map = map_from_name(name);
+    renderMapASCII(map);
+});
+
+program
+    .command("generate")
+    .option("-s, --seed <seed>", "Define seed", Number, 42)
+    .option("-n, --number <number>", "Amount of maps", Number, 120)
+    .option("-o, --output <output>", "Output file", "generated.maps")
+    .option("-t, --type <type>", "Map type", "random")
+    .action((options) => {
+        let maps = null;
+        if (options.type == "random") {
+            maps = generate_random_maps(
+                WIDTH,
+                HEIGHT,
+                options.seed,
+                options.number,
+            );
+        } else {
+            maps = generate_maps(
+                WIDTH,
+                HEIGHT,
+                options.seed,
+                options.number,
+                options.type,
+            );
+        }
+        const ws = fs.createWriteStream(options.output);
+        let header = Buffer.alloc(4);
+        header.writeInt32LE(maps.length);
+        ws.write(header);
+        const MAX_NAME_LENGTH = 31;
+        for (var i = 0; i < maps.length; i++) {
+            let header = Buffer.alloc(MAX_NAME_LENGTH + 3);
+            let name = maps[i].name;
+            let cells = Buffer.from(maps[i].cells);
+            let nest_cell = maps[i].nestY * WIDTH + maps[i].nestX;
+
+            header.fill(0);
+            header.write(name, 0, MAX_NAME_LENGTH);
+            header.writeInt16LE(nest_cell, MAX_NAME_LENGTH + 1);
+            ws.write(header);
+            ws.write(cells);
+        }
+        ws.end();
+    });
+
+program.parse();
+
+//let map = map_from_name("gauntlet-41jczs");
+//renderMapASCII(map);
diff --git a/maps/package-lock.json b/maps/package-lock.json
new file mode 100644
index 0000000..9e75a5b
--- /dev/null
+++ b/maps/package-lock.json
@@ -0,0 +1,20 @@
+{
+  "name": "ants",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "commander": "^14.0.3"
+      }
+    },
+    "node_modules/commander": {
+      "version": "14.0.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.3.tgz",
+      "integrity": "sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw==",
+      "engines": {
+        "node": ">=20"
+      }
+    }
+  }
+}
diff --git a/maps/package.json b/maps/package.json
new file mode 100644
index 0000000..48d1ba0
--- /dev/null
+++ b/maps/package.json
@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "commander": "^14.0.3"
+  }
+}
diff --git a/readme.md b/readme.md
new file mode 100644
index 0000000..f426889
--- /dev/null
+++ b/readme.md
@@ -0,0 +1,63 @@
+# SWARM challenge
+
+## The plan:
+
+* Reproduce the maps on the website
+* Create an assembler to generate bytecode. Add special instructions to define tweakable params and optional code blocks?
+* Create an antfarm: a high-performance program that can score ant programs inside those maps
+* Create a highly modular and customizable ant program
+* Create a program that makes small random changes to ant programs
+* BREED SUPERANTS
+
+Contents of this repo:
+
+* `/reference` contains reference materials describing and defining the challenge
+* `/maps` contains scripts to generate and view maps (nodejs)
+* `/asm` Assembles antssembly into my custom antbytecode
+* `/farm` This runs the **ALIEN ANT FARM**
+
+## Reference
+The reference folder contains
+* A sample ant program
+* The reference found on the website
+* A wget download of the relevant SPA
+
+
+## Maps
+As mentioned in the reference, there are 12 map generator functions. 
+
+* chambers
+* bridge
+* gauntlet
+* islands
+* open
+* brush
+* prairie
+* field
+* pockets
+* fortress
+* maze
+* spiral
+
+When looking in the browser, the generated maps have names like 'chambers-3lc8x4' or 'bridge-1u7xlw' where the string after the dash is the seed used, encoded in base36.
+
+* `nodejs maps.js generate -n 120 -o mymaps.maps` generates 120 maps and stores them in mymaps.maps
+* `nodejs maps.js view bridge-1u7xlw` renders the indicated map to ascii
+
+## Asm
+The assembler is not copied from the challenge, but a new implementation. 
+
+It has a couple of deviations from the spec:
+* Literals can only be 0-255, non negative. This is done to simplify the bytecode somewhat. I do not believe i will need literals outside this range (famous last words). This is only the literals in the assembly. The actual registers are full 32bit.
+* Constants, tags and aliases all end up in the same pool, and are case insensitive
+* JMP main is always prepended to every program
+
+
+The bytecode is quite simple. Every instruction is 4 bytes. The first byte is the instruction number, the other 3 are single-byte arguments. 
+
+Jump instructions are a special case. They need to specify a target instruction offset, and the conditional jumps also take two normal arguments. This does not fit into 4 bytes. To accommodate this, our cpu introduces a 9th register called JR and 2 'hidden instructions' called SJR and MJR. Any jump instruction is assembled into 2 bytecode instructions: first SJR or MJR and then the original instruction. SJR (Set JR) uses all 3 argument bytes as a single unsigned little endian int to describe the offset. MJR (Move JR) copies the value from a register into JR. The jump instructions simply use JR as the destination address
+
+## FARM
+Some would say this is where the magic happens.
+
+This is a program that reads the maps file (generated by the maps script), and an apm file (ant program, generated by the assembler) and starts breeding ants!
diff --git a/reference/example.ant b/reference/example.ant
new file mode 100644
index 0000000..a88aa7a
--- /dev/null
+++ b/reference/example.ant
@@ -0,0 +1,110 @@
+; ── SWARM FORAGER ────────────────────────────
+; Random walk to find food, dead reckoning to
+; navigate home. Pheromone marks food for others.
+; Hit play, then try improving it!
+
+; ── Registers ──
+.alias dx   r1           ; x displacement from nest
+.alias dy   r2           ; y displacement from nest
+.alias ret  r3           ; return address for CALL
+
+; ── Pheromone ──
+.const TRAIL CH_RED      ; marks food locations
+
+; ── Roles (visible in simulation viewer) ──
+.tag 0 foraging
+.tag 1 homing
+
+; ──────────────────────────────────────────────
+main:
+    CARRYING
+    JNE r0 0 go_home
+    TAG foraging
+
+; ── SEARCH: find food ─────────────────────────
+search:
+    SENSE FOOD
+    JNE r0 0 grab
+    SMELL TRAIL
+    JNE r0 0 step
+    RANDOM r0 4
+    ADD r0 1
+step:
+    CALL ret move_track
+    JMP main
+
+grab:
+    CALL ret move_track
+    PICKUP
+    MARK TRAIL 100
+    JMP main
+
+; ── GO HOME: dead reckon toward nest ──────────
+go_home:
+    TAG homing
+    SENSE NEST
+    JNE r0 0 deliver
+    RANDOM r0 4
+    JEQ r0 0 wander       ; 25% random to unstick walls
+    CALL ret home_dir
+    CALL ret move_track
+    JMP main
+wander:
+    RANDOM r0 4
+    ADD r0 1
+    CALL ret move_track
+    JMP main
+
+deliver:
+    CALL ret move_track
+    DROP
+    JMP main
+
+; ══════════════════════════════════════════════
+; SUBROUTINES — CALL ret <label>, return JMP ret
+; ══════════════════════════════════════════════
+
+; home_dir: set r0 = direction toward nest
+home_dir:
+    SET r4 dx
+    JGT dx 0 hd_dxp
+    SET r4 0
+    SUB r4 dx
+hd_dxp:
+    SET r5 dy
+    JGT dy 0 hd_dyp
+    SET r5 0
+    SUB r5 dy
+hd_dyp:
+    JGT r5 r4 hd_y
+    JGT dx 0 hd_w
+    SET r0 2
+    JMP ret
+hd_w:
+    SET r0 4
+    JMP ret
+hd_y:
+    JGT dy 0 hd_n
+    SET r0 3
+    JMP ret
+hd_n:
+    SET r0 1
+    JMP ret
+
+; move_track: MOVE r0, then update dx/dy
+move_track:
+    MOVE r0
+    JEQ r0 1 mt_n
+    JEQ r0 2 mt_e
+    JEQ r0 3 mt_s
+    SUB dx 1
+    JMP ret
+mt_n:
+    SUB dy 1
+    JMP ret
+mt_e:
+    ADD dx 1
+    JMP ret
+mt_s:
+    ADD dy 1
+    JMP ret
diff --git a/reference/fetch_site.sh b/reference/fetch_site.sh
new file mode 100644
index 0000000..19ab0ee
--- /dev/null
+++ b/reference/fetch_site.sh
@@ -0,0 +1,2 @@
+#!/bin/bash
+wget -k -np -p -H --adjust-extension  https://dev.moment.com/swarm
diff --git a/reference/random.js b/reference/random.js
new file mode 100644
index 0000000..4116de6
--- /dev/null
+++ b/reference/random.js
@@ -0,0 +1,19 @@
+ next() {
+                let e = 0 | (this.state += 0x9e3779b9);
+                return (
+                    (
+                        (
+                            (
+                                e = Math.imul(
+                                    (
+                                        e = Math.imul(
+                                            e ^ (e >>> 16), 0x85ebca6b
+                                        )
+                                    ) ^ (e >>> 13),  
+                                    0xc2b2ae35,
+                                )
+                            ) ^ (e >>> 16)
+                        ) >>> 0
+                    ) / 0x100000000
+                );
+            }
\ No newline at end of file
diff --git a/reference/reference.txt b/reference/reference.txt
new file mode 100644
index 0000000..5d38f20
--- /dev/null
+++ b/reference/reference.txt
@@ -0,0 +1,235 @@
+SWARM — Ant Colony Optimization Challenge
+
+  200 ants share one program on a 128x128 grid.
+  Find food, bring it to the nest. Communicate
+  only through pheromone trails. Score across 120
+  maps. Hit play to see the default code run,
+  then improve it.
+
+─────────────────────────────────────────────
+
+QUICK START
+
+  SENSE FOOD r1       ; scan 4 adjacent cells for food
+  MOVE r1             ; walk toward it
+  PICKUP              ; grab one unit
+  SENSE NEST r1       ; find the way home
+  MOVE r1             ; walk toward nest
+  DROP                ; deliver (scores if at nest)
+
+─────────────────────────────────────────────
+
+LANGUAGE
+
+  Antssembly is like assembly. The program
+  counter persists across ticks — your ant's
+  "brain" is  a continuous loop, not restarted
+  each tick.
+
+  DIRECTIVES
+
+    .alias dir r1         ; name a register
+    .alias trail r2
+    .const FOOD CH_RED    ; named constant
+    .tag 0 forager        ; name a tag (see TAGS)
+    .tag 1 scout
+
+  .tag names double as constants, so you can
+  write  TAG forager  instead of  TAG 0.
+
+  LABELS
+
+    search:
+      SENSE FOOD dir
+      JEQ dir 0 wander
+      MOVE dir
+      PICKUP
+      JMP search
+    wander:
+      MOVE RANDOM
+
+  ENTRYPOINT
+
+    If a  main:  label exists and isn't at the
+    top, a  JMP main  is auto-prepended.
+
+  REGISTERS   r0-r7, 8 general purpose.
+              Signed 32-bit integers, init to 0.
+              Overflow wraps (32-bit signed).
+  COMMENTS    ; everything after semicolon.
+
+─────────────────────────────────────────────
+
+SENSING
+
+  All sensing ops take an optional dest register
+  (defaults to r0 if omitted).
+
+  SENSE <target> [reg]  scan 4 adjacent cells
+    targets: EMPTY=0  WALL=1  FOOD=2  NEST=3
+             ANT=4  (or register)
+    returns direction (N=1 E=2 S=3 W=4), 0=none
+    ties broken randomly
+
+  SMELL <ch> [reg]      strongest pheromone dir
+    ties broken randomly
+  SNIFF <ch> <dir> [reg]  intensity 0-255
+    dir: HERE N E S W RANDOM (or register)
+  PROBE <dir> [reg]     cell type at direction
+    returns 0=EMPTY 1=WALL 2=FOOD 3=NEST
+  CARRYING [reg]        1 if holding food
+  ID [reg]              ant index (0-199)
+
+─────────────────────────────────────────────
+
+ACTIONS — end the ant's tick
+
+  MOVE <dir>    N/E/S/W, RANDOM, or register
+  PICKUP        pick up 1 food from current cell
+  DROP          drop food (scores if at nest)
+
+  Each ant carries at most 1 food. Multiple ants
+  can share a cell (no collisions). Each tick runs
+  until an action or the 64-op limit. Then the next
+  ant goes. After all 200 ants act, pheromones decay.
+
+─────────────────────────────────────────────
+
+PHEROMONES — 4 channels, intensity 0-255
+
+  CH_RED  CH_BLUE  CH_GREEN  CH_YELLOW
+  Toggle R/B/G/Y in the viewer to see them.
+
+  MARK <ch> <amount>  add to pheromone on this cell
+                      (additive, capped at 255)
+
+  Trail pattern:
+    MARK CH_RED 100     ; add to breadcrumb
+    SMELL CH_RED r2     ; follow gradient
+    MOVE r2
+
+─────────────────────────────────────────────
+
+ARITHMETIC
+
+  SET r1 5          ADD r1 1          SUB r1 1
+  MOD r1 4          MUL r1 3          DIV r1 2
+  AND r1 0xFF       OR r1 1           XOR r1 r2
+  LSHIFT r1 4       RSHIFT r1 4       RANDOM r1 4
+  Second operand can be a register or literal.
+
+  DIV truncates toward zero. MOD is always
+  non-negative. Both are no-ops if divisor=0.
+  SHR is arithmetic (sign-preserving).
+  RANDOM r1 N sets r1 to a value in [0, N).
+
+─────────────────────────────────────────────
+
+CONTROL FLOW
+
+  JMP <label>               unconditional
+  JMP <reg>                 indirect (jump to address in reg)
+  CALL <reg> <label>        save return addr in reg, jump
+  JEQ <a> <b> <label>       jump if a == b
+  JNE <a> <b> <label>       jump if a != b
+  JGT <a> <b> <label>       jump if a > b
+  JLT <a> <b> <label>       jump if a < b
+
+  Function call pattern:
+    CALL r7 my_func       ; save return addr, jump
+    ; ...returns here...
+    my_func:
+      ; do work
+      JMP r7              ; return to caller
+
+─────────────────────────────────────────────
+
+TAGS — role heatmaps for debugging
+
+  TAG <value>       set ant tag 0-7 (ZERO COST)
+
+  .tag 0 forager    name tags for viewer toggles
+  .tag 1 scout      then use:  TAG forager
+
+  Toggle tag heatmaps in the viewer to see
+  where each role's ants have walked. Useful
+  for visualizing role specialization:
+
+    ID r3
+    MOD r3 4
+    TAG r3            ; 4 roles, 4 heatmaps
+
+─────────────────────────────────────────────
+
+THE GRID
+
+  EMPTY  passable       WALL   impassable
+  FOOD   1-8 units      NEST   deliver here
+
+  Directions: N E S W (or NORTH EAST SOUTH WEST)
+  RANDOM = random cardinal direction each call
+
+─────────────────────────────────────────────
+
+MAP TYPES — 12 procedural generators
+
+  Your score is averaged across 120 maps drawn
+  from these types, seeded deterministically.
+
+  open      No internal walls. Random food
+            clusters scattered around the nest.
+
+  maze      Wide-corridor maze. 2-wide passages,
+            2-wide walls.
+
+  spiral    Concentric wavy ring walls with wide
+            random gaps.
+
+  field     Nearly open, a few lazy curvy walls.
+
+  bridge    A vertical wall splits the map with
+            2-4 narrow crossings. All food is
+            on the far side from the nest.
+
+  gauntlet  Nest far left, food far right.
+            Staggered vertical walls with gaps.
+
+  pockets   Circular walled cells with narrow
+            entrances and food inside.
+
+  fortress  Nest cornered behind wavy concentric
+            walls with gates. Food is deep
+            inside the fortress.
+
+  islands   Rooms separated by walls with one
+            doorway between adjacent rooms.
+
+  chambers  Rooms carved in rock connected by
+            narrow corridors.
+
+  prairie   Food everywhere at varying density,
+            no blobs.
+
+  brush     Dense random wall clutter throughout.
+            Food in medium clusters.
+
+─────────────────────────────────────────────
+
+SCORING
+
+  Each map: food delivered / food available.
+  Score = average ratio across 120 maps * 1000.
+  Deterministic — same code, same score.
+
+─────────────────────────────────────────────
+
+TIPS
+
+  1. Read the default code — it's a complete
+     two-trail forager with comments.
+  2. SENSE/SMELL return directions — pass to MOVE
+  3. MARK when carrying, SMELL when searching
+  4. ID + MOD for role specialization
+  5. SNIFF reads exact intensity for smarter
+     routing (e.g. pick strongest neighbor)
+  6. .alias and .tag cost nothing — use them