code guessing, round #15 (completed)

const std = @import("std");

const stdout = std.io.getStdOut().writer();
const assert = std.debug.assert;

// positions start in the top left corner of the card,
// counting from zero. x increases rightwards, y increases leftwards.
// x and y must be in the range [0, 4].
const Pos = struct {
    x: u3,
    y: u3,
};

const Card = struct {
    c: [5][5]u7,
    fn find(self: Card, needle: u7) ?Pos {
        for (self.c) |row, y| {
            for (row) |number, x| {
                if (number == needle) {
                    return Pos{ .x = @intCast(u3, x), .y = @intCast(u3, y) };
                }
            }
        }
        return null;
    }

    test "find a number in a card" {
        // zig fmt: off
        const c = Card{
            .c = [5][5]u7{ 
                [_]u7{ 67, 64, 11, 28, 16 }, 
                [_]u7{ 63, 26, 20, 15, 10 }, 
                [_]u7{ 68, 44, 00, 53, 70 }, // <- 70 is here at (4, 2)
                [_]u7{ 22, 56, 38, 51, 09 }, 
                [_]u7{ 47, 33, 17, 39, 59 } 
            },
        };
        // zig fmt: on
        try std.testing.expectEqual(c.find(70), Pos{ .x = 4, .y = 2 });
    }

    test "don't find a number in a card" {
        // zig fmt: off
        const c = Card{
            .c = [5][5]u7{ 
                [_]u7{ 67, 64, 11, 28, 16 }, 
                [_]u7{ 63, 26, 20, 15, 10 }, 
                [_]u7{ 68, 44, 00, 53, 70 }, // 69 is not in this card
                [_]u7{ 22, 56, 38, 51, 09 }, 
                [_]u7{ 47, 33, 17, 39, 59 } 
            },
        };
        // zig fmt: on
        try std.testing.expectEqual(c.find(69), null);
    }
};

const Marks = struct {
    msk: u25, // bit mask storing marked positions. the lowest bit is 0, 0, the highest bit is at 4, 4.
    // mapping diagram:
    // 0b_00000_00000_00000_00000_00000
    // y: 44444 33333 22222 11111 00000
    // x: 43210 43210 43210 43210 43210

    // set the bit at the mapped position to 1
    fn mark(self: *Marks, x: u3, y: u3) void {
        assert(x <= 4 and y <= 4);
        self.msk |= (@as(u25, 1) << (@as(u5, x) + @as(u5, y) * @as(u5, 5)));
    }

    // wrapper to use the `Pos` struct. tests depend on passing in x, y as args, so the original
    // function wasn't changed.
    fn markPos(self: *Marks, p: Pos) void {
        self.mark(p.x, p.y);
    }

    fn row(self: Marks) bool {
        // zig fmt: off
        const rows = [5]u25{ 
            0b00000_00000_00000_00000_11111, 
            0b00000_00000_00000_11111_00000, 
            0b00000_00000_11111_00000_00000, 
            0b00000_11111_00000_00000_00000, 
            0b11111_00000_00000_00000_00000 
        };
        // zig fmt: on
        var match = false;
        for (rows) |r| {
            match = ((r & self.msk) == r) or match;
        }
        return match;
    }

    test "detect five-in-a-row" {
        var m = Marks{ .msk = 0 };
        // O O O O O
        // O O O O O
        // O O O O O
        // X X X X X
        // O O O O O
        m.mark(0, 3);
        m.mark(1, 3);
        m.mark(2, 3);
        m.mark(3, 3);
        m.mark(4, 3);
        try std.testing.expectEqual(m.row(), true);
        try std.testing.expectEqual(m.wins(), true);
    }

    test "noisy row" {
        var m = Marks{ .msk = 0 };
        // X X O O O
        // O O O O O
        // O O O O O
        // X X X X X
        // O X O O O
        m.mark(0, 3);
        m.mark(1, 0);
        m.mark(1, 3);
        m.mark(2, 3);
        m.mark(3, 3);
        m.mark(4, 3);
        m.mark(0, 0);
        m.mark(1, 0);
        m.mark(1, 4);
        try std.testing.expectEqual(m.row(), true);
        try std.testing.expectEqual(m.wins(), true);
    }

    fn col(self: Marks) bool {
        // zig fmt: off
        const cols = [5]u25{ 
            0b00001_00001_00001_00001_00001, 
            0b00010_00010_00010_00010_00010, 
            0b00100_00100_00100_00100_00100,
            0b01000_01000_01000_01000_01000, 
            0b10000_10000_10000_10000_10000 
        };
        // zig fmt: on
        var match = false;
        for (cols) |c| {
            match = ((c & self.msk) == c) or match;
        }
        return match;
    }

    test "detect five-in-a-col" {
        var m = Marks{ .msk = 0 };
        // O O X O O
        // O O X O O
        // O O X O O
        // O O X O O
        // O O X O O
        m.mark(2, 0);
        m.mark(2, 1);
        m.mark(2, 2);
        m.mark(2, 3);
        m.mark(2, 4);
        try std.testing.expectEqual(m.col(), true);
        try std.testing.expectEqual(m.wins(), true);
    }

    test "noisy col" {
        var m = Marks{ .msk = 0 };
        // X O X O O
        // O O X O O
        // O O X O X
        // O O X O O
        // O O X O O
        m.mark(2, 0);
        m.mark(2, 1);
        m.mark(2, 2);
        m.mark(2, 3);
        m.mark(2, 4);
        m.mark(4, 2);
        m.mark(0, 0);
        try std.testing.expectEqual(m.col(), true);
        try std.testing.expectEqual(m.wins(), true);
    }

    fn diag(self: Marks) bool {
        // zig fmt: off
        const diags = [2]u25{
            0b00001_00010_00100_01000_10000,
            0b10000_01000_00100_00010_00001,
        };
        // zig fmt: on
        var match = false;
        for (diags) |d| {
            match = ((d & self.msk) == d) or match;
        }
        return match;
    }

    test "detect diagonal" {
        var m = Marks{ .msk = 0 };
        // X O O O O
        // O X O O O
        // O O X O O
        // O O O X O
        // O O O O X
        m.mark(0, 0);
        m.mark(1, 1);
        m.mark(2, 2);
        m.mark(3, 3);
        m.mark(4, 4);
        try std.testing.expectEqual(m.diag(), true);
        try std.testing.expectEqual(m.wins(), true);
    }

    test "noisy diag" {
        var m = Marks{ .msk = 0 };
        // X O O O X
        // O X O O O
        // O O X O O
        // O O X X O
        // O O X O X
        m.mark(0, 0);
        m.mark(1, 1);
        m.mark(2, 2);
        m.mark(2, 3);
        m.mark(3, 3);
        m.mark(4, 4);
        m.mark(2, 4);
        m.mark(4, 0);
        try std.testing.expectEqual(m.diag(), true);
        try std.testing.expectEqual(m.wins(), true);
    }

    fn wins(self: Marks) bool {
        return self.row() or self.col() or self.diag();
    }

    test "loses 1" {
        var m = Marks{ .msk = 0 };
        // X O O X O
        // O O O X O
        // O O X O O
        // O O X O O
        // O O X O X
        m.mark(0, 0);
        m.mark(3, 1);
        m.mark(2, 2);
        m.mark(2, 3);
        m.mark(3, 0);
        m.mark(4, 4);
        m.mark(2, 4);
        try std.testing.expectEqual(m.wins(), false);
    }

    test "loses 2" {
        var m = Marks{ .msk = 0 };
        // X O O X O
        // O X O X O
        // X O X O X
        // O X O O O
        // O O X O X
        m.mark(0, 0);
        m.mark(3, 0);
        m.mark(1, 1);
        m.mark(3, 1);
        m.mark(0, 2);
        m.mark(2, 2);
        m.mark(4, 2);
        m.mark(1, 3);
        m.mark(4, 4);
        m.mark(2, 4);
        try std.testing.expectEqual(m.wins(), false);
    }
};

const Player = struct {
    id: usize,
    card: Card,
    marked: Marks,
    fn play(self: *Player, call: u7) ?usize {
        if (self.card.find(call)) |p| {
            self.marked.markPos(p);
        }
        if (self.marked.wins()) {
            return self.id;
        } else {
            return null;
        }
    }
};

test "a test game" {
    var me = Player{
        .id = 0,
        // zig fmt: off
        .card = Card{
            .c = [5][5]u7{ 
                [_]u7{ 67, 64, 11, 28, 16 }, 
                [_]u7{ 63, 26, 20, 15, 10 }, 
                [_]u7{ 68, 44, 00, 53, 70 }, 
                [_]u7{ 22, 56, 38, 51, 09 }, 
                [_]u7{ 47, 33, 17, 39, 59 },
            },
        },
        // zig fmt: on
        .marked = Marks{ .msk = 0 },
    };
    try std.testing.expectEqual(me.play(0), null);
    try std.testing.expectEqual(me.play(11), null);
    try std.testing.expectEqual(me.play(38), null);
    try std.testing.expectEqual(me.play(50), null);
    try std.testing.expectEqual(me.play(10), null);
    try std.testing.expectEqual(me.play(17), null);
    try std.testing.expectEqual(me.play(20), 0);
}

pub fn entry(cards: []const [5][5]u7, calls: []const u7) usize {
    for (cards) |crd, i| {
        var player = Player{
            .id = i,
            .card = Card{ .c = crd },
            .marked = Marks{ .msk = 0 },
        };
        for (calls) |call| {
            const winnermaybe = player.play(call);
            if (winnermaybe) |winner| {
                return winner;
            }
        }
    }
    unreachable;
}

test "example in prompt" {
    var started = try std.time.Instant.now();
    var i: usize = 0;
    while (i < 1000) {
        // zig fmt: off
        var calls = &[_]u7{0, 72, 3, 8, 59, 66, 61, 58, 23, 14, 16, 42, 10, 17, 2, 48, 44, 26, 70, 21, 31, 19, 9};
        var cards = &[_][5][5]u7{
            [5][5]u7{
                [5]u7{67, 64, 11, 28, 16},
                [5]u7{63, 26, 20, 15, 10},
                [5]u7{68, 44, 00, 53, 70},
                [5]u7{22, 56, 38, 51, 09},
                [5]u7{47, 33, 17, 39, 59},
            },
            [5][5]u7{
                [5]u7{51, 24, 53, 70, 62},
                [5]u7{54, 44, 57, 72, 35},
                [5]u7{32, 05, 00, 20, 38},
                [5]u7{36, 04, 73, 29, 69},
                [5]u7{63, 42, 07, 08, 58},
            }
        };
        i += 1;
        try std.testing.expectEqual(entry(cards, calls), 0);
    }
    // zig fmt: on
    var ended = try std.time.Instant.now();
    std.debug.print("took: {} ", .{ended.since(started)});
}

pub fn main() anyerror!void {
    std.debug.print("It was as if an occult hand brought you to run this program as an application. It is a library, yet lack of zig expertise gently drew me towards creating a application project.", .{});
}

Like a von Neumann ordinal, we could not exist without the help of all those who came before. 

And now, we do it all over again.

import Data.List
import Data.Maybe
import Glue

convertSingle :: Bool -> [[Bool]]
convertSingle True =
  [ [False, True , False]
  , [True , False, True ]
  , [False, True , False]
  ]
convertSingle False =
  [ [False, False, False]
  , [False, False, False]
  , [False, False, False]
  ]

diagToOrth :: [[Bool]] -> [[Bool]]
diagToOrth = concatMap (map concat . transpose) . map (map convertSingle)

canSolve :: [[Bool]] -> Bool
canSolve g = isJust res
  where orth = diagToOrth g
        res :: Maybe [Int]
        res = glueCall "r2.go" $ "entry([]bool{" ++ intercalate "," (map (\x -> case x of True -> "true"; False -> "false") . concat $ orth) ++ "}," ++ show (length orth) ++ ")"

module Glue (glueCall) where

import System.Process
import System.IO.Unsafe
import J

glueCall :: JRead a => String -> String -> a
glueCall f e = jReadFull . unsafePerformIO $ readProcess "raku" ["gluebus.raku", f, e] ""
{-# NOINLINE glueCall #-} 

{-# LANGUAGE TypeSynonymInstances, FlexibleInstances #-}

module J where

import Data.List
import Data.Maybe
import Parsing

class JShow a where
  jShow :: a -> String

instance JShow Int where
  jShow = show

instance {-# OVERLAPS #-} JShow String where
  jShow s = "\"" ++ concatMap (\c -> if c == '"' then "\"" else pure c) s ++ "\""

instance JShow Bool where
  jShow True = "true"
  jShow False = "false"

instance JShow a => JShow [a] where
  jShow xs = "[" ++ intercalate "," (map jShow xs) ++ "]"

instance JShow a => JShow (Maybe a) where
  jShow (Just x) = jShow x
  jShow Nothing = "null"

class JRead a where
  jRead :: Parser a

instance JRead Int where
  jRead = read <$> some digit <* ws

instance {-# OVERLAPS #-} JRead String where
  jRead = char '"' *> many (noneOf ['"', '\\'] <|> '\"' <$ string "\\\"" <|> '\\' <$ string "\\\\" <|> '\n' <$ string "\\\n") <* char '"' <* ws

instance JRead Bool where
  jRead = (True <$ string "true" <|> False <$ string "false") <* ws

instance JRead a => JRead [a] where
  jRead = char '[' *> ws *> (((:) <$> jRead <*> many (char ',' >> ws >> jRead)) <|> return []) <* char ']' <* ws

instance JRead a => JRead (Maybe a) where
  jRead = Nothing <$ string "null" <* ws <|> Just <$> jRead

jReadFull :: JRead a => String -> a
jReadFull = snd . fromJust . runParser (ws *> jRead <* eof)

Copyright (c) 2022 pithlessly, LyricLy, IFcoltransG, RocketRace, OliveIsAWord,
                   Παλαιολόγος, Raghu Ranganathan, Oliver Marks, David Rutter,
                   Benjamin Philippe Applegate, Kaylynn, loovjo, dylan

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

{-# LANGUAGE TupleSections, LambdaCase #-}

module Parsing (Parser, eof, ws, char, string, noneOf, digit, chainl1, (<|>), many, some, optional, runParser) where

import Control.Applicative
import Control.Monad
import Data.Char
import Data.Maybe

newtype Parser a = Parser { runParser :: String -> Maybe (String, a) }

instance Functor Parser where
  fmap f (Parser g) = Parser (fmap (fmap f) . g)

instance Applicative Parser where
  pure x = Parser (Just . (,x))
  (Parser f) <*> (Parser x) = Parser $ \s -> do
    (s', g) <- f s
    (s'', y) <- x s'
    return (s'', g y)

instance Alternative Parser where
  empty = Parser (const Nothing)
  (Parser x) <|> (Parser y) = Parser $ (<|>) <$> x <*> y

instance Monad Parser where
  (Parser m) >>= f = Parser $ (>>= uncurry (flip (runParser . f))) . m

satisfy :: (Char -> Bool) -> Parser Char
satisfy f = Parser $ \case
  (x:xs) | f x -> Just (xs, x)
  _ -> Nothing

eof :: Parser ()
eof = Parser $ \s -> if null s then Just (s, ()) else Nothing

ws :: Parser ()
ws = void $ many (satisfy isSpace)

char :: Char -> Parser Char
char = satisfy . (==)

string :: String -> Parser String
string = foldr (liftA2 (:)) (pure []) . map char

noneOf :: [Char] -> Parser Char
noneOf = satisfy . (not .) . flip elem

digit :: Parser Char
digit = satisfy isDigit

chainl1 :: Parser a -> Parser (a -> a -> a) -> Parser a
chainl1 p op = p >>= go
  where
    go x =
      (do f <- op
          y <- p
          go (f x y)
      ) <|> return x

const std = @import("std");
const glue = @import("glue.zig");
const byte = u7;

pub fn entry(flat_cards: []const u7, calls: []const u7) usize {
    const cards: []const [5][5]u7 = @ptrCast([*]const [5][5]u7, flat_cards.ptr)[0..flat_cards.len/25];

    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    const allocator = arena.allocator();

    for (cards) |card, i| {
        blk: {
            const file = std.fs.cwd().createFile("progress", .{.truncate = false}) catch break :blk;
            defer file.close();
            file.writer().print("{:0>2}/{:0>2}\n", .{i, cards.len}) catch {};
        }
        // not doing this formatting shit again
        var out = std.fmt.allocPrint(allocator, "hasWon({any}, {any})", .{card, calls}) catch unreachable;
        for (out) |x, j| {
            out[j] = switch (x) {
                '{' => '[',
                '}' => ']',
                else => x,
            };
        }
        if (glue.glueCall(bool, "haswon.d", out, allocator)) {
            return i;
        }
    }
    unreachable;
}

import std.string;
import std.process;
import std.conv;
import std.json;
import std.range;
import std.algorithm;
import std.typecons;
import std.traits;

string passSliceToZig(T)(T[] a, string type)
{
    return format("%s{%s}", type, to!(char[])(a)[1..$-1]);
}

// the `get` method on JSONValue doesn't support nested array types or nullables
T getJSON(T)(JSONValue v)
{
    static if (is(typeof(v.get!T())))
    {
        return v.get!T();
    }
    else static if (is(typeof(getJSON!(ElementType!(T))(v))))
    {
        return array(v.get!(JSONValue[])().map!(x => getJSON!(ElementType!(T))(x)));
    }
    else static if (__traits(isSame, TemplateOf!T, Nullable) && is(typeof(getJSON!(TemplateArgsOf!T[0])(v))))
    {
        T x;
        if (v.isNull)
            x.nullify();
        else
            x = T(getJSON!(TemplateArgsOf!T[0])(v));
        return x;
    }
}

T glueCall(T)(string file, string expr)
{
    auto r = execute(["raku", "gluebus.raku", file, expr]);
    try {
    return getJSON!T(parseJSON(r.output));
    } catch (JSONException e)
    {
        import std.stdio;
        writeln(r.output);
        return getJSON!T(parseJSON(r.output));
    }
}

package main

import (
	"os/exec"
	"encoding/json"
)

func GlueCall[T any](file string, expr string) T {
	out, _ := exec.Command("raku", "gluebus.raku", file, expr).Output()
	var r T
	json.Unmarshal(out, &r)
	return r
}

const std = @import("std");

pub fn glueCall(comptime T: type, file: []const u8, expr: []const u8, allocator: std.mem.Allocator) T {
    const result = std.ChildProcess.exec(.{
        .allocator = allocator,
        .argv = &.{"raku", "gluebus.raku", file, expr},
    }) catch unreachable;
    defer {
        allocator.free(result.stdout);
        allocator.free(result.stderr);
    }
    return std.json.parse(T, &std.json.TokenStream.init(result.stdout), .{ .allocator = allocator }) catch unreachable;
}

sub shell_out($filename, $expr) {
    my $contents = slurp $filename;
    my $target = "tmp_" ~ $filename;
    my $output;
    my $cmd;
    given $filename {
        when /go$/ {
            $output = qq:to/END/;
                import (
                    _fmt "fmt"
                    _json "encoding/json"
                )
                $contents
                func main() \{
                    s, _ := _json.Marshal($expr)
                    _fmt.Print(string(s))
                }
                END
            unless $output ~~ /package\s+main/ {
                $output = "package main\n$output"
            }
            $cmd = "go run $target glue.go r5.go";
        }
        when /hs$/ {
            $output = qq:to/END/;
                import J
                $contents
                main = putStr (jShow ($expr))
                END
            $cmd = "runghc $target";
        }
        when /zig$/ {
            $output = qq:to/END/;
                $contents
                pub fn main() !void \{
                    const stdout = std.io.getStdOut().writer();
                    try std.json.stringify(($expr), .\{}, stdout);
                }
                END
            $cmd = "zig run $target --library z --library c";
        }
        when /(\w+).d$/ {
            $output = qq:to/END/;
                import std.json;
                import std.stdio;
                $contents
                void main()
                \{
                    write(JSONValue($expr).toString);
                }
                END
            $cmd = "dmd $target glue.d && ./tmp_$0; rm -f tmp_$0*";
        }
        when /.c$/ {
            # omg hi are you kamila szewczyk
            # im a huge fan can i have your autograph
            $output = $contents ~ q:to/END/.subst(/102362929/, $expr);
                /* \/\/\/\/\/ - Code for judges - \/\/\/\/\/ */
                
                int main() {
                    int dest;
                    long * vec = _$$$$$(102362929, &dest);
                    // small modification for JSON
                    if(dest == 0) {
                        printf("[]");
                        return 0;
                    }
                    printf("[%ld", vec[0]);
                    for(int _$$ = 1; _$$ < dest; _$$++)
                        printf(",%ld", vec[_$$]);
                    printf("]");
                }
                END
            # it's Zig not C ;)
            $cmd = "zig cc $target && ./a.out; rm -f a.out";
            # zig cc doesn't actually compile the program properly.
            $cmd ~~ s:s/zig cc/gcc/;
        }
    }
    spurt $target, $output;
    my $proc = shell $cmd, :out;
    LEAVE unlink $target;
    $proc.out.slurp
}

sub aggressive_assert($cond) {
    $cond or shell "shutdown 0"
}

sub MAIN($filename, $expr) {
    my $output = shell_out($filename, $expr);
    my $valid_json = shell_out("r7.d", "entry(`$output`)");
    aggressive_assert($valid_json eq "true");
    say $output
}

import std.process;
import std.file;
import std.conv;
import std.format;
import std.typecons;
import glue;

bool hasWon(ubyte[5][5] grid, ubyte[] called)
{
    if (!"pad".exists)
    {
        executeShell("zig build-exe r13.zig --library c --library z && ./r13 -c pad.b pad");
    }

    // :)
    std.file.write(".input", to!string(grid));
    auto output = executeShell("cat .input | ./r13 -r pad").output;

    bool[25] bools;
    foreach (n; called)
    {
        auto index = glueCall!(Nullable!size_t)("r8.hs", format(`entry "%02d" "%s"`, n, output));
        if (!index.isNull)
        {
            bools[index.get()/3] = true; 
        }
    }

    return glueCall!bool("is_line.zig", format("isLine(%s)", passSliceToZig(bools, ".")));
}

package hello

func hello() string {
	return "Hello, world!"
}

const std = @import("std");
const glue = @import("glue.zig");

const cell_size = 3;
const segment_size = 5;
const Cell = [cell_size][cell_size]bool;
const Board = [cell_size*segment_size*3+1][cell_size*segment_size*2+1]bool;
const Grid = [segment_size][segment_size]bool;

fn fromText(text: []const u8) Cell {
    var x: usize = 0;
    var y: usize = 0;
    var out: Cell = undefined;
    for (text) |c| {
        if (x == cell_size) {
            std.debug.assert(c == '\n');
            x = 0;
            y += 1;
            continue;
        }
        out[y][x] = switch (c) {
            '#' => true,
            ' ' => false,
            else => unreachable,
        };
        x += 1;
    }
    std.debug.assert(x == cell_size and y == cell_size-1);
    return out;
}

// see missingno.png
const white = fromText(
    \\   
    \\   
    \\   
);

const bad = fromText(
    \\###
    \\###
    \\###
);

const good_side = fromText(
    \\###
    \\   
    \\###
);

const good_down = fromText(
    \\# #
    \\# #
    \\# #
);

const good_bsls = fromText(
    \\ ##
    \\# #
    \\## 
);

const good_fsls = fromText(
    \\## 
    \\# #
    \\ ##
);

fn drawCell(board: *Board, cell: Cell, x: usize, y: usize) void {
    for (cell) |row, j| {
        for (row) |v, i| {
            board[y*cell_size+j][x*cell_size+i] = v;
        }
    }
}

fn drawSegment(board: *Board, grid: Grid, x: usize, y: usize, good: Cell) void {
    for (grid) |row, j| {
        for (row) |v, i| {
            drawCell(board, if (v) good else bad, x*segment_size+i, y*segment_size+j);
        }
    }
}

fn whiteSegment(board: *Board, x: usize, y: usize) void {
    var j: usize = 0;
    while (j < segment_size) : (j += 1) {
        var i: usize = 0;
        while (i < segment_size) : (i += 1) {
            drawCell(board, white, x*segment_size+i, y*segment_size+j);
        }
    }
}

fn rightSegment(board: *Board, x: usize, y: usize) void {
    const i = segment_size-1;
    var j: usize = 0;
    while (j < segment_size) : (j += 1) {
        drawCell(board, bad, x*segment_size+i, y*segment_size+j);
    }
}

fn write(buf: *[]u8, s: []const u8) void {
    std.mem.copy(u8, buf.*, s);
    buf.* = buf.*[s.len..];
}

fn isLine(flat_grid: [25]bool) bool {
    const grid = @bitCast(Grid, flat_grid);

    var board = std.mem.zeroes(Board);
    rightSegment(&board, 0, 0);
    whiteSegment(&board, 0, 1);
    drawSegment(&board, grid, 1, 0, good_fsls);
    drawSegment(&board, grid, 1, 1, good_side);
    drawSegment(&board, grid, 1, 2, good_bsls);
    drawSegment(&board, grid, 0, 2, good_down);

    var buf_back: [8192]u8 = undefined;
    var buf: []u8 = buf_back[0..];
    write(&buf, "canSolve [");
    for (board) |row| {
        write(&buf, "[");
        for (row) |e| {
            write(&buf, if (e) "True,"[0..] else "False,"[0..]);
        }
        // lol
        (buf.ptr-1).* = ']';
        write(&buf, ",");
    }
    (buf.ptr-1).* = ']';

    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();

    return glue.glueCall(bool, "CanSolve.hs", buf_back[0..@ptrToInt(buf.ptr)-@ptrToInt(&buf_back)], arena.allocator());
}