From 5b5d00cd427cc3e3c08aeec2a568a7bee9cfeb23 Mon Sep 17 00:00:00 2001
From: David Vanderson <david.vanderson@gmail.com>
Date: Thu, 28 Sep 2023 11:39:47 -0400
Subject: [PATCH 01/13] textual combination strategy

---
 build.zig                      |  65 ++++--
 src/textdiff/addHeaders.zig    | 399 +++++++++++++++++++++++++++++++++
 src/textdiff/outputHeaders.zig | 171 ++++++++++++++
 src/textdiff/testHeaders.zig   | 115 ++++++++++
 4 files changed, 731 insertions(+), 19 deletions(-)
 create mode 100644 src/textdiff/addHeaders.zig
 create mode 100644 src/textdiff/outputHeaders.zig
 create mode 100644 src/textdiff/testHeaders.zig

diff --git a/build.zig b/build.zig
index 461b9868..b513f1d4 100644
--- a/build.zig
+++ b/build.zig
@@ -4,26 +4,53 @@ pub fn build(b: *std.build.Builder) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    const arocc_dep = b.anonymousDependency("arocc", @import("arocc/build.zig"), .{
-        .target = target,
-        .optimize = optimize,
-    });
+    const textual = true;
+    if (!textual) {
+        const arocc_dep = b.anonymousDependency("arocc", @import("arocc/build.zig"), .{
+            .target = target,
+            .optimize = optimize,
+        });
 
-    const exe = b.addExecutable(.{
-        .name = "universal-headers",
-        .root_source_file = .{ .path = "src/main.zig" },
-        .target = target,
-        .optimize = optimize,
-    });
-    exe.addModule("arocc", arocc_dep.module("aro"));
-    b.installArtifact(exe);
+        const exe = b.addExecutable(.{
+            .name = "universal-headers",
+            .root_source_file = .{ .path = "src/main.zig" },
+            .target = target,
+            .optimize = optimize,
+        });
+        exe.addModule("arocc", arocc_dep.module("aro"));
+        b.installArtifact(exe);
 
-    const run_cmd = b.addRunArtifact(exe);
-    run_cmd.step.dependOn(b.getInstallStep());
-    if (b.args) |args| {
-        run_cmd.addArgs(args);
-    }
+        const run_cmd = b.addRunArtifact(exe);
+        run_cmd.step.dependOn(b.getInstallStep());
+        if (b.args) |args| {
+            run_cmd.addArgs(args);
+        }
+
+        const run_step = b.step("run", "Run the app");
+        run_step.dependOn(&run_cmd.step);
+    } else {
+        const addHeaders = b.addExecutable(.{
+            .name = "addHeaders",
+            .root_source_file = .{ .path = "src/textdiff/addHeaders.zig" },
+            .target = target,
+            .optimize = optimize,
+        });
+        b.installArtifact(addHeaders);
 
-    const run_step = b.step("run", "Run the app");
-    run_step.dependOn(&run_cmd.step);
+        const outputHeaders = b.addExecutable(.{
+            .name = "outputHeaders",
+            .root_source_file = .{ .path = "src/textdiff/outputHeaders.zig" },
+            .target = target,
+            .optimize = optimize,
+        });
+        b.installArtifact(outputHeaders);
+
+        const testHeaders = b.addExecutable(.{
+            .name = "testHeaders",
+            .root_source_file = .{ .path = "src/textdiff/testHeaders.zig" },
+            .target = target,
+            .optimize = optimize,
+        });
+        b.installArtifact(testHeaders);
+    }
 }
diff --git a/src/textdiff/addHeaders.zig b/src/textdiff/addHeaders.zig
new file mode 100644
index 00000000..cd8526c6
--- /dev/null
+++ b/src/textdiff/addHeaders.zig
@@ -0,0 +1,399 @@
+const std = @import("std");
+
+pub fn main() !void {
+    var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    const arena = arena_allocator.allocator();
+
+    var args = try std.process.argsWithAllocator(arena);
+
+    {
+        var i: usize = 0;
+        while (args.skip()) {
+            i += 1;
+        }
+
+        if (i != 2) {
+            std.debug.print("usage: addHeaders <dir>\n", .{});
+            std.debug.print("adds headers from <dir> into uh_workspace\n", .{});
+            return;
+        }
+    }
+
+    // load lines of file into memory
+    args = try std.process.argsWithAllocator(arena);
+    _ = args.skip();
+    const headerDir = args.next() orelse return;
+
+    var buf = try arena.alloc(u8, 1000);
+    const versionStr = try std.fmt.bufPrint(buf, "{s}|", .{std.fs.path.basename(headerDir)});
+
+    var dir = try std.fs.cwd().openIterableDir(headerDir, .{});
+    defer dir.close();
+
+    std.fs.cwd().makeDir("uh_workspace") catch {};
+
+    var walker = try dir.walk(arena);
+    while (try walker.next()) |entry| {
+        if (entry.kind != .file) {
+            continue;
+        }
+
+        //if (!std.mem.eql(u8, entry.basename, "unistd_ext.h")) continue;
+
+        //std.debug.print("entry: base {s} path {s}\n", .{ entry.basename, entry.path });
+
+        const extra = ".uhversion.txt";
+
+        var filepath = try std.fs.path.join(arena, &.{ headerDir, entry.path });
+        var workpath = try std.fs.path.join(arena, &.{ "uh_workspace", entry.path });
+
+        var worklines = std.ArrayList([]const u8).init(arena);
+        {
+            std.debug.print("createFile {s}\n", .{workpath});
+            if (std.fs.path.dirname(workpath)) |dirname| {
+                try std.fs.cwd().makePath(dirname);
+            }
+            var file = try std.fs.cwd().createFile(workpath, .{ .read = true, .truncate = false });
+            defer file.close();
+            var contents = try file.reader().readAllAlloc(arena, 20 * 1024 * 1024);
+            while (contents.len > 0 and contents[contents.len - 1] == '\n') {
+                contents = contents[0 .. contents.len - 1];
+            }
+
+            if (contents.len > 0) {
+                var it = std.mem.splitScalar(u8, contents, '\n');
+                while (it.next()) |line| {
+                    try worklines.append(line);
+                }
+            }
+        }
+
+        buf = try arena.alloc(u8, 1000);
+        const versionpath = try std.fmt.bufPrint(buf, "{s}{s}", .{ workpath, extra });
+        var versionlines = std.ArrayList([]const u8).init(arena);
+        {
+            var file = try std.fs.cwd().createFile(versionpath, .{ .read = true, .truncate = false });
+            defer file.close();
+            var contents = try file.reader().readAllAlloc(arena, 20 * 1024 * 1024);
+            while (contents.len > 0 and contents[contents.len - 1] == '\n') {
+                contents = contents[0 .. contents.len - 1];
+            }
+
+            if (contents.len > 0) {
+                var it = std.mem.splitScalar(u8, contents, '\n');
+                while (it.next()) |line| {
+                    try versionlines.append(line);
+                }
+            }
+        }
+
+        var filelines = std.ArrayList([]const u8).init(arena);
+        {
+            var file = try std.fs.cwd().openFile(filepath, .{});
+            defer file.close();
+            var contents = try file.reader().readAllAlloc(arena, 20 * 1024 * 1024);
+            while (contents.len > 0 and contents[contents.len - 1] == '\n') {
+                contents = contents[0 .. contents.len - 1];
+            }
+
+            if (contents.len > 0) {
+                var it = std.mem.splitScalar(u8, contents, '\n');
+                while (it.next()) |line| {
+                    // normalize whitespace (replace tabs with spaces)
+                    buf = try arena.alloc(u8, line.len);
+                    _ = std.mem.replace(u8, line, "\t", " ", buf);
+                    try filelines.append(buf);
+                }
+            }
+        }
+
+        // first add context to the new file
+        try addContext(arena, &filelines);
+
+        {
+            var file = try std.fs.cwd().createFile("uh_workfile", .{});
+            defer file.close();
+            var writer = file.writer();
+            for (filelines.items) |line| {
+                try writer.print("{s}\n", .{line});
+            }
+        }
+
+        //std.debug.print("filepath: {s}, workpath: {s}\n", .{ filepath, workpath });
+
+        var diff_stdout = std.ArrayList(u8).init(arena);
+        var diff_stderr = std.ArrayList(u8).init(arena);
+        var diff_child = std.process.Child.init(&.{ "diff", "-wdN", workpath, "uh_workfile" }, arena);
+        diff_child.stdout_behavior = .Pipe;
+        diff_child.stderr_behavior = .Pipe;
+        try diff_child.spawn();
+        try diff_child.collectOutput(&diff_stdout, &diff_stderr, 20 * 1024 * 1024);
+        _ = try diff_child.wait();
+
+        //std.debug.print("diff says:\n{s}\n", .{diff_stdout.items});
+
+        // worklines has all lines accumulated from headers so far
+        // versionlines has versions for all lines in worklines
+        // ctx_stdout.items has new header lines
+
+        // go through diff output and adjust worklines and versionlines
+        var line_adj: isize = 0;
+        var ignore: usize = 0;
+        var last_line: usize = 0;
+
+        var it = std.mem.splitScalar(u8, diff_stdout.items, '\n');
+        while (it.next()) |line| {
+            if (ignore > 0) {
+                std.debug.print("ignore {d} {s}\n", .{ ignore, line });
+                ignore -= 1;
+                continue;
+            }
+
+            if (std.mem.eql(u8, line, "")) {
+                // diff might be empty or end with an empty line
+            } else if (std.mem.indexOfScalar(u8, line, 'a')) |p| {
+                const before = line[0..p];
+                const after = line[p + 1 ..];
+                const addafter = try std.fmt.parseInt(usize, before, 10);
+                var start: usize = undefined;
+                var end: usize = undefined;
+                if (std.mem.indexOfScalar(u8, after, ',')) |pc| {
+                    start = try std.fmt.parseInt(usize, after[0..pc], 10);
+                    end = try std.fmt.parseInt(usize, after[pc + 1 ..], 10);
+                } else {
+                    start = try std.fmt.parseInt(usize, after, 10);
+                    end = start;
+                }
+
+                start -= 1;
+
+                std.debug.print("diff a says {s} -> {d}-{d}\n", .{ line, start, end });
+
+                // from line_adj to addafter, the lines were the same, so add the version
+                for (last_line..@intCast(line_adj + @as(isize, @intCast(addafter)))) |i| {
+                    const old = versionlines.items[i];
+                    buf = try arena.alloc(u8, old.len + versionStr.len);
+                    versionlines.items[i] = try std.fmt.bufPrint(buf, "{s}{s}", .{ old, versionStr });
+                }
+
+                // add lines start..end from new header after line addafter
+                const where: usize = @intCast(line_adj + @as(isize, @intCast(addafter)));
+                try worklines.insertSlice(where, filelines.items[start..end]);
+                //std.debug.print("versionlines.len {d}\n", .{versionlines.items.len});
+                for (0..end - start) |_| {
+                    try versionlines.insert(where, versionStr);
+                }
+
+                //std.debug.print("versionlines.len {d}\n", .{versionlines.items.len});
+
+                last_line = where + end - start;
+                line_adj += @intCast(end - start);
+                ignore = end - start;
+            } else if (std.mem.indexOfScalar(u8, line, 'c')) |p| {
+                var start1: usize = undefined;
+                var end1: usize = undefined;
+                var start2: usize = undefined;
+                var end2: usize = undefined;
+
+                const before = line[0..p];
+                if (std.mem.indexOfScalar(u8, before, ',')) |pc| {
+                    start1 = try std.fmt.parseInt(usize, before[0..pc], 10);
+                    end1 = try std.fmt.parseInt(usize, before[pc + 1 ..], 10);
+                } else {
+                    start1 = try std.fmt.parseInt(usize, before, 10);
+                    end1 = start1;
+                }
+                start1 -= 1;
+
+                const after = line[p + 1 ..];
+                if (std.mem.indexOfScalar(u8, after, ',')) |pc| {
+                    start2 = try std.fmt.parseInt(usize, after[0..pc], 10);
+                    end2 = try std.fmt.parseInt(usize, after[pc + 1 ..], 10);
+                } else {
+                    start2 = try std.fmt.parseInt(usize, after, 10);
+                    end2 = start2;
+                }
+                start2 -= 1;
+
+                std.debug.print("diff c says {s} -> {d}-{d} to {d}-{d}\n", .{ line, start1, end1, start2, end2 });
+
+                // from line_adj to start1, the lines were the same, so add the version
+                for (last_line..@intCast(line_adj + @as(isize, @intCast(start1)))) |i| {
+                    const old = versionlines.items[i];
+                    buf = try arena.alloc(u8, old.len + versionStr.len);
+                    versionlines.items[i] = try std.fmt.bufPrint(buf, "{s}{s}", .{ old, versionStr });
+                }
+
+                const where: usize = @intCast(line_adj + @as(isize, @intCast(end1)));
+                try worklines.insertSlice(where, filelines.items[start2..end2]);
+                for (0..end2 - start2) |_| {
+                    try versionlines.insert(where, versionStr);
+                }
+                last_line = where + end2 - start2;
+                line_adj += @intCast(end2 - start2);
+                ignore = end1 - start1 + end2 - start2 + 1;
+                //std.debug.print("setting ignore to {d} {d} {d} {d} {d}\n", .{ ignore, start1, end1, start2, end2 });
+            } else if (std.mem.indexOfScalar(u8, line, 'd')) |p| {
+                const before = line[0..p];
+
+                var start: usize = undefined;
+                var end: usize = undefined;
+                if (std.mem.indexOfScalar(u8, before, ',')) |pc| {
+                    start = try std.fmt.parseInt(usize, before[0..pc], 10);
+                    end = try std.fmt.parseInt(usize, before[pc + 1 ..], 10);
+                } else {
+                    start = try std.fmt.parseInt(usize, before, 10);
+                    end = start;
+                }
+
+                start -= 1;
+
+                std.debug.print("diff d says {s} -> {d}-{d}\n", .{ line, start, end });
+
+                for (last_line..@intCast(line_adj + @as(isize, @intCast(start)))) |i| {
+                    const old = versionlines.items[i];
+                    buf = try arena.alloc(u8, old.len + versionStr.len);
+                    versionlines.items[i] = try std.fmt.bufPrint(buf, "{s}{s}", .{ old, versionStr });
+                }
+
+                // we just skip over the lines
+                ignore = end - start;
+                last_line = @intCast(line_adj + @as(isize, @intCast(end)));
+            } else {
+                std.debug.print("diff says {s}\n", .{line});
+                return error.asdf;
+            }
+        }
+
+        // from line_adj to the end, the lines must have been the same
+        //std.debug.print("last_line {d} {d}\n", .{ last_line, versionlines.items.len });
+        for (last_line..versionlines.items.len) |i| {
+            const old = versionlines.items[i];
+            buf = try arena.alloc(u8, old.len + versionStr.len);
+            versionlines.items[i] = try std.fmt.bufPrint(buf, "{s}{s}", .{ old, versionStr });
+        }
+
+        // write out worklines and versionlines back to disk
+        {
+            var file = try std.fs.cwd().createFile(workpath, .{});
+            defer file.close();
+            var writer = file.writer();
+            for (worklines.items) |line| {
+                try writer.print("{s}\n", .{line});
+            }
+        }
+
+        {
+            var file = try std.fs.cwd().createFile(versionpath, .{});
+            defer file.close();
+            var writer = file.writer();
+            for (versionlines.items) |line| {
+                try writer.print("{s}\n", .{line});
+            }
+        }
+    }
+}
+
+pub fn addContext(arena: std.mem.Allocator, lines: *std.ArrayList([]const u8)) !void {
+    var context = std.ArrayList(u32).init(arena);
+    try context.append(0);
+    var in_comment: bool = false;
+    for (lines.items, 0..) |line, i| {
+        if ((i + 1) == lines.items.len and std.mem.eql(u8, line, "")) {
+            // don't add a line after last newline
+            break;
+        }
+
+        var pop_context: bool = false;
+
+        var com = in_comment;
+        if (!in_comment and std.mem.indexOf(u8, line, "/*") != null and std.mem.indexOf(u8, line, "*/") == null) {
+            in_comment = true;
+            com = true;
+            // need to context the comments as well otherwise it might break into two pieces
+            var ii = i;
+            const fnv = std.hash.Fnv1a_32;
+            var h = fnv.init();
+            h.value = context.items[context.items.len - 1];
+            while (true) : (ii += 1) {
+                h.update(lines.items[ii]);
+                if (std.mem.indexOf(u8, lines.items[ii], "/*") == null and std.mem.indexOf(u8, lines.items[ii], "*/") != null) {
+                    break;
+                }
+            }
+            try context.append(h.final());
+        } else if (in_comment and std.mem.indexOf(u8, line, "/*") == null and std.mem.indexOf(u8, line, "*/") != null) {
+            in_comment = false; // next line will be out of comment
+            pop_context = true;
+        }
+
+        if (!com) {
+            // could be spaces between # and directive
+            var trimmed = std.mem.trimLeft(u8, line, " ");
+            if (std.mem.startsWith(u8, trimmed, "#")) {
+                trimmed = trimmed[1..];
+                trimmed = std.mem.trimLeft(u8, trimmed, " ");
+                if (std.mem.startsWith(u8, trimmed, "if")) {
+                    const new_context = newContext(lines.items, i, context.items[context.items.len - 1]);
+                    try context.append(new_context);
+                } else if (std.mem.startsWith(u8, trimmed, "endif")) {
+                    pop_context = true;
+                }
+            }
+        }
+
+        var buf = try arena.alloc(u8, 9 + line.len);
+        lines.items[i] = try std.fmt.bufPrint(buf, "{x:0<8} {s}", .{ context.items[context.items.len - 1], line });
+
+        if (pop_context) {
+            _ = context.pop();
+        }
+    }
+}
+
+pub fn newContext(lines: [][]const u8, i: usize, ctx: u32) u32 {
+    const fnv = std.hash.Fnv1a_32;
+    var h = fnv.init();
+    h.value = ctx;
+    std.debug.print("updating hash: {s}\n", .{lines[i]});
+    h.update(lines[i]);
+    var ii = i + 1;
+    var depth: usize = 0;
+    var in_comment: bool = false;
+    while (true) : (ii += 1) {
+        const line = lines[ii];
+        var com = in_comment;
+        if (!in_comment and std.mem.indexOf(u8, line, "/*") != null and std.mem.indexOf(u8, line, "*/") == null) {
+            in_comment = true;
+            com = true;
+        } else if (in_comment and std.mem.indexOf(u8, line, "/*") == null and std.mem.indexOf(u8, line, "*/") != null) {
+            in_comment = false; // next line will be out of comment
+        }
+        std.debug.print("{s} {d} {s}\n", .{ if (com) "c" else " ", depth, line });
+        if (com) {
+            continue;
+        }
+        var trimmed = std.mem.trimLeft(u8, line, " ");
+        if (std.mem.startsWith(u8, trimmed, "#")) {
+            trimmed = trimmed[1..];
+            trimmed = std.mem.trimLeft(u8, trimmed, " ");
+            if (std.mem.startsWith(u8, trimmed, "if")) {
+                depth += 1;
+            } else if (std.mem.startsWith(u8, trimmed, "elif")) {
+                if (depth == 0) {
+                    std.debug.print("updating hash: {s}\n", .{line});
+                    h.update(line);
+                }
+            } else if (std.mem.startsWith(u8, trimmed, "endif")) {
+                if (depth == 0) {
+                    std.debug.print("updating hash: {s}\n", .{line});
+                    h.update(line);
+                    break;
+                }
+                depth -|= 1;
+            }
+        }
+    }
+
+    return h.final();
+}
diff --git a/src/textdiff/outputHeaders.zig b/src/textdiff/outputHeaders.zig
new file mode 100644
index 00000000..71822320
--- /dev/null
+++ b/src/textdiff/outputHeaders.zig
@@ -0,0 +1,171 @@
+const std = @import("std");
+
+pub fn main() !void {
+    var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    const arena = arena_allocator.allocator();
+
+    var args = try std.process.argsWithAllocator(arena);
+
+    {
+        var i: usize = 0;
+        while (args.skip()) {
+            i += 1;
+        }
+
+        if (i != 2 and i != 3) {
+            std.debug.print("usage: outputHeaders <dir> [version]\n", .{});
+            std.debug.print("takes headers from uh_workspace and outputs to <dir>\n", .{});
+            std.debug.print("if version is given, only output lines matching that version (for testing)\n", .{});
+            return;
+        }
+    }
+
+    args = try std.process.argsWithAllocator(arena);
+    _ = args.skip();
+    const outDir = args.next() orelse return;
+    const versionStr = args.next();
+
+    var dir = try std.fs.cwd().openIterableDir("uh_workspace", .{});
+    defer dir.close();
+
+    var walker = try dir.walk(arena);
+    while (try walker.next()) |entry| {
+        if (entry.kind != .file) {
+            continue;
+        }
+
+        const extra = ".uhversion.txt";
+
+        if (std.mem.endsWith(u8, entry.path, extra)) {
+            continue;
+        }
+
+        //if (!std.mem.eql(u8, entry.basename, "unistd_ext.h")) continue;
+
+        //std.debug.print("entry: base {s} path {s}\n", .{ entry.basename, entry.path });
+
+        var workpath = try std.fs.path.join(arena, &.{ "uh_workspace", entry.path });
+
+        var worklines = std.ArrayList([]const u8).init(arena);
+        {
+            var file = try std.fs.cwd().openFile(workpath, .{});
+            defer file.close();
+            var contents = try file.reader().readAllAlloc(arena, 20 * 1024 * 1024);
+            while (contents.len > 0 and contents[contents.len - 1] == '\n') {
+                contents = contents[0 .. contents.len - 1];
+            }
+
+            if (contents.len > 0) {
+                var it = std.mem.splitScalar(u8, contents, '\n');
+                while (it.next()) |line| {
+                    try worklines.append(line);
+                }
+            }
+        }
+
+        var buf = try arena.alloc(u8, 1000);
+        const versionpath = try std.fmt.bufPrint(buf, "{s}{s}", .{ workpath, extra });
+        var versionlines = std.ArrayList([]const u8).init(arena);
+        {
+            var file = try std.fs.cwd().openFile(versionpath, .{});
+            defer file.close();
+            var contents = try file.reader().readAllAlloc(arena, 20 * 1024 * 1024);
+            while (contents.len > 0 and contents[contents.len - 1] == '\n') {
+                contents = contents[0 .. contents.len - 1];
+            }
+
+            if (contents.len > 0) {
+                var it = std.mem.splitScalar(u8, contents, '\n');
+                while (it.next()) |line| {
+                    try versionlines.append(line);
+                }
+            }
+        }
+
+        var filepath = try std.fs.path.join(arena, &.{ outDir, entry.path });
+        if (std.fs.path.dirname(filepath)) |dirname| {
+            try std.fs.cwd().makePath(dirname);
+        }
+        std.debug.print("createFile {s}\n", .{filepath});
+        var outfile = try std.fs.cwd().createFile(filepath, .{});
+        var outwriter = outfile.writer();
+
+        if (versionStr) |version| {
+            for (worklines.items, versionlines.items) |workline, versionline| {
+                if (std.mem.indexOf(u8, versionline, version) != null) {
+                    try outwriter.print("{s}\n", .{workline[9..]});
+                }
+            }
+        } else {
+            var versionstack = std.ArrayList([]const u8).init(arena);
+            for (worklines.items, versionlines.items) |workline, versionline| {
+                if (versionstack.items.len > 0 and std.mem.eql(u8, versionline, versionstack.items[versionstack.items.len - 1])) {
+                    // line is a continuation
+                    try outwriter.print("{s}\n", .{workline[9..]});
+                } else {
+                    // version changed
+
+                    // are we changing to a subset?
+                    var subset: bool = false;
+                    while (versionstack.items.len > 0) {
+                        subset = true;
+                        var vit = std.mem.splitScalar(u8, versionline, '|');
+                        while (vit.next()) |version| {
+                            if (std.mem.eql(u8, version, "")) {
+                                continue;
+                            }
+
+                            if (std.mem.indexOf(u8, versionstack.items[versionstack.items.len - 1], version) == null) {
+                                subset = false;
+                                break;
+                            }
+                        }
+
+                        if (subset) {
+                            break;
+                        } else {
+                            const vline = versionstack.pop();
+                            try outwriter.print("#endif //{s}\n", .{vline});
+                        }
+                    }
+
+                    if (versionstack.items.len > 0 and std.mem.eql(u8, versionline, versionstack.items[versionstack.items.len - 1])) {
+                        // we popped to an exact match of our version, so can continue without a new #if
+                        try outwriter.print("{s}\n", .{workline[9..]});
+                    } else {
+
+                        // we've put any #endif we need, now start a new #if
+                        try outwriter.print("#if ", .{});
+                        var first_v: bool = true;
+                        var vit = std.mem.splitScalar(u8, versionline, '|');
+                        while (vit.next()) |version| {
+                            if (std.mem.eql(u8, version, "")) {
+                                continue;
+                            }
+
+                            if (!first_v) {
+                                try outwriter.print(" OR ", .{});
+                            }
+                            first_v = false;
+                            try outwriter.print("defined {s}", .{version});
+                        }
+                        try outwriter.print(" OR _ZIG_UH_TEST\n", .{});
+
+                        try versionstack.append(versionline);
+
+                        //for (versionstack.items) |vline| {
+                        //    try outwriter.print("//vline {s}\n", .{vline});
+                        //}
+
+                        try outwriter.print("{s}\n", .{workline[9..]});
+                    }
+                }
+            }
+
+            while (versionstack.items.len > 0) {
+                const versionline = versionstack.pop();
+                try outwriter.print("#endif //{s}\n", .{versionline});
+            }
+        }
+    }
+}
diff --git a/src/textdiff/testHeaders.zig b/src/textdiff/testHeaders.zig
new file mode 100644
index 00000000..2e1bf595
--- /dev/null
+++ b/src/textdiff/testHeaders.zig
@@ -0,0 +1,115 @@
+const std = @import("std");
+
+pub fn main() !void {
+    var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    const arena = arena_allocator.allocator();
+
+    var args = try std.process.argsWithAllocator(arena);
+
+    {
+        var i: usize = 0;
+        while (args.skip()) {
+            i += 1;
+        }
+
+        if (i != 4) {
+            std.debug.print("usage: testHeaders <dir> <outdir> <version>\n", .{});
+            std.debug.print("takes universal headers from <dir>, partially evaluates, and outputs to <outdir>\n", .{});
+            std.debug.print("output files should match originals from that version (maybe whitespace differences)\n", .{});
+            return;
+        }
+    }
+
+    args = try std.process.argsWithAllocator(arena);
+    _ = args.skip();
+    const inDir = args.next() orelse return;
+    const outDir = args.next() orelse return;
+    const versionStr = args.next() orelse return;
+
+    var dir = try std.fs.cwd().openIterableDir(inDir, .{});
+    defer dir.close();
+
+    var walker = try dir.walk(arena);
+    while (try walker.next()) |entry| {
+        if (entry.kind != .file) {
+            continue;
+        }
+
+        //if (!std.mem.eql(u8, entry.basename, "unistd_ext.h")) continue;
+
+        //std.debug.print("entry: base {s} path {s}\n", .{ entry.basename, entry.path });
+
+        var inpath = try std.fs.path.join(arena, &.{ inDir, entry.path });
+
+        var inlines = std.ArrayList([]const u8).init(arena);
+        {
+            var file = try std.fs.cwd().openFile(inpath, .{});
+            defer file.close();
+            var contents = try file.reader().readAllAlloc(arena, 20 * 1024 * 1024);
+            while (contents.len > 0 and contents[contents.len - 1] == '\n') {
+                contents = contents[0 .. contents.len - 1];
+            }
+
+            if (contents.len > 0) {
+                var it = std.mem.splitScalar(u8, contents, '\n');
+                while (it.next()) |line| {
+                    try inlines.append(line);
+                }
+            }
+        }
+
+        var outpath = try std.fs.path.join(arena, &.{ outDir, entry.path });
+        if (std.fs.path.dirname(outpath)) |dirname| {
+            try std.fs.cwd().makePath(dirname);
+        }
+        std.debug.print("createFile {s}\n", .{outpath});
+        var outfile = try std.fs.cwd().createFile(outpath, .{});
+        var outwriter = outfile.writer();
+
+        var outputing = std.ArrayList(u2).init(arena);
+        var in_comment: bool = false;
+        for (inlines.items) |line| {
+            std.debug.print("{d} line {s}\n", .{ outputing.items.len, line });
+            var com = in_comment;
+            if (!in_comment and std.mem.indexOf(u8, line, "/*") != null and std.mem.indexOf(u8, line, "*/") == null) {
+                in_comment = true;
+                com = true;
+            } else if (in_comment and std.mem.indexOf(u8, line, "/*") == null and std.mem.indexOf(u8, line, "*/") != null) {
+                in_comment = false; // next line will be out of comment
+            }
+            var trimmed = std.mem.trimLeft(u8, line, " ");
+            if (!com and std.mem.startsWith(u8, trimmed, "#")) {
+                trimmed = trimmed[1..];
+                trimmed = std.mem.trimLeft(u8, trimmed, " ");
+                if (std.mem.startsWith(u8, trimmed, "if")) {
+                    if (std.mem.indexOf(u8, trimmed, "_ZIG_UH_TEST") != null) {
+                        if (std.mem.indexOf(u8, trimmed, versionStr) != null) {
+                            try outputing.append(3);
+                        } else {
+                            try outputing.append(2);
+                        }
+                        continue;
+                    } else {
+                        const currently_outputting = (outputing.items.len == 0 or outputing.items[outputing.items.len - 1] & 1 > 0);
+                        try outputing.append(if (currently_outputting) 1 else 0);
+                    }
+                } else if (std.mem.startsWith(u8, trimmed, "endif")) {
+                    if (outputing.items.len == 0) {
+                        return error.dangling_endif;
+                    }
+
+                    if (outputing.items[outputing.items.len - 1] & 2 > 0) {
+                        _ = outputing.pop();
+                        continue;
+                    } else {
+                        _ = outputing.pop();
+                    }
+                }
+            }
+
+            if (outputing.items.len == 0 or outputing.items[outputing.items.len - 1] & 1 > 0) {
+                try outwriter.print("{s}\n", .{line});
+            }
+        }
+    }
+}

From b1faa275f59f7af455617ad2577636f79f71d889 Mon Sep 17 00:00:00 2001
From: David Vanderson <david.vanderson@gmail.com>
Date: Thu, 28 Sep 2023 20:02:41 -0400
Subject: [PATCH 02/13] working on x86*

---
 src/textdiff/addHeaders.zig    | 79 +++++++++++++++++++++-------------
 src/textdiff/example.bash      | 74 +++++++++++++++++++++++++++++++
 src/textdiff/outputHeaders.zig |  3 +-
 src/textdiff/testHeaders.zig   | 14 +++---
 4 files changed, 135 insertions(+), 35 deletions(-)
 create mode 100755 src/textdiff/example.bash

diff --git a/src/textdiff/addHeaders.zig b/src/textdiff/addHeaders.zig
index cd8526c6..b033d77d 100644
--- a/src/textdiff/addHeaders.zig
+++ b/src/textdiff/addHeaders.zig
@@ -1,5 +1,7 @@
 const std = @import("std");
 
+const debug = false;
+
 pub fn main() !void {
     var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     const arena = arena_allocator.allocator();
@@ -34,11 +36,11 @@ pub fn main() !void {
 
     var walker = try dir.walk(arena);
     while (try walker.next()) |entry| {
-        if (entry.kind != .file) {
+        if (entry.kind != .file and entry.kind != .sym_link) {
             continue;
         }
 
-        //if (!std.mem.eql(u8, entry.basename, "unistd_ext.h")) continue;
+        //if (!std.mem.eql(u8, entry.basename, "_ctype.h")) continue;
 
         //std.debug.print("entry: base {s} path {s}\n", .{ entry.basename, entry.path });
 
@@ -49,7 +51,7 @@ pub fn main() !void {
 
         var worklines = std.ArrayList([]const u8).init(arena);
         {
-            std.debug.print("createFile {s}\n", .{workpath});
+            if (debug) std.debug.print("createFile {s}\n", .{workpath});
             if (std.fs.path.dirname(workpath)) |dirname| {
                 try std.fs.cwd().makePath(dirname);
             }
@@ -144,7 +146,7 @@ pub fn main() !void {
         var it = std.mem.splitScalar(u8, diff_stdout.items, '\n');
         while (it.next()) |line| {
             if (ignore > 0) {
-                std.debug.print("ignore {d} {s}\n", .{ ignore, line });
+                if (debug) std.debug.print("ignore {d} {s}\n", .{ ignore, line });
                 ignore -= 1;
                 continue;
             }
@@ -167,7 +169,7 @@ pub fn main() !void {
 
                 start -= 1;
 
-                std.debug.print("diff a says {s} -> {d}-{d}\n", .{ line, start, end });
+                if (debug) std.debug.print("diff a says {s} -> {d}-{d}\n", .{ line, start, end });
 
                 // from line_adj to addafter, the lines were the same, so add the version
                 for (last_line..@intCast(line_adj + @as(isize, @intCast(addafter)))) |i| {
@@ -215,7 +217,7 @@ pub fn main() !void {
                 }
                 start2 -= 1;
 
-                std.debug.print("diff c says {s} -> {d}-{d} to {d}-{d}\n", .{ line, start1, end1, start2, end2 });
+                if (debug) std.debug.print("diff c says {s} -> {d}-{d} to {d}-{d}\n", .{ line, start1, end1, start2, end2 });
 
                 // from line_adj to start1, the lines were the same, so add the version
                 for (last_line..@intCast(line_adj + @as(isize, @intCast(start1)))) |i| {
@@ -248,7 +250,7 @@ pub fn main() !void {
 
                 start -= 1;
 
-                std.debug.print("diff d says {s} -> {d}-{d}\n", .{ line, start, end });
+                if (debug) std.debug.print("diff d says {s} -> {d}-{d}\n", .{ line, start, end });
 
                 for (last_line..@intCast(line_adj + @as(isize, @intCast(start)))) |i| {
                     const old = versionlines.items[i];
@@ -260,7 +262,7 @@ pub fn main() !void {
                 ignore = end - start;
                 last_line = @intCast(line_adj + @as(isize, @intCast(end)));
             } else {
-                std.debug.print("diff says {s}\n", .{line});
+                //std.debug.print("diff says {s}\n", .{line});
                 return error.asdf;
             }
         }
@@ -295,6 +297,7 @@ pub fn main() !void {
 }
 
 pub fn addContext(arena: std.mem.Allocator, lines: *std.ArrayList([]const u8)) !void {
+    var seen_contexts = std.ArrayList(u32).init(arena);
     var context = std.ArrayList(u32).init(arena);
     try context.append(0);
     var in_comment: bool = false;
@@ -309,19 +312,6 @@ pub fn addContext(arena: std.mem.Allocator, lines: *std.ArrayList([]const u8)) !
         var com = in_comment;
         if (!in_comment and std.mem.indexOf(u8, line, "/*") != null and std.mem.indexOf(u8, line, "*/") == null) {
             in_comment = true;
-            com = true;
-            // need to context the comments as well otherwise it might break into two pieces
-            var ii = i;
-            const fnv = std.hash.Fnv1a_32;
-            var h = fnv.init();
-            h.value = context.items[context.items.len - 1];
-            while (true) : (ii += 1) {
-                h.update(lines.items[ii]);
-                if (std.mem.indexOf(u8, lines.items[ii], "/*") == null and std.mem.indexOf(u8, lines.items[ii], "*/") != null) {
-                    break;
-                }
-            }
-            try context.append(h.final());
         } else if (in_comment and std.mem.indexOf(u8, line, "/*") == null and std.mem.indexOf(u8, line, "*/") != null) {
             in_comment = false; // next line will be out of comment
             pop_context = true;
@@ -334,14 +324,46 @@ pub fn addContext(arena: std.mem.Allocator, lines: *std.ArrayList([]const u8)) !
                 trimmed = trimmed[1..];
                 trimmed = std.mem.trimLeft(u8, trimmed, " ");
                 if (std.mem.startsWith(u8, trimmed, "if")) {
-                    const new_context = newContext(lines.items, i, context.items[context.items.len - 1]);
-                    try context.append(new_context);
+                    var ctx = newContext(lines.items, i, context.items[context.items.len - 1]);
+                    for (seen_contexts.items) |sc| {
+                        if (ctx == sc) {
+                            ctx += 1;
+                            break;
+                        }
+                    }
+                    try context.append(ctx);
+                    try seen_contexts.append(ctx);
                 } else if (std.mem.startsWith(u8, trimmed, "endif")) {
                     pop_context = true;
                 }
             }
         }
 
+        if (!com and in_comment) {
+            // just transitioned into a comment
+            // need to context the comments as well otherwise it might break into two pieces
+            var ii = i;
+            const fnv = std.hash.Fnv1a_32;
+            var h = fnv.init();
+            h.value = context.items[context.items.len - 1];
+            while (true) : (ii += 1) {
+                h.update(lines.items[ii]);
+                h.update("1"); // update even on an empty line
+                if (std.mem.indexOf(u8, lines.items[ii], "/*") == null and std.mem.indexOf(u8, lines.items[ii], "*/") != null) {
+                    break;
+                }
+            }
+            var ctx = h.final();
+            for (seen_contexts.items) |sc| {
+                if (ctx == sc) {
+                    ctx += 1;
+                    break;
+                }
+            }
+            try context.append(ctx);
+            try seen_contexts.append(ctx);
+        }
+
         var buf = try arena.alloc(u8, 9 + line.len);
         lines.items[i] = try std.fmt.bufPrint(buf, "{x:0<8} {s}", .{ context.items[context.items.len - 1], line });
 
@@ -355,21 +377,20 @@ pub fn newContext(lines: [][]const u8, i: usize, ctx: u32) u32 {
     const fnv = std.hash.Fnv1a_32;
     var h = fnv.init();
     h.value = ctx;
-    std.debug.print("updating hash: {s}\n", .{lines[i]});
+    if (debug) std.debug.print("updating hash: {s}\n", .{lines[i]});
     h.update(lines[i]);
     var ii = i + 1;
     var depth: usize = 0;
     var in_comment: bool = false;
-    while (true) : (ii += 1) {
+    while (ii < lines.len) : (ii += 1) {
         const line = lines[ii];
         var com = in_comment;
         if (!in_comment and std.mem.indexOf(u8, line, "/*") != null and std.mem.indexOf(u8, line, "*/") == null) {
             in_comment = true;
-            com = true;
         } else if (in_comment and std.mem.indexOf(u8, line, "/*") == null and std.mem.indexOf(u8, line, "*/") != null) {
             in_comment = false; // next line will be out of comment
         }
-        std.debug.print("{s} {d} {s}\n", .{ if (com) "c" else " ", depth, line });
+        if (debug) std.debug.print("{s} {d} {s}\n", .{ if (com) "c" else " ", depth, line });
         if (com) {
             continue;
         }
@@ -381,12 +402,12 @@ pub fn newContext(lines: [][]const u8, i: usize, ctx: u32) u32 {
                 depth += 1;
             } else if (std.mem.startsWith(u8, trimmed, "elif")) {
                 if (depth == 0) {
-                    std.debug.print("updating hash: {s}\n", .{line});
+                    if (debug) std.debug.print("updating hash: {s}\n", .{line});
                     h.update(line);
                 }
             } else if (std.mem.startsWith(u8, trimmed, "endif")) {
                 if (depth == 0) {
-                    std.debug.print("updating hash: {s}\n", .{line});
+                    if (debug) std.debug.print("updating hash: {s}\n", .{line});
                     h.update(line);
                     break;
                 }
diff --git a/src/textdiff/example.bash b/src/textdiff/example.bash
new file mode 100755
index 00000000..c3204b4d
--- /dev/null
+++ b/src/textdiff/example.bash
@@ -0,0 +1,74 @@
+
+if [ -d uh_workspace ];
+then
+    echo "directory uh_workspace already exists, need to remove it"
+    exit 1
+fi
+
+
+HEADER_LIST=""
+#HEADER_LIST="$HEADER_LIST headers/i386-linux-musl"
+#HEADER_LIST="$HEADER_LIST headers/i486-linux-gnu.2.32"
+#HEADER_LIST="$HEADER_LIST headers/i486-linux-gnu.2.33"
+#HEADER_LIST="$HEADER_LIST headers/i486-linux-gnu.2.34"
+#HEADER_LIST="$HEADER_LIST headers/i486-linux-gnu.2.35"
+#HEADER_LIST="$HEADER_LIST headers/i486-linux-gnu.2.36"
+#HEADER_LIST="$HEADER_LIST headers/i586-linux-gnu.2.32"
+#HEADER_LIST="$HEADER_LIST headers/i586-linux-gnu.2.33"
+#HEADER_LIST="$HEADER_LIST headers/i586-linux-gnu.2.34"
+#HEADER_LIST="$HEADER_LIST headers/i586-linux-gnu.2.35"
+#HEADER_LIST="$HEADER_LIST headers/i586-linux-gnu.2.36"
+#HEADER_LIST="$HEADER_LIST headers/i686-linux-gnu.2.32"
+#HEADER_LIST="$HEADER_LIST headers/i686-linux-gnu.2.33"
+#HEADER_LIST="$HEADER_LIST headers/i686-linux-gnu.2.34"
+#HEADER_LIST="$HEADER_LIST headers/i686-linux-gnu.2.35"
+#HEADER_LIST="$HEADER_LIST headers/i686-linux-gnu.2.36"
+#HEADER_LIST="$HEADER_LIST headers/ia64-linux-gnu.2.32"
+#HEADER_LIST="$HEADER_LIST headers/ia64-linux-gnu.2.33"
+#HEADER_LIST="$HEADER_LIST headers/ia64-linux-gnu.2.34"
+#HEADER_LIST="$HEADER_LIST headers/ia64-linux-gnu.2.35"
+#HEADER_LIST="$HEADER_LIST headers/ia64-linux-gnu.2.36"
+
+HEADER_LIST="$HEADER_LIST headers/x86_64-freebsd.12.3-gnu"
+HEADER_LIST="$HEADER_LIST headers/x86_64-freebsd.13.1-gnu"
+HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.32"
+HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.33"
+HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.34"
+HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.35"
+HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.36"
+HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.32"
+HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.33"
+HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.34"
+HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.35"
+HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.36"
+HEADER_LIST="$HEADER_LIST headers/x86_64-linux-musl"
+HEADER_LIST="$HEADER_LIST headers/x86_64-macos.11-none"
+HEADER_LIST="$HEADER_LIST headers/x86_64-macos.12-none"
+HEADER_LIST="$HEADER_LIST headers/x86_64-macos.13-none"
+HEADER_LIST="$HEADER_LIST headers/x86-freebsd.12.3-gnu"
+HEADER_LIST="$HEADER_LIST headers/x86-freebsd.13.1-gnu"
+
+for i in $HEADER_LIST;
+do
+    echo "addHeaders $i"
+    ./zig-out/bin/addHeaders $i || exit 1
+done
+
+
+echo "outputHeaders"
+./zig-out/bin/outputHeaders univ_headers || exit 1
+
+
+for i in $HEADER_LIST;
+do
+    echo "testHeaders $i"
+    ./zig-out/bin/testHeaders univ_headers uh_test $i
+    diff -uBwr $i uh_test | grep -v "Only in" > uh_diff
+    if [ -s uh_diff ]
+    then
+        echo "failed: diff -uBwr $i uh_test"
+        exit 1
+    fi
+done
+
+exit 0
diff --git a/src/textdiff/outputHeaders.zig b/src/textdiff/outputHeaders.zig
index 71822320..33b68f2f 100644
--- a/src/textdiff/outputHeaders.zig
+++ b/src/textdiff/outputHeaders.zig
@@ -86,8 +86,9 @@ pub fn main() !void {
         if (std.fs.path.dirname(filepath)) |dirname| {
             try std.fs.cwd().makePath(dirname);
         }
-        std.debug.print("createFile {s}\n", .{filepath});
+        //std.debug.print("createFile {s}\n", .{filepath});
         var outfile = try std.fs.cwd().createFile(filepath, .{});
+        defer outfile.close();
         var outwriter = outfile.writer();
 
         if (versionStr) |version| {
diff --git a/src/textdiff/testHeaders.zig b/src/textdiff/testHeaders.zig
index 2e1bf595..913a42bb 100644
--- a/src/textdiff/testHeaders.zig
+++ b/src/textdiff/testHeaders.zig
@@ -1,5 +1,7 @@
 const std = @import("std");
 
+const debug = false;
+
 pub fn main() !void {
     var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     const arena = arena_allocator.allocator();
@@ -24,7 +26,7 @@ pub fn main() !void {
     _ = args.skip();
     const inDir = args.next() orelse return;
     const outDir = args.next() orelse return;
-    const versionStr = args.next() orelse return;
+    const versionStr = std.fs.path.basename(args.next() orelse return);
 
     var dir = try std.fs.cwd().openIterableDir(inDir, .{});
     defer dir.close();
@@ -35,7 +37,7 @@ pub fn main() !void {
             continue;
         }
 
-        //if (!std.mem.eql(u8, entry.basename, "unistd_ext.h")) continue;
+        //if (!std.mem.eql(u8, entry.basename, "e_os2.h")) continue;
 
         //std.debug.print("entry: base {s} path {s}\n", .{ entry.basename, entry.path });
 
@@ -62,18 +64,18 @@ pub fn main() !void {
         if (std.fs.path.dirname(outpath)) |dirname| {
             try std.fs.cwd().makePath(dirname);
         }
-        std.debug.print("createFile {s}\n", .{outpath});
+        if (debug) std.debug.print("createFile {s}\n", .{outpath});
         var outfile = try std.fs.cwd().createFile(outpath, .{});
+        defer outfile.close();
         var outwriter = outfile.writer();
 
         var outputing = std.ArrayList(u2).init(arena);
         var in_comment: bool = false;
         for (inlines.items) |line| {
-            std.debug.print("{d} line {s}\n", .{ outputing.items.len, line });
+            if (debug) std.debug.print("{d} {s}\n", .{ outputing.items.len, line });
             var com = in_comment;
             if (!in_comment and std.mem.indexOf(u8, line, "/*") != null and std.mem.indexOf(u8, line, "*/") == null) {
                 in_comment = true;
-                com = true;
             } else if (in_comment and std.mem.indexOf(u8, line, "/*") == null and std.mem.indexOf(u8, line, "*/") != null) {
                 in_comment = false; // next line will be out of comment
             }
@@ -81,7 +83,9 @@ pub fn main() !void {
             if (!com and std.mem.startsWith(u8, trimmed, "#")) {
                 trimmed = trimmed[1..];
                 trimmed = std.mem.trimLeft(u8, trimmed, " ");
+                if (debug) std.debug.print("trimmed {s}\n", .{trimmed});
                 if (std.mem.startsWith(u8, trimmed, "if")) {
+                    if (debug) std.debug.print("- if\n", .{});
                     if (std.mem.indexOf(u8, trimmed, "_ZIG_UH_TEST") != null) {
                         if (std.mem.indexOf(u8, trimmed, versionStr) != null) {
                             try outputing.append(3);

From 11cfb4947b605b80b785605f9b0b9ad64ad3d65e Mon Sep 17 00:00:00 2001
From: David Vanderson <david.vanderson@gmail.com>
Date: Thu, 28 Sep 2023 20:24:01 -0400
Subject: [PATCH 03/13] make example output to uh_headers

---
 src/textdiff/example.bash | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/textdiff/example.bash b/src/textdiff/example.bash
index c3204b4d..06a1de94 100755
--- a/src/textdiff/example.bash
+++ b/src/textdiff/example.bash
@@ -1,7 +1,7 @@
 
 if [ -d uh_workspace ];
 then
-    echo "directory uh_workspace already exists, need to remove it"
+    echo "directory uh_workspace already exists, need to remove it - rm -r uh_* ?"
     exit 1
 fi
 
@@ -56,13 +56,13 @@ done
 
 
 echo "outputHeaders"
-./zig-out/bin/outputHeaders univ_headers || exit 1
+./zig-out/bin/outputHeaders uh_headers || exit 1
 
 
 for i in $HEADER_LIST;
 do
     echo "testHeaders $i"
-    ./zig-out/bin/testHeaders univ_headers uh_test $i
+    ./zig-out/bin/testHeaders uh_headers uh_test $i
     diff -uBwr $i uh_test | grep -v "Only in" > uh_diff
     if [ -s uh_diff ]
     then

From e3c556b117bb736f5759490de6e667d9a0d6465f Mon Sep 17 00:00:00 2001
From: David Vanderson <david.vanderson@gmail.com>
Date: Thu, 28 Sep 2023 20:41:37 -0400
Subject: [PATCH 04/13] add some comments

---
 src/textdiff/addHeaders.zig    | 20 +++++++++++++++++---
 src/textdiff/outputHeaders.zig | 10 +++++++++-
 src/textdiff/testHeaders.zig   |  8 +++++++-
 3 files changed, 33 insertions(+), 5 deletions(-)

diff --git a/src/textdiff/addHeaders.zig b/src/textdiff/addHeaders.zig
index b033d77d..ac7b2deb 100644
--- a/src/textdiff/addHeaders.zig
+++ b/src/textdiff/addHeaders.zig
@@ -21,7 +21,6 @@ pub fn main() !void {
         }
     }
 
-    // load lines of file into memory
     args = try std.process.argsWithAllocator(arena);
     _ = args.skip();
     const headerDir = args.next() orelse return;
@@ -36,6 +35,8 @@ pub fn main() !void {
 
     var walker = try dir.walk(arena);
     while (try walker.next()) |entry| {
+
+        // only process files and sym links - right now we copy the sym links into regular files
         if (entry.kind != .file and entry.kind != .sym_link) {
             continue;
         }
@@ -44,11 +45,13 @@ pub fn main() !void {
 
         //std.debug.print("entry: base {s} path {s}\n", .{ entry.basename, entry.path });
 
+        // file extension for our sidecar version information
         const extra = ".uhversion.txt";
 
         var filepath = try std.fs.path.join(arena, &.{ headerDir, entry.path });
         var workpath = try std.fs.path.join(arena, &.{ "uh_workspace", entry.path });
 
+        // read all the lines of our work-in-progress file
         var worklines = std.ArrayList([]const u8).init(arena);
         {
             if (debug) std.debug.print("createFile {s}\n", .{workpath});
@@ -70,6 +73,7 @@ pub fn main() !void {
             }
         }
 
+        // read all the lines of our work-in-progress sidecar version file
         buf = try arena.alloc(u8, 1000);
         const versionpath = try std.fmt.bufPrint(buf, "{s}{s}", .{ workpath, extra });
         var versionlines = std.ArrayList([]const u8).init(arena);
@@ -89,6 +93,7 @@ pub fn main() !void {
             }
         }
 
+        // read all the lines of the new file we are going to merge
         var filelines = std.ArrayList([]const u8).init(arena);
         {
             var file = try std.fs.cwd().openFile(filepath, .{});
@@ -110,8 +115,11 @@ pub fn main() !void {
         }
 
         // first add context to the new file
+        // - this prepends each line with a hash value
+        // - solves diff problems later by keeping #if-#endif blocks and comment blocks together
         try addContext(arena, &filelines);
 
+        // write out the new file with added context to a temp file
         {
             var file = try std.fs.cwd().createFile("uh_workfile", .{});
             defer file.close();
@@ -123,6 +131,7 @@ pub fn main() !void {
 
         //std.debug.print("filepath: {s}, workpath: {s}\n", .{ filepath, workpath });
 
+        // run diff and get the output
         var diff_stdout = std.ArrayList(u8).init(arena);
         var diff_stderr = std.ArrayList(u8).init(arena);
         var diff_child = std.process.Child.init(&.{ "diff", "-wdN", workpath, "uh_workfile" }, arena);
@@ -136,7 +145,7 @@ pub fn main() !void {
 
         // worklines has all lines accumulated from headers so far
         // versionlines has versions for all lines in worklines
-        // ctx_stdout.items has new header lines
+        // filelines has new header lines
 
         // go through diff output and adjust worklines and versionlines
         var line_adj: isize = 0;
@@ -275,7 +284,7 @@ pub fn main() !void {
             versionlines.items[i] = try std.fmt.bufPrint(buf, "{s}{s}", .{ old, versionStr });
         }
 
-        // write out worklines and versionlines back to disk
+        // write out work-in-progress file back to disk
         {
             var file = try std.fs.cwd().createFile(workpath, .{});
             defer file.close();
@@ -285,6 +294,7 @@ pub fn main() !void {
             }
         }
 
+        // write out work-in-progress sidecar version file back to disk
         {
             var file = try std.fs.cwd().createFile(versionpath, .{});
             defer file.close();
@@ -296,6 +306,7 @@ pub fn main() !void {
     }
 }
 
+// Prepend each line of this file with a hash to prevent the diff from splitting #if/#endif into separate versions
 pub fn addContext(arena: std.mem.Allocator, lines: *std.ArrayList([]const u8)) !void {
     var seen_contexts = std.ArrayList(u32).init(arena);
     var context = std.ArrayList(u32).init(arena);
@@ -373,6 +384,9 @@ pub fn addContext(arena: std.mem.Allocator, lines: *std.ArrayList([]const u8)) !
     }
 }
 
+// We are given the line containing the first #if
+// - hash that line, any #elif, and the #endif line together
+// - must skip over any nested #if blocks (and comments)
 pub fn newContext(lines: [][]const u8, i: usize, ctx: u32) u32 {
     const fnv = std.hash.Fnv1a_32;
     var h = fnv.init();
diff --git a/src/textdiff/outputHeaders.zig b/src/textdiff/outputHeaders.zig
index 33b68f2f..a3321fca 100644
--- a/src/textdiff/outputHeaders.zig
+++ b/src/textdiff/outputHeaders.zig
@@ -44,8 +44,8 @@ pub fn main() !void {
 
         //std.debug.print("entry: base {s} path {s}\n", .{ entry.basename, entry.path });
 
+        // read work-in-progress file into memory
         var workpath = try std.fs.path.join(arena, &.{ "uh_workspace", entry.path });
-
         var worklines = std.ArrayList([]const u8).init(arena);
         {
             var file = try std.fs.cwd().openFile(workpath, .{});
@@ -63,6 +63,7 @@ pub fn main() !void {
             }
         }
 
+        // read work-in-progress sidecar version file into memory
         var buf = try arena.alloc(u8, 1000);
         const versionpath = try std.fmt.bufPrint(buf, "{s}{s}", .{ workpath, extra });
         var versionlines = std.ArrayList([]const u8).init(arena);
@@ -82,6 +83,7 @@ pub fn main() !void {
             }
         }
 
+        // make writer to output file that will be our universal header
         var filepath = try std.fs.path.join(arena, &.{ outDir, entry.path });
         if (std.fs.path.dirname(filepath)) |dirname| {
             try std.fs.cwd().makePath(dirname);
@@ -92,12 +94,18 @@ pub fn main() !void {
         var outwriter = outfile.writer();
 
         if (versionStr) |version| {
+            // this is for debugging
             for (worklines.items, versionlines.items) |workline, versionline| {
                 if (std.mem.indexOf(u8, versionline, version) != null) {
                     try outwriter.print("{s}\n", .{workline[9..]});
                 }
             }
         } else {
+            // output the universal header
+            // - we maintain a stack of the version #if blocks we are inside of
+            // - if the version changes, then either:
+            // - - it is a subset of the previous version, so we can add a new nested #if block
+            // - - it is not a subset, so #endif the block and start a new one
             var versionstack = std.ArrayList([]const u8).init(arena);
             for (worklines.items, versionlines.items) |workline, versionline| {
                 if (versionstack.items.len > 0 and std.mem.eql(u8, versionline, versionstack.items[versionstack.items.len - 1])) {
diff --git a/src/textdiff/testHeaders.zig b/src/textdiff/testHeaders.zig
index 913a42bb..3c9f81b3 100644
--- a/src/textdiff/testHeaders.zig
+++ b/src/textdiff/testHeaders.zig
@@ -2,6 +2,8 @@ const std = @import("std");
 
 const debug = false;
 
+// This utility goes through universal headers and only evaluates the #if blocks that we added to make them universal
+// - what comes out can be diffed against the original headers for testing
 pub fn main() !void {
     var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     const arena = arena_allocator.allocator();
@@ -41,8 +43,8 @@ pub fn main() !void {
 
         //std.debug.print("entry: base {s} path {s}\n", .{ entry.basename, entry.path });
 
+        // read universal header into memory
         var inpath = try std.fs.path.join(arena, &.{ inDir, entry.path });
-
         var inlines = std.ArrayList([]const u8).init(arena);
         {
             var file = try std.fs.cwd().openFile(inpath, .{});
@@ -69,7 +71,11 @@ pub fn main() !void {
         defer outfile.close();
         var outwriter = outfile.writer();
 
+        // maintain a stack corresponding to #if blocks we are inside of
+        // - bit 1 is if we should be outputting these lines (because the version matches)
+        // - bit 2 is if this #if block is one we added to make the universal header (we don't want to output those)
         var outputing = std.ArrayList(u2).init(arena);
+
         var in_comment: bool = false;
         for (inlines.items) |line| {
             if (debug) std.debug.print("{d} {s}\n", .{ outputing.items.len, line });

From a0e83af6434b2ded633bbdd23d887537848a8beb Mon Sep 17 00:00:00 2001
From: David Vanderson <david.vanderson@gmail.com>
Date: Thu, 28 Sep 2023 21:47:53 -0400
Subject: [PATCH 05/13] only use /* */ comments in output

---
 src/textdiff/outputHeaders.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/textdiff/outputHeaders.zig b/src/textdiff/outputHeaders.zig
index a3321fca..5b424594 100644
--- a/src/textdiff/outputHeaders.zig
+++ b/src/textdiff/outputHeaders.zig
@@ -134,7 +134,7 @@ pub fn main() !void {
                             break;
                         } else {
                             const vline = versionstack.pop();
-                            try outwriter.print("#endif //{s}\n", .{vline});
+                            try outwriter.print("#endif /*{s}*/\n", .{vline});
                         }
                     }
 
@@ -173,7 +173,7 @@ pub fn main() !void {
 
             while (versionstack.items.len > 0) {
                 const versionline = versionstack.pop();
-                try outwriter.print("#endif //{s}\n", .{versionline});
+                try outwriter.print("#endif /*{s}*/\n", .{versionline});
             }
         }
     }

From e5eccc6dded4920f1074af225702118e32f5e95c Mon Sep 17 00:00:00 2001
From: David Vanderson <david.vanderson@gmail.com>
Date: Thu, 19 Oct 2023 19:42:59 -0400
Subject: [PATCH 06/13] tweak bash script to accept header dirs on command line

---
 src/textdiff/example.bash | 39 ++++++++++++++++++++-------------------
 1 file changed, 20 insertions(+), 19 deletions(-)

diff --git a/src/textdiff/example.bash b/src/textdiff/example.bash
index 06a1de94..40fc54aa 100755
--- a/src/textdiff/example.bash
+++ b/src/textdiff/example.bash
@@ -5,8 +5,9 @@ then
     exit 1
 fi
 
+HEADER_LIST="$@"
 
-HEADER_LIST=""
+#HEADER_LIST=""
 #HEADER_LIST="$HEADER_LIST headers/i386-linux-musl"
 #HEADER_LIST="$HEADER_LIST headers/i486-linux-gnu.2.32"
 #HEADER_LIST="$HEADER_LIST headers/i486-linux-gnu.2.33"
@@ -29,24 +30,24 @@ HEADER_LIST=""
 #HEADER_LIST="$HEADER_LIST headers/ia64-linux-gnu.2.35"
 #HEADER_LIST="$HEADER_LIST headers/ia64-linux-gnu.2.36"
 
-HEADER_LIST="$HEADER_LIST headers/x86_64-freebsd.12.3-gnu"
-HEADER_LIST="$HEADER_LIST headers/x86_64-freebsd.13.1-gnu"
-HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.32"
-HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.33"
-HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.34"
-HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.35"
-HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.36"
-HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.32"
-HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.33"
-HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.34"
-HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.35"
-HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.36"
-HEADER_LIST="$HEADER_LIST headers/x86_64-linux-musl"
-HEADER_LIST="$HEADER_LIST headers/x86_64-macos.11-none"
-HEADER_LIST="$HEADER_LIST headers/x86_64-macos.12-none"
-HEADER_LIST="$HEADER_LIST headers/x86_64-macos.13-none"
-HEADER_LIST="$HEADER_LIST headers/x86-freebsd.12.3-gnu"
-HEADER_LIST="$HEADER_LIST headers/x86-freebsd.13.1-gnu"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-freebsd.12.3-gnu"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-freebsd.13.1-gnu"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.32"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.33"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.34"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.35"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.36"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.32"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.33"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.34"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.35"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.36"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-musl"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-macos.11-none"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-macos.12-none"
+#HEADER_LIST="$HEADER_LIST headers/x86_64-macos.13-none"
+#HEADER_LIST="$HEADER_LIST headers/x86-freebsd.12.3-gnu"
+#HEADER_LIST="$HEADER_LIST headers/x86-freebsd.13.1-gnu"
 
 for i in $HEADER_LIST;
 do

From b80deb4af21236721ab3e1fa4dcef9b2cc930b49 Mon Sep 17 00:00:00 2001
From: David Vanderson <david.vanderson@gmail.com>
Date: Thu, 19 Oct 2023 22:03:12 -0400
Subject: [PATCH 07/13] filter c-style comments and empty lines, bug fix

---
 src/textdiff/addHeaders.zig    | 78 ++++++++++++++++++++++++++++++----
 src/textdiff/compile.bash      | 25 +++++++++++
 src/textdiff/example.bash      | 75 --------------------------------
 src/textdiff/outputHeaders.zig |  4 +-
 src/textdiff/test.bash         | 16 +++++++
 5 files changed, 113 insertions(+), 85 deletions(-)
 create mode 100755 src/textdiff/compile.bash
 delete mode 100755 src/textdiff/example.bash
 create mode 100755 src/textdiff/test.bash

diff --git a/src/textdiff/addHeaders.zig b/src/textdiff/addHeaders.zig
index ac7b2deb..3f973819 100644
--- a/src/textdiff/addHeaders.zig
+++ b/src/textdiff/addHeaders.zig
@@ -16,7 +16,8 @@ pub fn main() !void {
 
         if (i != 2) {
             std.debug.print("usage: addHeaders <dir>\n", .{});
-            std.debug.print("adds headers from <dir> into uh_workspace\n", .{});
+            std.debug.print("normalizes headers from <dir> into uh_norm/<dir>\n", .{});
+            std.debug.print("adds headers from uh_norm/<dir> into uh_workspace\n", .{});
             return;
         }
     }
@@ -26,6 +27,11 @@ pub fn main() !void {
     const headerDir = args.next() orelse return;
 
     var buf = try arena.alloc(u8, 1000);
+
+    const normalized_dir = try std.fmt.bufPrint(buf, "uh_norm/{s}", .{std.fs.path.basename(headerDir)});
+    std.fs.cwd().makePath(normalized_dir) catch {};
+
+    buf = try arena.alloc(u8, 1000);
     const versionStr = try std.fmt.bufPrint(buf, "{s}|", .{std.fs.path.basename(headerDir)});
 
     var dir = try std.fs.cwd().openIterableDir(headerDir, .{});
@@ -41,7 +47,7 @@ pub fn main() !void {
             continue;
         }
 
-        //if (!std.mem.eql(u8, entry.basename, "_ctype.h")) continue;
+        //if (!std.mem.eql(u8, entry.basename, "ucontext.h")) continue;
 
         //std.debug.print("entry: base {s} path {s}\n", .{ entry.basename, entry.path });
 
@@ -50,6 +56,7 @@ pub fn main() !void {
 
         var filepath = try std.fs.path.join(arena, &.{ headerDir, entry.path });
         var workpath = try std.fs.path.join(arena, &.{ "uh_workspace", entry.path });
+        var normalized_path = try std.fs.path.join(arena, &.{ normalized_dir, entry.path });
 
         // read all the lines of our work-in-progress file
         var worklines = std.ArrayList([]const u8).init(arena);
@@ -60,13 +67,15 @@ pub fn main() !void {
             }
             var file = try std.fs.cwd().createFile(workpath, .{ .read = true, .truncate = false });
             defer file.close();
-            var contents = try file.reader().readAllAlloc(arena, 20 * 1024 * 1024);
+            var contents = try file.reader().readAllAlloc(arena, 100 * 1024 * 1024);
+
             while (contents.len > 0 and contents[contents.len - 1] == '\n') {
                 contents = contents[0 .. contents.len - 1];
             }
 
             if (contents.len > 0) {
                 var it = std.mem.splitScalar(u8, contents, '\n');
+
                 while (it.next()) |line| {
                     try worklines.append(line);
                 }
@@ -80,7 +89,7 @@ pub fn main() !void {
         {
             var file = try std.fs.cwd().createFile(versionpath, .{ .read = true, .truncate = false });
             defer file.close();
-            var contents = try file.reader().readAllAlloc(arena, 20 * 1024 * 1024);
+            var contents = try file.reader().readAllAlloc(arena, 100 * 1024 * 1024);
             while (contents.len > 0 and contents[contents.len - 1] == '\n') {
                 contents = contents[0 .. contents.len - 1];
             }
@@ -98,7 +107,37 @@ pub fn main() !void {
         {
             var file = try std.fs.cwd().openFile(filepath, .{});
             defer file.close();
-            var contents = try file.reader().readAllAlloc(arena, 20 * 1024 * 1024);
+            var contents = try file.reader().readAllAlloc(arena, 100 * 1024 * 1024);
+
+            // filter out comments
+            var i: usize = 0;
+            var k: usize = 0;
+            var in_comment = false;
+            while (i < contents.len) {
+                if (i + 1 < contents.len) {
+                    if (!in_comment and std.mem.eql(u8, contents[i..][0..2], "/*")) {
+                        in_comment = true;
+                        i += 2;
+                        continue;
+                    }
+
+                    if (in_comment and std.mem.eql(u8, contents[i..][0..2], "*/")) {
+                        in_comment = false;
+                        i += 2;
+                        continue;
+                    }
+                }
+
+                if (!in_comment) {
+                    contents[k] = contents[i];
+                    k += 1;
+                }
+
+                i += 1;
+            }
+
+            contents.len = k;
+
             while (contents.len > 0 and contents[contents.len - 1] == '\n') {
                 contents = contents[0 .. contents.len - 1];
             }
@@ -109,7 +148,32 @@ pub fn main() !void {
                     // normalize whitespace (replace tabs with spaces)
                     buf = try arena.alloc(u8, line.len);
                     _ = std.mem.replace(u8, line, "\t", " ", buf);
-                    try filelines.append(buf);
+
+                    // filter out empty lines
+                    var empty = true;
+                    for (buf) |ch| {
+                        if (ch != ' ') {
+                            empty = false;
+                            break;
+                        }
+                    }
+
+                    if (!empty) {
+                        try filelines.append(buf);
+                    }
+                }
+            }
+
+            // write out normalized file back to disk for debugging
+            {
+                if (std.fs.path.dirname(normalized_path)) |dirname| {
+                    try std.fs.cwd().makePath(dirname);
+                }
+                var nfile = try std.fs.cwd().createFile(normalized_path, .{});
+                defer nfile.close();
+                var writer = nfile.writer();
+                for (filelines.items) |line| {
+                    try writer.print("{s}\n", .{line});
                 }
             }
         }
@@ -339,7 +403,6 @@ pub fn addContext(arena: std.mem.Allocator, lines: *std.ArrayList([]const u8)) !
                     for (seen_contexts.items) |sc| {
                         if (ctx == sc) {
                             ctx += 1;
-                            break;
                         }
                     }
                     try context.append(ctx);
@@ -368,7 +431,6 @@ pub fn addContext(arena: std.mem.Allocator, lines: *std.ArrayList([]const u8)) !
             for (seen_contexts.items) |sc| {
                 if (ctx == sc) {
                     ctx += 1;
-                    break;
                 }
             }
             try context.append(ctx);
diff --git a/src/textdiff/compile.bash b/src/textdiff/compile.bash
new file mode 100755
index 00000000..002c1404
--- /dev/null
+++ b/src/textdiff/compile.bash
@@ -0,0 +1,25 @@
+
+# example: ./src/textdiff/compile.bash headers/m68k-linux*
+#
+# then run ./src/textdiff/test.bash headers/m68k-linux*
+
+HEADER_LIST="$@"
+
+if [ -d uh_workspace ];
+then
+    echo "directory uh_workspace already exists, need to remove it - rm -r uh_* ?"
+    exit 1
+fi
+
+for i in $HEADER_LIST;
+do
+    echo "addHeaders $i"
+    ./zig-out/bin/addHeaders $i || exit 1
+done
+
+
+echo "outputHeaders"
+./zig-out/bin/outputHeaders uh_headers || exit 1
+
+
+exit 0
diff --git a/src/textdiff/example.bash b/src/textdiff/example.bash
deleted file mode 100755
index 40fc54aa..00000000
--- a/src/textdiff/example.bash
+++ /dev/null
@@ -1,75 +0,0 @@
-
-if [ -d uh_workspace ];
-then
-    echo "directory uh_workspace already exists, need to remove it - rm -r uh_* ?"
-    exit 1
-fi
-
-HEADER_LIST="$@"
-
-#HEADER_LIST=""
-#HEADER_LIST="$HEADER_LIST headers/i386-linux-musl"
-#HEADER_LIST="$HEADER_LIST headers/i486-linux-gnu.2.32"
-#HEADER_LIST="$HEADER_LIST headers/i486-linux-gnu.2.33"
-#HEADER_LIST="$HEADER_LIST headers/i486-linux-gnu.2.34"
-#HEADER_LIST="$HEADER_LIST headers/i486-linux-gnu.2.35"
-#HEADER_LIST="$HEADER_LIST headers/i486-linux-gnu.2.36"
-#HEADER_LIST="$HEADER_LIST headers/i586-linux-gnu.2.32"
-#HEADER_LIST="$HEADER_LIST headers/i586-linux-gnu.2.33"
-#HEADER_LIST="$HEADER_LIST headers/i586-linux-gnu.2.34"
-#HEADER_LIST="$HEADER_LIST headers/i586-linux-gnu.2.35"
-#HEADER_LIST="$HEADER_LIST headers/i586-linux-gnu.2.36"
-#HEADER_LIST="$HEADER_LIST headers/i686-linux-gnu.2.32"
-#HEADER_LIST="$HEADER_LIST headers/i686-linux-gnu.2.33"
-#HEADER_LIST="$HEADER_LIST headers/i686-linux-gnu.2.34"
-#HEADER_LIST="$HEADER_LIST headers/i686-linux-gnu.2.35"
-#HEADER_LIST="$HEADER_LIST headers/i686-linux-gnu.2.36"
-#HEADER_LIST="$HEADER_LIST headers/ia64-linux-gnu.2.32"
-#HEADER_LIST="$HEADER_LIST headers/ia64-linux-gnu.2.33"
-#HEADER_LIST="$HEADER_LIST headers/ia64-linux-gnu.2.34"
-#HEADER_LIST="$HEADER_LIST headers/ia64-linux-gnu.2.35"
-#HEADER_LIST="$HEADER_LIST headers/ia64-linux-gnu.2.36"
-
-#HEADER_LIST="$HEADER_LIST headers/x86_64-freebsd.12.3-gnu"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-freebsd.13.1-gnu"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.32"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.33"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.34"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.35"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu.2.36"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.32"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.33"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.34"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.35"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-gnu-x32.2.36"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-linux-musl"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-macos.11-none"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-macos.12-none"
-#HEADER_LIST="$HEADER_LIST headers/x86_64-macos.13-none"
-#HEADER_LIST="$HEADER_LIST headers/x86-freebsd.12.3-gnu"
-#HEADER_LIST="$HEADER_LIST headers/x86-freebsd.13.1-gnu"
-
-for i in $HEADER_LIST;
-do
-    echo "addHeaders $i"
-    ./zig-out/bin/addHeaders $i || exit 1
-done
-
-
-echo "outputHeaders"
-./zig-out/bin/outputHeaders uh_headers || exit 1
-
-
-for i in $HEADER_LIST;
-do
-    echo "testHeaders $i"
-    ./zig-out/bin/testHeaders uh_headers uh_test $i
-    diff -uBwr $i uh_test | grep -v "Only in" > uh_diff
-    if [ -s uh_diff ]
-    then
-        echo "failed: diff -uBwr $i uh_test"
-        exit 1
-    fi
-done
-
-exit 0
diff --git a/src/textdiff/outputHeaders.zig b/src/textdiff/outputHeaders.zig
index 5b424594..73e260cf 100644
--- a/src/textdiff/outputHeaders.zig
+++ b/src/textdiff/outputHeaders.zig
@@ -50,7 +50,7 @@ pub fn main() !void {
         {
             var file = try std.fs.cwd().openFile(workpath, .{});
             defer file.close();
-            var contents = try file.reader().readAllAlloc(arena, 20 * 1024 * 1024);
+            var contents = try file.reader().readAllAlloc(arena, 100 * 1024 * 1024);
             while (contents.len > 0 and contents[contents.len - 1] == '\n') {
                 contents = contents[0 .. contents.len - 1];
             }
@@ -70,7 +70,7 @@ pub fn main() !void {
         {
             var file = try std.fs.cwd().openFile(versionpath, .{});
             defer file.close();
-            var contents = try file.reader().readAllAlloc(arena, 20 * 1024 * 1024);
+            var contents = try file.reader().readAllAlloc(arena, 100 * 1024 * 1024);
             while (contents.len > 0 and contents[contents.len - 1] == '\n') {
                 contents = contents[0 .. contents.len - 1];
             }
diff --git a/src/textdiff/test.bash b/src/textdiff/test.bash
new file mode 100755
index 00000000..636b2926
--- /dev/null
+++ b/src/textdiff/test.bash
@@ -0,0 +1,16 @@
+
+HEADER_LIST="$@"
+
+for i in $HEADER_LIST;
+do
+    echo "testHeaders $i"
+    ./zig-out/bin/testHeaders uh_headers uh_test $i
+    diff -uBwr uh_norm/$(basename $i) uh_test | grep -v "Only in" > uh_diff
+    if [ -s uh_diff ]
+    then
+        echo "failed: diff -uBwr uh_norm/$(basename $i) uh_test"
+        exit 1
+    fi
+done
+
+exit 0

From 1d5a1fb0a591838416a4c4284b7b74c29c9cae2e Mon Sep 17 00:00:00 2001
From: David Vanderson <david.vanderson@gmail.com>
Date: Fri, 20 Oct 2023 11:01:59 -0400
Subject: [PATCH 08/13] filter // comments

---
 src/textdiff/addHeaders.zig    | 10 +++++++++-
 src/textdiff/outputHeaders.zig |  6 +++---
 src/textdiff/testHeaders.zig   |  2 +-
 3 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/textdiff/addHeaders.zig b/src/textdiff/addHeaders.zig
index 3f973819..279cf688 100644
--- a/src/textdiff/addHeaders.zig
+++ b/src/textdiff/addHeaders.zig
@@ -109,7 +109,7 @@ pub fn main() !void {
             defer file.close();
             var contents = try file.reader().readAllAlloc(arena, 100 * 1024 * 1024);
 
-            // filter out comments
+            // filter out comments (both /**/ and // styles)
             var i: usize = 0;
             var k: usize = 0;
             var in_comment = false;
@@ -126,6 +126,14 @@ pub fn main() !void {
                         i += 2;
                         continue;
                     }
+
+                    if (!in_comment and std.mem.eql(u8, contents[i..][0..2], "//")) {
+                        // skip until we get to a newline
+                        while (contents[i] != '\n') {
+                            i += 1;
+                        }
+                        continue;
+                    }
                 }
 
                 if (!in_comment) {
diff --git a/src/textdiff/outputHeaders.zig b/src/textdiff/outputHeaders.zig
index 73e260cf..d3d6b704 100644
--- a/src/textdiff/outputHeaders.zig
+++ b/src/textdiff/outputHeaders.zig
@@ -134,7 +134,7 @@ pub fn main() !void {
                             break;
                         } else {
                             const vline = versionstack.pop();
-                            try outwriter.print("#endif /*{s}*/\n", .{vline});
+                            try outwriter.print("#endif /*_ZIG_UH_|{s}*/\n", .{vline});
                         }
                     }
 
@@ -158,7 +158,7 @@ pub fn main() !void {
                             first_v = false;
                             try outwriter.print("defined {s}", .{version});
                         }
-                        try outwriter.print(" OR _ZIG_UH_TEST\n", .{});
+                        try outwriter.print(" OR _ZIG_UH_\n", .{});
 
                         try versionstack.append(versionline);
 
@@ -173,7 +173,7 @@ pub fn main() !void {
 
             while (versionstack.items.len > 0) {
                 const versionline = versionstack.pop();
-                try outwriter.print("#endif /*{s}*/\n", .{versionline});
+                try outwriter.print("#endif /*_ZIG_UH_|{s}*/\n", .{versionline});
             }
         }
     }
diff --git a/src/textdiff/testHeaders.zig b/src/textdiff/testHeaders.zig
index 3c9f81b3..1be9ed7a 100644
--- a/src/textdiff/testHeaders.zig
+++ b/src/textdiff/testHeaders.zig
@@ -92,7 +92,7 @@ pub fn main() !void {
                 if (debug) std.debug.print("trimmed {s}\n", .{trimmed});
                 if (std.mem.startsWith(u8, trimmed, "if")) {
                     if (debug) std.debug.print("- if\n", .{});
-                    if (std.mem.indexOf(u8, trimmed, "_ZIG_UH_TEST") != null) {
+                    if (std.mem.indexOf(u8, trimmed, "_ZIG_UH_") != null) {
                         if (std.mem.indexOf(u8, trimmed, versionStr) != null) {
                             try outputing.append(3);
                         } else {

From e10250a93a4400438d4c4d536b378b07d428a3a4 Mon Sep 17 00:00:00 2001
From: David Vanderson <david.vanderson@gmail.com>
Date: Sun, 22 Oct 2023 22:02:40 -0400
Subject: [PATCH 09/13] add reductions.zig that reduces huge #ifs

---
 src/textdiff/compile.bash      |   11 +-
 src/textdiff/outputHeaders.zig |   80 +-
 src/textdiff/reductions.zig    | 1350 ++++++++++++++++++++++++++++++++
 3 files changed, 1419 insertions(+), 22 deletions(-)
 create mode 100644 src/textdiff/reductions.zig

diff --git a/src/textdiff/compile.bash b/src/textdiff/compile.bash
index 002c1404..5b69735b 100755
--- a/src/textdiff/compile.bash
+++ b/src/textdiff/compile.bash
@@ -1,10 +1,17 @@
 
-# example: ./src/textdiff/compile.bash headers/m68k-linux*
+# example: ./src/textdiff/compile.bash headers/*
 #
-# then run ./src/textdiff/test.bash headers/m68k-linux*
+# then run ./src/textdiff/test.bash headers/*
 
 HEADER_LIST="$@"
 
+# check that all headers exist somewhere in reductions.zig - this check is to
+# make sure when new headers are added reductions.zig is updated
+for i in $HEADER_LIST;
+do
+    grep -q `basename $i` src/textdiff/reductions.zig || { echo "couldn't find '`basename $i`' in reductions.zig, is it new?"; exit 1; }
+done
+
 if [ -d uh_workspace ];
 then
     echo "directory uh_workspace already exists, need to remove it - rm -r uh_* ?"
diff --git a/src/textdiff/outputHeaders.zig b/src/textdiff/outputHeaders.zig
index d3d6b704..872436bd 100644
--- a/src/textdiff/outputHeaders.zig
+++ b/src/textdiff/outputHeaders.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const reductions = @import("reductions.zig"){};
 
 pub fn main() !void {
     var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
@@ -40,7 +41,7 @@ pub fn main() !void {
             continue;
         }
 
-        //if (!std.mem.eql(u8, entry.basename, "unistd_ext.h")) continue;
+        //if (!std.mem.eql(u8, entry.basename, "features.h")) continue;
 
         //std.debug.print("entry: base {s} path {s}\n", .{ entry.basename, entry.path });
 
@@ -133,8 +134,8 @@ pub fn main() !void {
                         if (subset) {
                             break;
                         } else {
-                            const vline = versionstack.pop();
-                            try outwriter.print("#endif /*_ZIG_UH_|{s}*/\n", .{vline});
+                            _ = versionstack.pop();
+                            try outwriter.print("#endif /*_ZIG_UH_*/\n", .{});
                         }
                     }
 
@@ -144,21 +145,7 @@ pub fn main() !void {
                     } else {
 
                         // we've put any #endif we need, now start a new #if
-                        try outwriter.print("#if ", .{});
-                        var first_v: bool = true;
-                        var vit = std.mem.splitScalar(u8, versionline, '|');
-                        while (vit.next()) |version| {
-                            if (std.mem.eql(u8, version, "")) {
-                                continue;
-                            }
-
-                            if (!first_v) {
-                                try outwriter.print(" OR ", .{});
-                            }
-                            first_v = false;
-                            try outwriter.print("defined {s}", .{version});
-                        }
-                        try outwriter.print(" OR _ZIG_UH_\n", .{});
+                        try outputIfLine(arena, outwriter, versionline);
 
                         try versionstack.append(versionline);
 
@@ -172,9 +159,62 @@ pub fn main() !void {
             }
 
             while (versionstack.items.len > 0) {
-                const versionline = versionstack.pop();
-                try outwriter.print("#endif /*_ZIG_UH_|{s}*/\n", .{versionline});
+                _ = versionstack.pop();
+                try outwriter.print("#endif /*_ZIG_UH_*/\n", .{});
+            }
+        }
+    }
+}
+
+pub fn outputIfLine(arena: std.mem.Allocator, writer: anytype, versionline: []const u8) !void {
+    var vit = std.mem.splitScalar(u8, versionline, '|');
+    var versions = std.StringArrayHashMap(void).init(arena);
+    while (vit.next()) |version| {
+        if (std.mem.eql(u8, version, "")) {
+            continue;
+        }
+
+        try versions.put(version, {});
+    }
+
+    var replacements = std.ArrayList([]const u8).init(arena);
+
+    inline for (@typeInfo(@TypeOf(reductions)).Struct.fields) |f| {
+        const field = @field(reductions, f.name);
+        var found_all = true;
+        for (0..field.len - 1) |i| {
+            // are all of this reduction's versions here?
+            if (!versions.contains(field[i])) {
+                found_all = false;
+                break;
+            }
+        }
+
+        if (found_all) {
+            // we can replace all these versions with the reduction
+            for (0..field.len - 1) |i| {
+                _ = versions.orderedRemove(field[i]);
             }
+
+            try replacements.append(field[field.len - 1]);
+        }
+    }
+
+    try writer.print("#if ", .{});
+    var first_v: bool = true;
+    for (replacements.items) |rep| {
+        if (!first_v) {
+            try writer.print(" OR ", .{});
+        }
+        first_v = false;
+        try writer.print("{s}", .{rep});
+    }
+    for (versions.keys()) |version| {
+        if (!first_v) {
+            try writer.print(" OR ", .{});
         }
+        first_v = false;
+        try writer.print("defined {s}", .{version});
     }
+    try writer.print(" OR _ZIG_UH_\n", .{});
 }
diff --git a/src/textdiff/reductions.zig b/src/textdiff/reductions.zig
new file mode 100644
index 00000000..d791bdcc
--- /dev/null
+++ b/src/textdiff/reductions.zig
@@ -0,0 +1,1350 @@
+aarch64_linux_gnu: []const []const u8 = &[_][]const u8{
+    "aarch64_be-linux-gnu.2.32",
+    "aarch64_be-linux-gnu.2.33",
+    "aarch64_be-linux-gnu.2.34",
+    "aarch64_be-linux-gnu.2.35",
+    "aarch64_be-linux-gnu.2.36",
+    "aarch64_be-linux-gnu.2.37",
+    "aarch64_be-linux-gnu.2.38",
+    "aarch64-linux-gnu.2.32",
+    "aarch64-linux-gnu.2.33",
+    "aarch64-linux-gnu.2.34",
+    "aarch64-linux-gnu.2.35",
+    "aarch64-linux-gnu.2.36",
+    "aarch64-linux-gnu.2.37",
+    "aarch64-linux-gnu.2.38",
+    "(defined __aarch64__ AND defined __GLIBC__)", // FIXME
+},
+
+arc_linux_gnu: []const []const u8 = &[_][]const u8{
+    "arc-linux-gnu.2.32",
+    "arc-linux-gnu.2.33",
+    "arc-linux-gnu.2.34",
+    "arc-linux-gnu.2.35",
+    "arc-linux-gnu.2.36",
+    "arc-linux-gnu.2.37",
+    "arc-linux-gnu.2.38",
+    "arc-linux-gnuhf.2.32",
+    "arc-linux-gnuhf.2.33",
+    "arc-linux-gnuhf.2.34",
+    "arc-linux-gnuhf.2.35",
+    "arc-linux-gnuhf.2.36",
+    "arc-linux-gnuhf.2.37",
+    "arc-linux-gnuhf.2.38",
+    "(defined __arc__ AND defined __GLIBC__)", // FIXME
+},
+
+arm_linux_gnu: []const []const u8 = &[_][]const u8{
+    "armeb-linux-gnueabi.2.32",
+    "armeb-linux-gnueabi.2.33",
+    "armeb-linux-gnueabi.2.34",
+    "armeb-linux-gnueabi.2.35",
+    "armeb-linux-gnueabi.2.36",
+    "armeb-linux-gnueabi.2.37",
+    "armeb-linux-gnueabi.2.38",
+    "armeb-linux-gnueabihf.2.32",
+    "armeb-linux-gnueabihf.2.33",
+    "armeb-linux-gnueabihf.2.34",
+    "armeb-linux-gnueabihf.2.35",
+    "armeb-linux-gnueabihf.2.36",
+    "armeb-linux-gnueabihf.2.37",
+    "armeb-linux-gnueabihf.2.38",
+    "arm-linux-gnueabi.2.32",
+    "arm-linux-gnueabi.2.33",
+    "arm-linux-gnueabi.2.34",
+    "arm-linux-gnueabi.2.35",
+    "arm-linux-gnueabi.2.36",
+    "arm-linux-gnueabi.2.37",
+    "arm-linux-gnueabi.2.38",
+    "arm-linux-gnueabihf.2.32",
+    "arm-linux-gnueabihf.2.33",
+    "arm-linux-gnueabihf.2.34",
+    "arm-linux-gnueabihf.2.35",
+    "arm-linux-gnueabihf.2.36",
+    "arm-linux-gnueabihf.2.37",
+    "arm-linux-gnueabihf.2.38",
+    "arm-linux-gnueabihf-v7a.2.32",
+    "arm-linux-gnueabihf-v7a.2.33",
+    "arm-linux-gnueabihf-v7a.2.34",
+    "arm-linux-gnueabihf-v7a.2.35",
+    "arm-linux-gnueabihf-v7a.2.36",
+    "arm-linux-gnueabihf-v7a.2.37",
+    "arm-linux-gnueabihf-v7a.2.38",
+    "arm-linux-gnueabi-v4t.2.32",
+    "arm-linux-gnueabi-v4t.2.33",
+    "arm-linux-gnueabi-v4t.2.34",
+    "arm-linux-gnueabi-v4t.2.35",
+    "arm-linux-gnueabi-v4t.2.36",
+    "arm-linux-gnueabi-v4t.2.37",
+    "arm-linux-gnueabi-v4t.2.38",
+    "(defined __arm__ AND defined __GLIBC__)", // FIXME
+},
+
+csky_linux_gnu: []const []const u8 = &[_][]const u8{
+    "csky-linux-gnuabiv2.2.33",
+    "csky-linux-gnuabiv2.2.34",
+    "csky-linux-gnuabiv2.2.35",
+    "csky-linux-gnuabiv2.2.36",
+    "csky-linux-gnuabiv2.2.37",
+    "csky-linux-gnuabiv2.2.38",
+    "csky-linux-gnuabiv2-soft.2.33",
+    "csky-linux-gnuabiv2-soft.2.34",
+    "csky-linux-gnuabiv2-soft.2.35",
+    "csky-linux-gnuabiv2-soft.2.36",
+    "csky-linux-gnuabiv2-soft.2.37",
+    "csky-linux-gnuabiv2-soft.2.38",
+    "(defined __csky__ AND defined __GLIBC__)", // FIXME
+},
+
+i_linux_gnu: []const []const u8 = &[_][]const u8{
+    "i486-linux-gnu.2.32",
+    "i486-linux-gnu.2.33",
+    "i486-linux-gnu.2.34",
+    "i486-linux-gnu.2.35",
+    "i486-linux-gnu.2.36",
+    "i486-linux-gnu.2.37",
+    "i486-linux-gnu.2.38",
+    "i586-linux-gnu.2.32",
+    "i586-linux-gnu.2.33",
+    "i586-linux-gnu.2.34",
+    "i586-linux-gnu.2.35",
+    "i586-linux-gnu.2.36",
+    "i586-linux-gnu.2.37",
+    "i586-linux-gnu.2.38",
+    "i686-linux-gnu.2.32",
+    "i686-linux-gnu.2.33",
+    "i686-linux-gnu.2.34",
+    "i686-linux-gnu.2.35",
+    "i686-linux-gnu.2.36",
+    "i686-linux-gnu.2.37",
+    "i686-linux-gnu.2.38",
+    "ia64-linux-gnu.2.32",
+    "ia64-linux-gnu.2.33",
+    "ia64-linux-gnu.2.34",
+    "ia64-linux-gnu.2.35",
+    "ia64-linux-gnu.2.36",
+    "ia64-linux-gnu.2.37",
+    "ia64-linux-gnu.2.38",
+    "(defined __ISOME__ AND defined __GLIBC__)", // FIXME
+},
+
+m68k_linux_gnu: []const []const u8 = &[_][]const u8{
+    "m68k-linux-gnu.2.32",
+    "m68k-linux-gnu.2.33",
+    "m68k-linux-gnu.2.34",
+    "m68k-linux-gnu.2.35",
+    "m68k-linux-gnu.2.36",
+    "m68k-linux-gnu.2.37",
+    "m68k-linux-gnu.2.38",
+    "(defined __M68K__ AND defined __GLIBC__)", // FIXME
+},
+
+mips64_linux_gnu: []const []const u8 = &[_][]const u8{
+    "mips64el-linux-gnu-n32.2.32",
+    "mips64el-linux-gnu-n32.2.33",
+    "mips64el-linux-gnu-n32.2.34",
+    "mips64el-linux-gnu-n32.2.35",
+    "mips64el-linux-gnu-n32.2.36",
+    "mips64el-linux-gnu-n32.2.37",
+    "mips64el-linux-gnu-n32.2.38",
+    "mips64el-linux-gnu-n32-nan2008.2.32",
+    "mips64el-linux-gnu-n32-nan2008.2.33",
+    "mips64el-linux-gnu-n32-nan2008.2.34",
+    "mips64el-linux-gnu-n32-nan2008.2.35",
+    "mips64el-linux-gnu-n32-nan2008.2.36",
+    "mips64el-linux-gnu-n32-nan2008.2.37",
+    "mips64el-linux-gnu-n32-nan2008.2.38",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.32",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.33",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.34",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.35",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.36",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.37",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.38",
+    "mips64el-linux-gnu-n32-soft.2.32",
+    "mips64el-linux-gnu-n32-soft.2.33",
+    "mips64el-linux-gnu-n32-soft.2.34",
+    "mips64el-linux-gnu-n32-soft.2.35",
+    "mips64el-linux-gnu-n32-soft.2.36",
+    "mips64el-linux-gnu-n32-soft.2.37",
+    "mips64el-linux-gnu-n32-soft.2.38",
+    "mips64el-linux-gnu-n64.2.32",
+    "mips64el-linux-gnu-n64.2.33",
+    "mips64el-linux-gnu-n64.2.34",
+    "mips64el-linux-gnu-n64.2.35",
+    "mips64el-linux-gnu-n64.2.36",
+    "mips64el-linux-gnu-n64.2.37",
+    "mips64el-linux-gnu-n64.2.38",
+    "mips64el-linux-gnu-n64-nan2008.2.32",
+    "mips64el-linux-gnu-n64-nan2008.2.33",
+    "mips64el-linux-gnu-n64-nan2008.2.34",
+    "mips64el-linux-gnu-n64-nan2008.2.35",
+    "mips64el-linux-gnu-n64-nan2008.2.36",
+    "mips64el-linux-gnu-n64-nan2008.2.37",
+    "mips64el-linux-gnu-n64-nan2008.2.38",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.32",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.33",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.34",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.35",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.36",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.37",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.38",
+    "mips64el-linux-gnu-n64-soft.2.32",
+    "mips64el-linux-gnu-n64-soft.2.33",
+    "mips64el-linux-gnu-n64-soft.2.34",
+    "mips64el-linux-gnu-n64-soft.2.35",
+    "mips64el-linux-gnu-n64-soft.2.36",
+    "mips64el-linux-gnu-n64-soft.2.37",
+    "mips64el-linux-gnu-n64-soft.2.38",
+    "mips64-linux-gnu-n32.2.32",
+    "mips64-linux-gnu-n32.2.33",
+    "mips64-linux-gnu-n32.2.34",
+    "mips64-linux-gnu-n32.2.35",
+    "mips64-linux-gnu-n32.2.36",
+    "mips64-linux-gnu-n32.2.37",
+    "mips64-linux-gnu-n32.2.38",
+    "mips64-linux-gnu-n32-nan2008.2.32",
+    "mips64-linux-gnu-n32-nan2008.2.33",
+    "mips64-linux-gnu-n32-nan2008.2.34",
+    "mips64-linux-gnu-n32-nan2008.2.35",
+    "mips64-linux-gnu-n32-nan2008.2.36",
+    "mips64-linux-gnu-n32-nan2008.2.37",
+    "mips64-linux-gnu-n32-nan2008.2.38",
+    "mips64-linux-gnu-n32-nan2008-soft.2.32",
+    "mips64-linux-gnu-n32-nan2008-soft.2.33",
+    "mips64-linux-gnu-n32-nan2008-soft.2.34",
+    "mips64-linux-gnu-n32-nan2008-soft.2.35",
+    "mips64-linux-gnu-n32-nan2008-soft.2.36",
+    "mips64-linux-gnu-n32-nan2008-soft.2.37",
+    "mips64-linux-gnu-n32-nan2008-soft.2.38",
+    "mips64-linux-gnu-n32-soft.2.32",
+    "mips64-linux-gnu-n32-soft.2.33",
+    "mips64-linux-gnu-n32-soft.2.34",
+    "mips64-linux-gnu-n32-soft.2.35",
+    "mips64-linux-gnu-n32-soft.2.36",
+    "mips64-linux-gnu-n32-soft.2.37",
+    "mips64-linux-gnu-n32-soft.2.38",
+    "mips64-linux-gnu-n64.2.32",
+    "mips64-linux-gnu-n64.2.33",
+    "mips64-linux-gnu-n64.2.34",
+    "mips64-linux-gnu-n64.2.35",
+    "mips64-linux-gnu-n64.2.36",
+    "mips64-linux-gnu-n64.2.37",
+    "mips64-linux-gnu-n64.2.38",
+    "mips64-linux-gnu-n64-nan2008.2.32",
+    "mips64-linux-gnu-n64-nan2008.2.33",
+    "mips64-linux-gnu-n64-nan2008.2.34",
+    "mips64-linux-gnu-n64-nan2008.2.35",
+    "mips64-linux-gnu-n64-nan2008.2.36",
+    "mips64-linux-gnu-n64-nan2008.2.37",
+    "mips64-linux-gnu-n64-nan2008.2.38",
+    "mips64-linux-gnu-n64-nan2008-soft.2.32",
+    "mips64-linux-gnu-n64-nan2008-soft.2.33",
+    "mips64-linux-gnu-n64-nan2008-soft.2.34",
+    "mips64-linux-gnu-n64-nan2008-soft.2.35",
+    "mips64-linux-gnu-n64-nan2008-soft.2.36",
+    "mips64-linux-gnu-n64-nan2008-soft.2.37",
+    "mips64-linux-gnu-n64-nan2008-soft.2.38",
+    "mips64-linux-gnu-n64-soft.2.32",
+    "mips64-linux-gnu-n64-soft.2.33",
+    "mips64-linux-gnu-n64-soft.2.34",
+    "mips64-linux-gnu-n64-soft.2.35",
+    "mips64-linux-gnu-n64-soft.2.36",
+    "mips64-linux-gnu-n64-soft.2.37",
+    "mips64-linux-gnu-n64-soft.2.38",
+    "(defined __MIPS64__ AND defined __GLIBC__)", // FIXME
+},
+
+mipsel_linux_gnu: []const []const u8 = &[_][]const u8{
+    "mipsel-linux-gnu.2.32",
+    "mipsel-linux-gnu.2.33",
+    "mipsel-linux-gnu.2.34",
+    "mipsel-linux-gnu.2.35",
+    "mipsel-linux-gnu.2.36",
+    "mipsel-linux-gnu.2.37",
+    "mipsel-linux-gnu.2.38",
+    "mipsel-linux-gnu-nan2008.2.32",
+    "mipsel-linux-gnu-nan2008.2.33",
+    "mipsel-linux-gnu-nan2008.2.34",
+    "mipsel-linux-gnu-nan2008.2.35",
+    "mipsel-linux-gnu-nan2008.2.36",
+    "mipsel-linux-gnu-nan2008.2.37",
+    "mipsel-linux-gnu-nan2008.2.38",
+    "mipsel-linux-gnu-nan2008-soft.2.32",
+    "mipsel-linux-gnu-nan2008-soft.2.33",
+    "mipsel-linux-gnu-nan2008-soft.2.34",
+    "mipsel-linux-gnu-nan2008-soft.2.35",
+    "mipsel-linux-gnu-nan2008-soft.2.36",
+    "mipsel-linux-gnu-nan2008-soft.2.37",
+    "mipsel-linux-gnu-nan2008-soft.2.38",
+    "mipsel-linux-gnu-soft.2.32",
+    "mipsel-linux-gnu-soft.2.33",
+    "mipsel-linux-gnu-soft.2.34",
+    "mipsel-linux-gnu-soft.2.35",
+    "mipsel-linux-gnu-soft.2.36",
+    "mipsel-linux-gnu-soft.2.37",
+    "mipsel-linux-gnu-soft.2.38",
+    "mipsisa32r6el-linux-gnu.2.32",
+    "mipsisa32r6el-linux-gnu.2.33",
+    "mipsisa32r6el-linux-gnu.2.34",
+    "mipsisa32r6el-linux-gnu.2.35",
+    "mipsisa32r6el-linux-gnu.2.36",
+    "mipsisa32r6el-linux-gnu.2.37",
+    "mipsisa32r6el-linux-gnu.2.38",
+    "mipsisa64r6el-linux-gnu-n32.2.32",
+    "mipsisa64r6el-linux-gnu-n32.2.33",
+    "mipsisa64r6el-linux-gnu-n32.2.34",
+    "mipsisa64r6el-linux-gnu-n32.2.35",
+    "mipsisa64r6el-linux-gnu-n32.2.36",
+    "mipsisa64r6el-linux-gnu-n32.2.37",
+    "mipsisa64r6el-linux-gnu-n32.2.38",
+    "mipsisa64r6el-linux-gnu-n64.2.32",
+    "mipsisa64r6el-linux-gnu-n64.2.33",
+    "mipsisa64r6el-linux-gnu-n64.2.34",
+    "mipsisa64r6el-linux-gnu-n64.2.35",
+    "mipsisa64r6el-linux-gnu-n64.2.36",
+    "mipsisa64r6el-linux-gnu-n64.2.37",
+    "mipsisa64r6el-linux-gnu-n64.2.38",
+    "(defined __MIPSEL__ AND defined __GLIBC__)", // FIXME
+},
+
+mips_linux_gnu: []const []const u8 = &[_][]const u8{
+    "mips-linux-gnu.2.32",
+    "mips-linux-gnu.2.33",
+    "mips-linux-gnu.2.34",
+    "mips-linux-gnu.2.35",
+    "mips-linux-gnu.2.36",
+    "mips-linux-gnu.2.37",
+    "mips-linux-gnu.2.38",
+    "mips-linux-gnu-nan2008.2.32",
+    "mips-linux-gnu-nan2008.2.33",
+    "mips-linux-gnu-nan2008.2.34",
+    "mips-linux-gnu-nan2008.2.35",
+    "mips-linux-gnu-nan2008.2.36",
+    "mips-linux-gnu-nan2008.2.37",
+    "mips-linux-gnu-nan2008.2.38",
+    "mips-linux-gnu-nan2008-soft.2.32",
+    "mips-linux-gnu-nan2008-soft.2.33",
+    "mips-linux-gnu-nan2008-soft.2.34",
+    "mips-linux-gnu-nan2008-soft.2.35",
+    "mips-linux-gnu-nan2008-soft.2.36",
+    "mips-linux-gnu-nan2008-soft.2.37",
+    "mips-linux-gnu-nan2008-soft.2.38",
+    "mips-linux-gnu-soft.2.32",
+    "mips-linux-gnu-soft.2.33",
+    "mips-linux-gnu-soft.2.34",
+    "mips-linux-gnu-soft.2.35",
+    "mips-linux-gnu-soft.2.36",
+    "mips-linux-gnu-soft.2.37",
+    "mips-linux-gnu-soft.2.38",
+    "(defined __MIPS__ AND defined __GLIBC__)", // FIXME
+},
+
+powerpc64_linux_gnu: []const []const u8 = &[_][]const u8{
+    "powerpc64le-linux-gnu.2.32",
+    "powerpc64le-linux-gnu.2.33",
+    "powerpc64le-linux-gnu.2.34",
+    "powerpc64le-linux-gnu.2.35",
+    "powerpc64le-linux-gnu.2.36",
+    "powerpc64le-linux-gnu.2.37",
+    "powerpc64le-linux-gnu.2.38",
+    "powerpc64-linux-gnu.2.32",
+    "powerpc64-linux-gnu.2.33",
+    "powerpc64-linux-gnu.2.34",
+    "powerpc64-linux-gnu.2.35",
+    "powerpc64-linux-gnu.2.36",
+    "powerpc64-linux-gnu.2.37",
+    "powerpc64-linux-gnu.2.38",
+    "(defined __PPC64__ AND defined __GLIBC__)", // FIXME
+},
+
+powerpc_linux_gnu: []const []const u8 = &[_][]const u8{
+    "powerpc-linux-gnu.2.32",
+    "powerpc-linux-gnu.2.33",
+    "powerpc-linux-gnu.2.34",
+    "powerpc-linux-gnu.2.35",
+    "powerpc-linux-gnu.2.36",
+    "powerpc-linux-gnu.2.37",
+    "powerpc-linux-gnu.2.38",
+    "powerpc-linux-gnu-power4.2.32",
+    "powerpc-linux-gnu-power4.2.33",
+    "powerpc-linux-gnu-power4.2.34",
+    "powerpc-linux-gnu-power4.2.35",
+    "powerpc-linux-gnu-power4.2.36",
+    "powerpc-linux-gnu-power4.2.37",
+    "powerpc-linux-gnu-power4.2.38",
+    "powerpc-linux-gnu-soft.2.32",
+    "powerpc-linux-gnu-soft.2.33",
+    "powerpc-linux-gnu-soft.2.34",
+    "powerpc-linux-gnu-soft.2.35",
+    "powerpc-linux-gnu-soft.2.36",
+    "powerpc-linux-gnu-soft.2.37",
+    "powerpc-linux-gnu-soft.2.38",
+    "(defined __PPC__ AND defined __GLIBC__)", // FIXME
+},
+
+riscv32_linux_gnu: []const []const u8 = &[_][]const u8{
+    "riscv32-linux-gnu-rv32imac-ilp32.2.33",
+    "riscv32-linux-gnu-rv32imac-ilp32.2.34",
+    "riscv32-linux-gnu-rv32imac-ilp32.2.35",
+    "riscv32-linux-gnu-rv32imac-ilp32.2.36",
+    "riscv32-linux-gnu-rv32imac-ilp32.2.37",
+    "riscv32-linux-gnu-rv32imac-ilp32.2.38",
+    "riscv32-linux-gnu-rv32imafdc-ilp32.2.33",
+    "riscv32-linux-gnu-rv32imafdc-ilp32.2.34",
+    "riscv32-linux-gnu-rv32imafdc-ilp32.2.35",
+    "riscv32-linux-gnu-rv32imafdc-ilp32.2.36",
+    "riscv32-linux-gnu-rv32imafdc-ilp32.2.37",
+    "riscv32-linux-gnu-rv32imafdc-ilp32.2.38",
+    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.33",
+    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.34",
+    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.35",
+    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.36",
+    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.37",
+    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.38",
+    "(defined __RISCV32__ AND defined __GLIBC__)", // FIXME
+},
+
+riscv64_linux_gnu: []const []const u8 = &[_][]const u8{
+    "riscv64-linux-gnu-rv64imac-lp64.2.32",
+    "riscv64-linux-gnu-rv64imac-lp64.2.33",
+    "riscv64-linux-gnu-rv64imac-lp64.2.34",
+    "riscv64-linux-gnu-rv64imac-lp64.2.35",
+    "riscv64-linux-gnu-rv64imac-lp64.2.36",
+    "riscv64-linux-gnu-rv64imac-lp64.2.37",
+    "riscv64-linux-gnu-rv64imac-lp64.2.38",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.32",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.33",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.34",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.35",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.36",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.37",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.38",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.32",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.33",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.34",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.35",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.36",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.37",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.38",
+    "(defined __RISCV64__ AND defined __GLIBC__)", // FIXME
+},
+
+s390x_linux_gnu: []const []const u8 = &[_][]const u8{
+    "s390x-linux-gnu.2.32",
+    "s390x-linux-gnu.2.33",
+    "s390x-linux-gnu.2.34",
+    "s390x-linux-gnu.2.35",
+    "s390x-linux-gnu.2.36",
+    "s390x-linux-gnu.2.37",
+    "s390x-linux-gnu.2.38",
+    "(defined __S390X__ AND defined __GLIBC__)", // FIXME
+},
+
+sparc64_linux_gnu: []const []const u8 = &[_][]const u8{
+    "sparc64-linux-gnu.2.32",
+    "sparc64-linux-gnu.2.33",
+    "sparc64-linux-gnu.2.34",
+    "sparc64-linux-gnu.2.35",
+    "sparc64-linux-gnu.2.36",
+    "sparc64-linux-gnu.2.37",
+    "sparc64-linux-gnu.2.38",
+    "(defined __SPARC64__ AND defined __GLIBC__)", // FIXME
+},
+
+sparcv8_linux_gnu: []const []const u8 = &[_][]const u8{
+    "sparcv8-linux-gnu-leon3.2.32",
+    "sparcv8-linux-gnu-leon3.2.33",
+    "sparcv8-linux-gnu-leon3.2.34",
+    "sparcv8-linux-gnu-leon3.2.35",
+    "sparcv8-linux-gnu-leon3.2.36",
+    "sparcv8-linux-gnu-leon3.2.37",
+    "sparcv8-linux-gnu-leon3.2.38",
+    "(defined __SPARCV8__ AND defined __GLIBC__)", // FIXME
+},
+
+sparcv9_linux_gnu: []const []const u8 = &[_][]const u8{
+    "sparcv9-linux-gnu.2.32",
+    "sparcv9-linux-gnu.2.33",
+    "sparcv9-linux-gnu.2.34",
+    "sparcv9-linux-gnu.2.35",
+    "sparcv9-linux-gnu.2.36",
+    "sparcv9-linux-gnu.2.37",
+    "sparcv9-linux-gnu.2.38",
+    "(defined __SPARCV9__ AND defined __GLIBC__)", // FIXME
+},
+
+x86_64_linux_gnu: []const []const u8 = &[_][]const u8{
+    "x86_64-linux-gnu.2.32",
+    "x86_64-linux-gnu.2.33",
+    "x86_64-linux-gnu.2.34",
+    "x86_64-linux-gnu.2.35",
+    "x86_64-linux-gnu.2.36",
+    "x86_64-linux-gnu.2.37",
+    "x86_64-linux-gnu.2.38",
+    "x86_64-linux-gnu-x32.2.32",
+    "x86_64-linux-gnu-x32.2.33",
+    "x86_64-linux-gnu-x32.2.34",
+    "x86_64-linux-gnu-x32.2.35",
+    "x86_64-linux-gnu-x32.2.36",
+    "x86_64-linux-gnu-x32.2.37",
+    "x86_64-linux-gnu-x32.2.38",
+    "(defined __X86_64__ AND defined __GLIBC__)", // FIXME
+},
+
+freebsd_gnu: []const []const u8 = &[_][]const u8{
+    "aarch64-freebsd.12.3-gnu",
+    "aarch64-freebsd.13.1-gnu",
+    "powerpc64-freebsd.12.3-gnu",
+    "powerpc64-freebsd.13.1-gnu",
+    "powerpc64le-freebsd.13.1-gnu",
+    "powerpc-freebsd.12.3-gnu",
+    "powerpc-freebsd.13.1-gnu",
+    "riscv64-freebsd.13.1-gnu",
+    "sparc64-freebsd.12.3-gnu",
+    "x86_64-freebsd.12.3-gnu",
+    "x86_64-freebsd.13.1-gnu",
+    "x86-freebsd.12.3-gnu",
+    "x86-freebsd.13.1-gnu",
+    "(defined __FreeBSD__ AND defined __GLIBC__)", // FIXME
+},
+
+freebsd_12_3: []const []const u8 = &[_][]const u8{
+    "aarch64-freebsd.12.3-gnu",
+    "powerpc64-freebsd.12.3-gnu",
+    "powerpc-freebsd.12.3-gnu",
+    "sparc64-freebsd.12.3-gnu",
+    "x86_64-freebsd.12.3-gnu",
+    "x86-freebsd.12.3-gnu",
+    "(__FreeBSD__ > 1203500 AND __FreeBSD__ < 1204000)",
+},
+
+freebsd_13_1: []const []const u8 = &[_][]const u8{
+    "aarch64-freebsd.13.1-gnu",
+    "powerpc64-freebsd.13.1-gnu",
+    "powerpc64le-freebsd.13.1-gnu",
+    "powerpc-freebsd.13.1-gnu",
+    "riscv64-freebsd.13.1-gnu",
+    "x86_64-freebsd.13.1-gnu",
+    "x86-freebsd.13.1-gnu",
+    "(__FreeBSD__ > 1301000 AND __FreeBSD__ < 1302000)",
+},
+
+macos: []const []const u8 = &[_][]const u8{
+    "aarch64-macos.11-none",
+    "aarch64-macos.12-none",
+    "aarch64-macos.13-none",
+    "x86_64-macos.11-none",
+    "x86_64-macos.12-none",
+    "x86_64-macos.13-none",
+    "defined __MACOS__", // FIXME
+},
+
+musl: []const []const u8 = &[_][]const u8{
+    "aarch64-linux-musl",
+    "arm-linux-musl",
+    "i386-linux-musl",
+    "mips64-linux-musl",
+    "mips-linux-musl",
+    "powerpc64-linux-musl",
+    "powerpc-linux-musl",
+    "riscv64-linux-musl",
+    "x86_64-linux-musl",
+    "defined __MUSL__", // FIXME
+},
+
+gnu_2_32: []const []const u8 = &[_][]const u8{
+    "aarch64_be-linux-gnu.2.32",
+    "aarch64-linux-gnu.2.32",
+    "arc-linux-gnu.2.32",
+    "arc-linux-gnuhf.2.32",
+    "armeb-linux-gnueabi.2.32",
+    "armeb-linux-gnueabihf.2.32",
+    "arm-linux-gnueabi.2.32",
+    "arm-linux-gnueabihf.2.32",
+    "arm-linux-gnueabihf-v7a.2.32",
+    "arm-linux-gnueabi-v4t.2.32",
+    "i486-linux-gnu.2.32",
+    "i586-linux-gnu.2.32",
+    "i686-linux-gnu.2.32",
+    "ia64-linux-gnu.2.32",
+    "m68k-linux-gnu.2.32",
+    "mips64el-linux-gnu-n32.2.32",
+    "mips64el-linux-gnu-n32-nan2008.2.32",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.32",
+    "mips64el-linux-gnu-n32-soft.2.32",
+    "mips64el-linux-gnu-n64.2.32",
+    "mips64el-linux-gnu-n64-nan2008.2.32",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.32",
+    "mips64el-linux-gnu-n64-soft.2.32",
+    "mips64-linux-gnu-n32.2.32",
+    "mips64-linux-gnu-n32-nan2008.2.32",
+    "mips64-linux-gnu-n32-nan2008-soft.2.32",
+    "mips64-linux-gnu-n32-soft.2.32",
+    "mips64-linux-gnu-n64.2.32",
+    "mips64-linux-gnu-n64-nan2008.2.32",
+    "mips64-linux-gnu-n64-nan2008-soft.2.32",
+    "mips64-linux-gnu-n64-soft.2.32",
+    "mipsel-linux-gnu.2.32",
+    "mipsel-linux-gnu-nan2008.2.32",
+    "mipsel-linux-gnu-nan2008-soft.2.32",
+    "mipsel-linux-gnu-soft.2.32",
+    "mipsisa32r6el-linux-gnu.2.32",
+    "mipsisa64r6el-linux-gnu-n32.2.32",
+    "mipsisa64r6el-linux-gnu-n64.2.32",
+    "mips-linux-gnu.2.32",
+    "mips-linux-gnu-nan2008.2.32",
+    "mips-linux-gnu-nan2008-soft.2.32",
+    "mips-linux-gnu-soft.2.32",
+    "powerpc64le-linux-gnu.2.32",
+    "powerpc64-linux-gnu.2.32",
+    "powerpc-linux-gnu.2.32",
+    "powerpc-linux-gnu-power4.2.32",
+    "powerpc-linux-gnu-soft.2.32",
+    "riscv64-linux-gnu-rv64imac-lp64.2.32",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.32",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.32",
+    "s390x-linux-gnu.2.32",
+    "sparc64-linux-gnu.2.32",
+    "sparcv8-linux-gnu-leon3.2.32",
+    "sparcv9-linux-gnu.2.32",
+    "x86_64-linux-gnu.2.32",
+    "x86_64-linux-gnu-x32.2.32",
+    "__GLIBC_MINOR__ == 32",
+},
+
+gnu_2_33: []const []const u8 = &[_][]const u8{
+    "aarch64_be-linux-gnu.2.33",
+    "aarch64-linux-gnu.2.33",
+    "arc-linux-gnu.2.33",
+    "arc-linux-gnuhf.2.33",
+    "armeb-linux-gnueabi.2.33",
+    "armeb-linux-gnueabihf.2.33",
+    "arm-linux-gnueabi.2.33",
+    "arm-linux-gnueabihf.2.33",
+    "arm-linux-gnueabihf-v7a.2.33",
+    "arm-linux-gnueabi-v4t.2.33",
+    "csky-linux-gnuabiv2.2.33",
+    "csky-linux-gnuabiv2-soft.2.33",
+    "i486-linux-gnu.2.33",
+    "i586-linux-gnu.2.33",
+    "i686-linux-gnu.2.33",
+    "ia64-linux-gnu.2.33",
+    "m68k-linux-gnu.2.33",
+    "mips64el-linux-gnu-n32.2.33",
+    "mips64el-linux-gnu-n32-nan2008.2.33",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.33",
+    "mips64el-linux-gnu-n32-soft.2.33",
+    "mips64el-linux-gnu-n64.2.33",
+    "mips64el-linux-gnu-n64-nan2008.2.33",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.33",
+    "mips64el-linux-gnu-n64-soft.2.33",
+    "mips64-linux-gnu-n32.2.33",
+    "mips64-linux-gnu-n32-nan2008.2.33",
+    "mips64-linux-gnu-n32-nan2008-soft.2.33",
+    "mips64-linux-gnu-n32-soft.2.33",
+    "mips64-linux-gnu-n64.2.33",
+    "mips64-linux-gnu-n64-nan2008.2.33",
+    "mips64-linux-gnu-n64-nan2008-soft.2.33",
+    "mips64-linux-gnu-n64-soft.2.33",
+    "mipsel-linux-gnu.2.33",
+    "mipsel-linux-gnu-nan2008.2.33",
+    "mipsel-linux-gnu-nan2008-soft.2.33",
+    "mipsel-linux-gnu-soft.2.33",
+    "mipsisa32r6el-linux-gnu.2.33",
+    "mipsisa64r6el-linux-gnu-n32.2.33",
+    "mipsisa64r6el-linux-gnu-n64.2.33",
+    "mips-linux-gnu.2.33",
+    "mips-linux-gnu-nan2008.2.33",
+    "mips-linux-gnu-nan2008-soft.2.33",
+    "mips-linux-gnu-soft.2.33",
+    "powerpc64le-linux-gnu.2.33",
+    "powerpc64-linux-gnu.2.33",
+    "powerpc-linux-gnu.2.33",
+    "powerpc-linux-gnu-power4.2.33",
+    "powerpc-linux-gnu-soft.2.33",
+    "riscv32-linux-gnu-rv32imac-ilp32.2.33",
+    "riscv32-linux-gnu-rv32imafdc-ilp32.2.33",
+    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.33",
+    "riscv64-linux-gnu-rv64imac-lp64.2.33",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.33",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.33",
+    "s390x-linux-gnu.2.33",
+    "sparc64-linux-gnu.2.33",
+    "sparcv8-linux-gnu-leon3.2.33",
+    "sparcv9-linux-gnu.2.33",
+    "x86_64-linux-gnu.2.33",
+    "x86_64-linux-gnu-x32.2.33",
+    "__GLIBC_MINOR__ == 33",
+},
+
+gnu_2_34: []const []const u8 = &[_][]const u8{
+    "aarch64_be-linux-gnu.2.34",
+    "aarch64-linux-gnu.2.34",
+    "arc-linux-gnu.2.34",
+    "arc-linux-gnuhf.2.34",
+    "armeb-linux-gnueabi.2.34",
+    "armeb-linux-gnueabihf.2.34",
+    "arm-linux-gnueabi.2.34",
+    "arm-linux-gnueabihf.2.34",
+    "arm-linux-gnueabihf-v7a.2.34",
+    "arm-linux-gnueabi-v4t.2.34",
+    "csky-linux-gnuabiv2.2.34",
+    "csky-linux-gnuabiv2-soft.2.34",
+    "i486-linux-gnu.2.34",
+    "i586-linux-gnu.2.34",
+    "i686-linux-gnu.2.34",
+    "ia64-linux-gnu.2.34",
+    "m68k-linux-gnu.2.34",
+    "mips64el-linux-gnu-n32.2.34",
+    "mips64el-linux-gnu-n32-nan2008.2.34",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.34",
+    "mips64el-linux-gnu-n32-soft.2.34",
+    "mips64el-linux-gnu-n64.2.34",
+    "mips64el-linux-gnu-n64-nan2008.2.34",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.34",
+    "mips64el-linux-gnu-n64-soft.2.34",
+    "mips64-linux-gnu-n32.2.34",
+    "mips64-linux-gnu-n32-nan2008.2.34",
+    "mips64-linux-gnu-n32-nan2008-soft.2.34",
+    "mips64-linux-gnu-n32-soft.2.34",
+    "mips64-linux-gnu-n64.2.34",
+    "mips64-linux-gnu-n64-nan2008.2.34",
+    "mips64-linux-gnu-n64-nan2008-soft.2.34",
+    "mips64-linux-gnu-n64-soft.2.34",
+    "mipsel-linux-gnu.2.34",
+    "mipsel-linux-gnu-nan2008.2.34",
+    "mipsel-linux-gnu-nan2008-soft.2.34",
+    "mipsel-linux-gnu-soft.2.34",
+    "mipsisa32r6el-linux-gnu.2.34",
+    "mipsisa64r6el-linux-gnu-n32.2.34",
+    "mipsisa64r6el-linux-gnu-n64.2.34",
+    "mips-linux-gnu.2.34",
+    "mips-linux-gnu-nan2008.2.34",
+    "mips-linux-gnu-nan2008-soft.2.34",
+    "mips-linux-gnu-soft.2.34",
+    "powerpc64le-linux-gnu.2.34",
+    "powerpc64-linux-gnu.2.34",
+    "powerpc-linux-gnu.2.34",
+    "powerpc-linux-gnu-power4.2.34",
+    "powerpc-linux-gnu-soft.2.34",
+    "riscv32-linux-gnu-rv32imac-ilp32.2.34",
+    "riscv32-linux-gnu-rv32imafdc-ilp32.2.34",
+    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.34",
+    "riscv64-linux-gnu-rv64imac-lp64.2.34",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.34",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.34",
+    "s390x-linux-gnu.2.34",
+    "sparc64-linux-gnu.2.34",
+    "sparcv8-linux-gnu-leon3.2.34",
+    "sparcv9-linux-gnu.2.34",
+    "x86_64-linux-gnu.2.34",
+    "x86_64-linux-gnu-x32.2.34",
+    "__GLIBC_MINOR__ == 34",
+},
+
+gnu_2_35: []const []const u8 = &[_][]const u8{
+    "aarch64_be-linux-gnu.2.35",
+    "aarch64-linux-gnu.2.35",
+    "arc-linux-gnu.2.35",
+    "arc-linux-gnuhf.2.35",
+    "armeb-linux-gnueabi.2.35",
+    "armeb-linux-gnueabihf.2.35",
+    "arm-linux-gnueabi.2.35",
+    "arm-linux-gnueabihf.2.35",
+    "arm-linux-gnueabihf-v7a.2.35",
+    "arm-linux-gnueabi-v4t.2.35",
+    "csky-linux-gnuabiv2.2.35",
+    "csky-linux-gnuabiv2-soft.2.35",
+    "i486-linux-gnu.2.35",
+    "i586-linux-gnu.2.35",
+    "i686-linux-gnu.2.35",
+    "ia64-linux-gnu.2.35",
+    "m68k-linux-gnu.2.35",
+    "mips64el-linux-gnu-n32.2.35",
+    "mips64el-linux-gnu-n32-nan2008.2.35",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.35",
+    "mips64el-linux-gnu-n32-soft.2.35",
+    "mips64el-linux-gnu-n64.2.35",
+    "mips64el-linux-gnu-n64-nan2008.2.35",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.35",
+    "mips64el-linux-gnu-n64-soft.2.35",
+    "mips64-linux-gnu-n32.2.35",
+    "mips64-linux-gnu-n32-nan2008.2.35",
+    "mips64-linux-gnu-n32-nan2008-soft.2.35",
+    "mips64-linux-gnu-n32-soft.2.35",
+    "mips64-linux-gnu-n64.2.35",
+    "mips64-linux-gnu-n64-nan2008.2.35",
+    "mips64-linux-gnu-n64-nan2008-soft.2.35",
+    "mips64-linux-gnu-n64-soft.2.35",
+    "mipsel-linux-gnu.2.35",
+    "mipsel-linux-gnu-nan2008.2.35",
+    "mipsel-linux-gnu-nan2008-soft.2.35",
+    "mipsel-linux-gnu-soft.2.35",
+    "mipsisa32r6el-linux-gnu.2.35",
+    "mipsisa64r6el-linux-gnu-n32.2.35",
+    "mipsisa64r6el-linux-gnu-n64.2.35",
+    "mips-linux-gnu.2.35",
+    "mips-linux-gnu-nan2008.2.35",
+    "mips-linux-gnu-nan2008-soft.2.35",
+    "mips-linux-gnu-soft.2.35",
+    "powerpc64le-linux-gnu.2.35",
+    "powerpc64-linux-gnu.2.35",
+    "powerpc-linux-gnu.2.35",
+    "powerpc-linux-gnu-power4.2.35",
+    "powerpc-linux-gnu-soft.2.35",
+    "riscv32-linux-gnu-rv32imac-ilp32.2.35",
+    "riscv32-linux-gnu-rv32imafdc-ilp32.2.35",
+    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.35",
+    "riscv64-linux-gnu-rv64imac-lp64.2.35",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.35",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.35",
+    "s390x-linux-gnu.2.35",
+    "sparc64-linux-gnu.2.35",
+    "sparcv8-linux-gnu-leon3.2.35",
+    "sparcv9-linux-gnu.2.35",
+    "x86_64-linux-gnu.2.35",
+    "x86_64-linux-gnu-x32.2.35",
+    "__GLIBC_MINOR__ == 35",
+},
+
+gnu_2_36: []const []const u8 = &[_][]const u8{
+    "aarch64_be-linux-gnu.2.36",
+    "aarch64-linux-gnu.2.36",
+    "arc-linux-gnu.2.36",
+    "arc-linux-gnuhf.2.36",
+    "armeb-linux-gnueabi.2.36",
+    "armeb-linux-gnueabihf.2.36",
+    "arm-linux-gnueabi.2.36",
+    "arm-linux-gnueabihf.2.36",
+    "arm-linux-gnueabihf-v7a.2.36",
+    "arm-linux-gnueabi-v4t.2.36",
+    "csky-linux-gnuabiv2.2.36",
+    "csky-linux-gnuabiv2-soft.2.36",
+    "i486-linux-gnu.2.36",
+    "i586-linux-gnu.2.36",
+    "i686-linux-gnu.2.36",
+    "ia64-linux-gnu.2.36",
+    "m68k-linux-gnu.2.36",
+    "mips64el-linux-gnu-n32.2.36",
+    "mips64el-linux-gnu-n32-nan2008.2.36",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.36",
+    "mips64el-linux-gnu-n32-soft.2.36",
+    "mips64el-linux-gnu-n64.2.36",
+    "mips64el-linux-gnu-n64-nan2008.2.36",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.36",
+    "mips64el-linux-gnu-n64-soft.2.36",
+    "mips64-linux-gnu-n32.2.36",
+    "mips64-linux-gnu-n32-nan2008.2.36",
+    "mips64-linux-gnu-n32-nan2008-soft.2.36",
+    "mips64-linux-gnu-n32-soft.2.36",
+    "mips64-linux-gnu-n64.2.36",
+    "mips64-linux-gnu-n64-nan2008.2.36",
+    "mips64-linux-gnu-n64-nan2008-soft.2.36",
+    "mips64-linux-gnu-n64-soft.2.36",
+    "mipsel-linux-gnu.2.36",
+    "mipsel-linux-gnu-nan2008.2.36",
+    "mipsel-linux-gnu-nan2008-soft.2.36",
+    "mipsel-linux-gnu-soft.2.36",
+    "mipsisa32r6el-linux-gnu.2.36",
+    "mipsisa64r6el-linux-gnu-n32.2.36",
+    "mipsisa64r6el-linux-gnu-n64.2.36",
+    "mips-linux-gnu.2.36",
+    "mips-linux-gnu-nan2008.2.36",
+    "mips-linux-gnu-nan2008-soft.2.36",
+    "mips-linux-gnu-soft.2.36",
+    "powerpc64le-linux-gnu.2.36",
+    "powerpc64-linux-gnu.2.36",
+    "powerpc-linux-gnu.2.36",
+    "powerpc-linux-gnu-power4.2.36",
+    "powerpc-linux-gnu-soft.2.36",
+    "riscv32-linux-gnu-rv32imac-ilp32.2.36",
+    "riscv32-linux-gnu-rv32imafdc-ilp32.2.36",
+    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.36",
+    "riscv64-linux-gnu-rv64imac-lp64.2.36",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.36",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.36",
+    "s390x-linux-gnu.2.36",
+    "sparc64-linux-gnu.2.36",
+    "sparcv8-linux-gnu-leon3.2.36",
+    "sparcv9-linux-gnu.2.36",
+    "x86_64-linux-gnu.2.36",
+    "x86_64-linux-gnu-x32.2.36",
+    "__GLIBC_MINOR__ == 36",
+},
+
+gnu_2_37: []const []const u8 = &[_][]const u8{
+    "aarch64_be-linux-gnu.2.37",
+    "aarch64-linux-gnu.2.37",
+    "arc-linux-gnu.2.37",
+    "arc-linux-gnuhf.2.37",
+    "armeb-linux-gnueabi.2.37",
+    "armeb-linux-gnueabihf.2.37",
+    "arm-linux-gnueabi.2.37",
+    "arm-linux-gnueabihf.2.37",
+    "arm-linux-gnueabihf-v7a.2.37",
+    "arm-linux-gnueabi-v4t.2.37",
+    "csky-linux-gnuabiv2.2.37",
+    "csky-linux-gnuabiv2-soft.2.37",
+    "i486-linux-gnu.2.37",
+    "i586-linux-gnu.2.37",
+    "i686-linux-gnu.2.37",
+    "ia64-linux-gnu.2.37",
+    "m68k-linux-gnu.2.37",
+    "mips64el-linux-gnu-n32.2.37",
+    "mips64el-linux-gnu-n32-nan2008.2.37",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.37",
+    "mips64el-linux-gnu-n32-soft.2.37",
+    "mips64el-linux-gnu-n64.2.37",
+    "mips64el-linux-gnu-n64-nan2008.2.37",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.37",
+    "mips64el-linux-gnu-n64-soft.2.37",
+    "mips64-linux-gnu-n32.2.37",
+    "mips64-linux-gnu-n32-nan2008.2.37",
+    "mips64-linux-gnu-n32-nan2008-soft.2.37",
+    "mips64-linux-gnu-n32-soft.2.37",
+    "mips64-linux-gnu-n64.2.37",
+    "mips64-linux-gnu-n64-nan2008.2.37",
+    "mips64-linux-gnu-n64-nan2008-soft.2.37",
+    "mips64-linux-gnu-n64-soft.2.37",
+    "mipsel-linux-gnu.2.37",
+    "mipsel-linux-gnu-nan2008.2.37",
+    "mipsel-linux-gnu-nan2008-soft.2.37",
+    "mipsel-linux-gnu-soft.2.37",
+    "mipsisa32r6el-linux-gnu.2.37",
+    "mipsisa64r6el-linux-gnu-n32.2.37",
+    "mipsisa64r6el-linux-gnu-n64.2.37",
+    "mips-linux-gnu.2.37",
+    "mips-linux-gnu-nan2008.2.37",
+    "mips-linux-gnu-nan2008-soft.2.37",
+    "mips-linux-gnu-soft.2.37",
+    "powerpc64le-linux-gnu.2.37",
+    "powerpc64-linux-gnu.2.37",
+    "powerpc-linux-gnu.2.37",
+    "powerpc-linux-gnu-power4.2.37",
+    "powerpc-linux-gnu-soft.2.37",
+    "riscv32-linux-gnu-rv32imac-ilp32.2.37",
+    "riscv32-linux-gnu-rv32imafdc-ilp32.2.37",
+    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.37",
+    "riscv64-linux-gnu-rv64imac-lp64.2.37",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.37",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.37",
+    "s390x-linux-gnu.2.37",
+    "sparc64-linux-gnu.2.37",
+    "sparcv8-linux-gnu-leon3.2.37",
+    "sparcv9-linux-gnu.2.37",
+    "x86_64-linux-gnu.2.37",
+    "x86_64-linux-gnu-x32.2.37",
+    "__GLIBC_MINOR__ == 37",
+},
+
+gnu_2_38: []const []const u8 = &[_][]const u8{
+    "aarch64_be-linux-gnu.2.38",
+    "aarch64-linux-gnu.2.38",
+    "arc-linux-gnu.2.38",
+    "arc-linux-gnuhf.2.38",
+    "armeb-linux-gnueabi.2.38",
+    "armeb-linux-gnueabihf.2.38",
+    "arm-linux-gnueabi.2.38",
+    "arm-linux-gnueabihf.2.38",
+    "arm-linux-gnueabihf-v7a.2.38",
+    "arm-linux-gnueabi-v4t.2.38",
+    "csky-linux-gnuabiv2.2.38",
+    "csky-linux-gnuabiv2-soft.2.38",
+    "i486-linux-gnu.2.38",
+    "i586-linux-gnu.2.38",
+    "i686-linux-gnu.2.38",
+    "ia64-linux-gnu.2.38",
+    "m68k-linux-gnu.2.38",
+    "mips64el-linux-gnu-n32.2.38",
+    "mips64el-linux-gnu-n32-nan2008.2.38",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.38",
+    "mips64el-linux-gnu-n32-soft.2.38",
+    "mips64el-linux-gnu-n64.2.38",
+    "mips64el-linux-gnu-n64-nan2008.2.38",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.38",
+    "mips64el-linux-gnu-n64-soft.2.38",
+    "mips64-linux-gnu-n32.2.38",
+    "mips64-linux-gnu-n32-nan2008.2.38",
+    "mips64-linux-gnu-n32-nan2008-soft.2.38",
+    "mips64-linux-gnu-n32-soft.2.38",
+    "mips64-linux-gnu-n64.2.38",
+    "mips64-linux-gnu-n64-nan2008.2.38",
+    "mips64-linux-gnu-n64-nan2008-soft.2.38",
+    "mips64-linux-gnu-n64-soft.2.38",
+    "mipsel-linux-gnu.2.38",
+    "mipsel-linux-gnu-nan2008.2.38",
+    "mipsel-linux-gnu-nan2008-soft.2.38",
+    "mipsel-linux-gnu-soft.2.38",
+    "mipsisa32r6el-linux-gnu.2.38",
+    "mipsisa64r6el-linux-gnu-n32.2.38",
+    "mipsisa64r6el-linux-gnu-n64.2.38",
+    "mips-linux-gnu.2.38",
+    "mips-linux-gnu-nan2008.2.38",
+    "mips-linux-gnu-nan2008-soft.2.38",
+    "mips-linux-gnu-soft.2.38",
+    "powerpc64le-linux-gnu.2.38",
+    "powerpc64-linux-gnu.2.38",
+    "powerpc-linux-gnu.2.38",
+    "powerpc-linux-gnu-power4.2.38",
+    "powerpc-linux-gnu-soft.2.38",
+    "riscv32-linux-gnu-rv32imac-ilp32.2.38",
+    "riscv32-linux-gnu-rv32imafdc-ilp32.2.38",
+    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.38",
+    "riscv64-linux-gnu-rv64imac-lp64.2.38",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.38",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.38",
+    "s390x-linux-gnu.2.38",
+    "sparc64-linux-gnu.2.38",
+    "sparcv8-linux-gnu-leon3.2.38",
+    "sparcv9-linux-gnu.2.38",
+    "x86_64-linux-gnu.2.38",
+    "x86_64-linux-gnu-x32.2.38",
+    "__GLIBC_MINOR__ == 38",
+},
+
+gnu_not_2_32: []const []const u8 = &[_][]const u8{
+    "aarch64_be-linux-gnu.2.33",
+    "aarch64_be-linux-gnu.2.34",
+    "aarch64_be-linux-gnu.2.35",
+    "aarch64_be-linux-gnu.2.36",
+    "aarch64_be-linux-gnu.2.37",
+    "aarch64_be-linux-gnu.2.38",
+    "aarch64-linux-gnu.2.33",
+    "aarch64-linux-gnu.2.34",
+    "aarch64-linux-gnu.2.35",
+    "aarch64-linux-gnu.2.36",
+    "aarch64-linux-gnu.2.37",
+    "aarch64-linux-gnu.2.38",
+    "arc-linux-gnu.2.33",
+    "arc-linux-gnu.2.34",
+    "arc-linux-gnu.2.35",
+    "arc-linux-gnu.2.36",
+    "arc-linux-gnu.2.37",
+    "arc-linux-gnu.2.38",
+    "arc-linux-gnuhf.2.33",
+    "arc-linux-gnuhf.2.34",
+    "arc-linux-gnuhf.2.35",
+    "arc-linux-gnuhf.2.36",
+    "arc-linux-gnuhf.2.37",
+    "arc-linux-gnuhf.2.38",
+    "armeb-linux-gnueabi.2.33",
+    "armeb-linux-gnueabi.2.34",
+    "armeb-linux-gnueabi.2.35",
+    "armeb-linux-gnueabi.2.36",
+    "armeb-linux-gnueabi.2.37",
+    "armeb-linux-gnueabi.2.38",
+    "armeb-linux-gnueabihf.2.33",
+    "armeb-linux-gnueabihf.2.34",
+    "armeb-linux-gnueabihf.2.35",
+    "armeb-linux-gnueabihf.2.36",
+    "armeb-linux-gnueabihf.2.37",
+    "armeb-linux-gnueabihf.2.38",
+    "arm-linux-gnueabi.2.33",
+    "arm-linux-gnueabi.2.34",
+    "arm-linux-gnueabi.2.35",
+    "arm-linux-gnueabi.2.36",
+    "arm-linux-gnueabi.2.37",
+    "arm-linux-gnueabi.2.38",
+    "arm-linux-gnueabihf.2.33",
+    "arm-linux-gnueabihf.2.34",
+    "arm-linux-gnueabihf.2.35",
+    "arm-linux-gnueabihf.2.36",
+    "arm-linux-gnueabihf.2.37",
+    "arm-linux-gnueabihf.2.38",
+    "arm-linux-gnueabihf-v7a.2.33",
+    "arm-linux-gnueabihf-v7a.2.34",
+    "arm-linux-gnueabihf-v7a.2.35",
+    "arm-linux-gnueabihf-v7a.2.36",
+    "arm-linux-gnueabihf-v7a.2.37",
+    "arm-linux-gnueabihf-v7a.2.38",
+    "arm-linux-gnueabi-v4t.2.33",
+    "arm-linux-gnueabi-v4t.2.34",
+    "arm-linux-gnueabi-v4t.2.35",
+    "arm-linux-gnueabi-v4t.2.36",
+    "arm-linux-gnueabi-v4t.2.37",
+    "arm-linux-gnueabi-v4t.2.38",
+    "i486-linux-gnu.2.33",
+    "i486-linux-gnu.2.34",
+    "i486-linux-gnu.2.35",
+    "i486-linux-gnu.2.36",
+    "i486-linux-gnu.2.37",
+    "i486-linux-gnu.2.38",
+    "i586-linux-gnu.2.33",
+    "i586-linux-gnu.2.34",
+    "i586-linux-gnu.2.35",
+    "i586-linux-gnu.2.36",
+    "i586-linux-gnu.2.37",
+    "i586-linux-gnu.2.38",
+    "i686-linux-gnu.2.33",
+    "i686-linux-gnu.2.34",
+    "i686-linux-gnu.2.35",
+    "i686-linux-gnu.2.36",
+    "i686-linux-gnu.2.37",
+    "i686-linux-gnu.2.38",
+    "ia64-linux-gnu.2.33",
+    "ia64-linux-gnu.2.34",
+    "ia64-linux-gnu.2.35",
+    "ia64-linux-gnu.2.36",
+    "ia64-linux-gnu.2.37",
+    "ia64-linux-gnu.2.38",
+    "m68k-linux-gnu.2.33",
+    "m68k-linux-gnu.2.34",
+    "m68k-linux-gnu.2.35",
+    "m68k-linux-gnu.2.36",
+    "m68k-linux-gnu.2.37",
+    "m68k-linux-gnu.2.38",
+    "mips64el-linux-gnu-n32.2.33",
+    "mips64el-linux-gnu-n32.2.34",
+    "mips64el-linux-gnu-n32.2.35",
+    "mips64el-linux-gnu-n32.2.36",
+    "mips64el-linux-gnu-n32.2.37",
+    "mips64el-linux-gnu-n32.2.38",
+    "mips64el-linux-gnu-n32-nan2008.2.33",
+    "mips64el-linux-gnu-n32-nan2008.2.34",
+    "mips64el-linux-gnu-n32-nan2008.2.35",
+    "mips64el-linux-gnu-n32-nan2008.2.36",
+    "mips64el-linux-gnu-n32-nan2008.2.37",
+    "mips64el-linux-gnu-n32-nan2008.2.38",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.33",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.34",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.35",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.36",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.37",
+    "mips64el-linux-gnu-n32-nan2008-soft.2.38",
+    "mips64el-linux-gnu-n32-soft.2.33",
+    "mips64el-linux-gnu-n32-soft.2.34",
+    "mips64el-linux-gnu-n32-soft.2.35",
+    "mips64el-linux-gnu-n32-soft.2.36",
+    "mips64el-linux-gnu-n32-soft.2.37",
+    "mips64el-linux-gnu-n32-soft.2.38",
+    "mips64el-linux-gnu-n64.2.33",
+    "mips64el-linux-gnu-n64.2.34",
+    "mips64el-linux-gnu-n64.2.35",
+    "mips64el-linux-gnu-n64.2.36",
+    "mips64el-linux-gnu-n64.2.37",
+    "mips64el-linux-gnu-n64.2.38",
+    "mips64el-linux-gnu-n64-nan2008.2.33",
+    "mips64el-linux-gnu-n64-nan2008.2.34",
+    "mips64el-linux-gnu-n64-nan2008.2.35",
+    "mips64el-linux-gnu-n64-nan2008.2.36",
+    "mips64el-linux-gnu-n64-nan2008.2.37",
+    "mips64el-linux-gnu-n64-nan2008.2.38",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.33",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.34",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.35",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.36",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.37",
+    "mips64el-linux-gnu-n64-nan2008-soft.2.38",
+    "mips64el-linux-gnu-n64-soft.2.33",
+    "mips64el-linux-gnu-n64-soft.2.34",
+    "mips64el-linux-gnu-n64-soft.2.35",
+    "mips64el-linux-gnu-n64-soft.2.36",
+    "mips64el-linux-gnu-n64-soft.2.37",
+    "mips64el-linux-gnu-n64-soft.2.38",
+    "mips64-linux-gnu-n32.2.33",
+    "mips64-linux-gnu-n32.2.34",
+    "mips64-linux-gnu-n32.2.35",
+    "mips64-linux-gnu-n32.2.36",
+    "mips64-linux-gnu-n32.2.37",
+    "mips64-linux-gnu-n32.2.38",
+    "mips64-linux-gnu-n32-nan2008.2.33",
+    "mips64-linux-gnu-n32-nan2008.2.34",
+    "mips64-linux-gnu-n32-nan2008.2.35",
+    "mips64-linux-gnu-n32-nan2008.2.36",
+    "mips64-linux-gnu-n32-nan2008.2.37",
+    "mips64-linux-gnu-n32-nan2008.2.38",
+    "mips64-linux-gnu-n32-nan2008-soft.2.33",
+    "mips64-linux-gnu-n32-nan2008-soft.2.34",
+    "mips64-linux-gnu-n32-nan2008-soft.2.35",
+    "mips64-linux-gnu-n32-nan2008-soft.2.36",
+    "mips64-linux-gnu-n32-nan2008-soft.2.37",
+    "mips64-linux-gnu-n32-nan2008-soft.2.38",
+    "mips64-linux-gnu-n32-soft.2.33",
+    "mips64-linux-gnu-n32-soft.2.34",
+    "mips64-linux-gnu-n32-soft.2.35",
+    "mips64-linux-gnu-n32-soft.2.36",
+    "mips64-linux-gnu-n32-soft.2.37",
+    "mips64-linux-gnu-n32-soft.2.38",
+    "mips64-linux-gnu-n64.2.33",
+    "mips64-linux-gnu-n64.2.34",
+    "mips64-linux-gnu-n64.2.35",
+    "mips64-linux-gnu-n64.2.36",
+    "mips64-linux-gnu-n64.2.37",
+    "mips64-linux-gnu-n64.2.38",
+    "mips64-linux-gnu-n64-nan2008.2.33",
+    "mips64-linux-gnu-n64-nan2008.2.34",
+    "mips64-linux-gnu-n64-nan2008.2.35",
+    "mips64-linux-gnu-n64-nan2008.2.36",
+    "mips64-linux-gnu-n64-nan2008.2.37",
+    "mips64-linux-gnu-n64-nan2008.2.38",
+    "mips64-linux-gnu-n64-nan2008-soft.2.33",
+    "mips64-linux-gnu-n64-nan2008-soft.2.34",
+    "mips64-linux-gnu-n64-nan2008-soft.2.35",
+    "mips64-linux-gnu-n64-nan2008-soft.2.36",
+    "mips64-linux-gnu-n64-nan2008-soft.2.37",
+    "mips64-linux-gnu-n64-nan2008-soft.2.38",
+    "mips64-linux-gnu-n64-soft.2.33",
+    "mips64-linux-gnu-n64-soft.2.34",
+    "mips64-linux-gnu-n64-soft.2.35",
+    "mips64-linux-gnu-n64-soft.2.36",
+    "mips64-linux-gnu-n64-soft.2.37",
+    "mips64-linux-gnu-n64-soft.2.38",
+    "mipsel-linux-gnu.2.33",
+    "mipsel-linux-gnu.2.34",
+    "mipsel-linux-gnu.2.35",
+    "mipsel-linux-gnu.2.36",
+    "mipsel-linux-gnu.2.37",
+    "mipsel-linux-gnu.2.38",
+    "mipsel-linux-gnu-nan2008.2.33",
+    "mipsel-linux-gnu-nan2008.2.34",
+    "mipsel-linux-gnu-nan2008.2.35",
+    "mipsel-linux-gnu-nan2008.2.36",
+    "mipsel-linux-gnu-nan2008.2.37",
+    "mipsel-linux-gnu-nan2008.2.38",
+    "mipsel-linux-gnu-nan2008-soft.2.33",
+    "mipsel-linux-gnu-nan2008-soft.2.34",
+    "mipsel-linux-gnu-nan2008-soft.2.35",
+    "mipsel-linux-gnu-nan2008-soft.2.36",
+    "mipsel-linux-gnu-nan2008-soft.2.37",
+    "mipsel-linux-gnu-nan2008-soft.2.38",
+    "mipsel-linux-gnu-soft.2.33",
+    "mipsel-linux-gnu-soft.2.34",
+    "mipsel-linux-gnu-soft.2.35",
+    "mipsel-linux-gnu-soft.2.36",
+    "mipsel-linux-gnu-soft.2.37",
+    "mipsel-linux-gnu-soft.2.38",
+    "mipsisa32r6el-linux-gnu.2.33",
+    "mipsisa32r6el-linux-gnu.2.34",
+    "mipsisa32r6el-linux-gnu.2.35",
+    "mipsisa32r6el-linux-gnu.2.36",
+    "mipsisa32r6el-linux-gnu.2.37",
+    "mipsisa32r6el-linux-gnu.2.38",
+    "mipsisa64r6el-linux-gnu-n32.2.33",
+    "mipsisa64r6el-linux-gnu-n32.2.34",
+    "mipsisa64r6el-linux-gnu-n32.2.35",
+    "mipsisa64r6el-linux-gnu-n32.2.36",
+    "mipsisa64r6el-linux-gnu-n32.2.37",
+    "mipsisa64r6el-linux-gnu-n32.2.38",
+    "mipsisa64r6el-linux-gnu-n64.2.33",
+    "mipsisa64r6el-linux-gnu-n64.2.34",
+    "mipsisa64r6el-linux-gnu-n64.2.35",
+    "mipsisa64r6el-linux-gnu-n64.2.36",
+    "mipsisa64r6el-linux-gnu-n64.2.37",
+    "mipsisa64r6el-linux-gnu-n64.2.38",
+    "mips-linux-gnu.2.33",
+    "mips-linux-gnu.2.34",
+    "mips-linux-gnu.2.35",
+    "mips-linux-gnu.2.36",
+    "mips-linux-gnu.2.37",
+    "mips-linux-gnu.2.38",
+    "mips-linux-gnu-nan2008.2.33",
+    "mips-linux-gnu-nan2008.2.34",
+    "mips-linux-gnu-nan2008.2.35",
+    "mips-linux-gnu-nan2008.2.36",
+    "mips-linux-gnu-nan2008.2.37",
+    "mips-linux-gnu-nan2008.2.38",
+    "mips-linux-gnu-nan2008-soft.2.33",
+    "mips-linux-gnu-nan2008-soft.2.34",
+    "mips-linux-gnu-nan2008-soft.2.35",
+    "mips-linux-gnu-nan2008-soft.2.36",
+    "mips-linux-gnu-nan2008-soft.2.37",
+    "mips-linux-gnu-nan2008-soft.2.38",
+    "mips-linux-gnu-soft.2.33",
+    "mips-linux-gnu-soft.2.34",
+    "mips-linux-gnu-soft.2.35",
+    "mips-linux-gnu-soft.2.36",
+    "mips-linux-gnu-soft.2.37",
+    "mips-linux-gnu-soft.2.38",
+    "powerpc64le-linux-gnu.2.33",
+    "powerpc64le-linux-gnu.2.34",
+    "powerpc64le-linux-gnu.2.35",
+    "powerpc64le-linux-gnu.2.36",
+    "powerpc64le-linux-gnu.2.37",
+    "powerpc64le-linux-gnu.2.38",
+    "powerpc64-linux-gnu.2.33",
+    "powerpc64-linux-gnu.2.34",
+    "powerpc64-linux-gnu.2.35",
+    "powerpc64-linux-gnu.2.36",
+    "powerpc64-linux-gnu.2.37",
+    "powerpc64-linux-gnu.2.38",
+    "powerpc-linux-gnu.2.33",
+    "powerpc-linux-gnu.2.34",
+    "powerpc-linux-gnu.2.35",
+    "powerpc-linux-gnu.2.36",
+    "powerpc-linux-gnu.2.37",
+    "powerpc-linux-gnu.2.38",
+    "powerpc-linux-gnu-power4.2.33",
+    "powerpc-linux-gnu-power4.2.34",
+    "powerpc-linux-gnu-power4.2.35",
+    "powerpc-linux-gnu-power4.2.36",
+    "powerpc-linux-gnu-power4.2.37",
+    "powerpc-linux-gnu-power4.2.38",
+    "powerpc-linux-gnu-soft.2.33",
+    "powerpc-linux-gnu-soft.2.34",
+    "powerpc-linux-gnu-soft.2.35",
+    "powerpc-linux-gnu-soft.2.36",
+    "powerpc-linux-gnu-soft.2.37",
+    "powerpc-linux-gnu-soft.2.38",
+    "riscv64-linux-gnu-rv64imac-lp64.2.33",
+    "riscv64-linux-gnu-rv64imac-lp64.2.34",
+    "riscv64-linux-gnu-rv64imac-lp64.2.35",
+    "riscv64-linux-gnu-rv64imac-lp64.2.36",
+    "riscv64-linux-gnu-rv64imac-lp64.2.37",
+    "riscv64-linux-gnu-rv64imac-lp64.2.38",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.33",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.34",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.35",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.36",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.37",
+    "riscv64-linux-gnu-rv64imafdc-lp64.2.38",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.33",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.34",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.35",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.36",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.37",
+    "riscv64-linux-gnu-rv64imafdc-lp64d.2.38",
+    "s390x-linux-gnu.2.33",
+    "s390x-linux-gnu.2.34",
+    "s390x-linux-gnu.2.35",
+    "s390x-linux-gnu.2.36",
+    "s390x-linux-gnu.2.37",
+    "s390x-linux-gnu.2.38",
+    "sparc64-linux-gnu.2.33",
+    "sparc64-linux-gnu.2.34",
+    "sparc64-linux-gnu.2.35",
+    "sparc64-linux-gnu.2.36",
+    "sparc64-linux-gnu.2.37",
+    "sparc64-linux-gnu.2.38",
+    "sparcv8-linux-gnu-leon3.2.33",
+    "sparcv8-linux-gnu-leon3.2.34",
+    "sparcv8-linux-gnu-leon3.2.35",
+    "sparcv8-linux-gnu-leon3.2.36",
+    "sparcv8-linux-gnu-leon3.2.37",
+    "sparcv8-linux-gnu-leon3.2.38",
+    "sparcv9-linux-gnu.2.33",
+    "sparcv9-linux-gnu.2.34",
+    "sparcv9-linux-gnu.2.35",
+    "sparcv9-linux-gnu.2.36",
+    "sparcv9-linux-gnu.2.37",
+    "sparcv9-linux-gnu.2.38",
+    "x86_64-linux-gnu.2.33",
+    "x86_64-linux-gnu.2.34",
+    "x86_64-linux-gnu.2.35",
+    "x86_64-linux-gnu.2.36",
+    "x86_64-linux-gnu.2.37",
+    "x86_64-linux-gnu.2.38",
+    "x86_64-linux-gnu-x32.2.33",
+    "x86_64-linux-gnu-x32.2.34",
+    "x86_64-linux-gnu-x32.2.35",
+    "x86_64-linux-gnu-x32.2.36",
+    "x86_64-linux-gnu-x32.2.37",
+    "x86_64-linux-gnu-x32.2.38",
+    "__GLIBC_MINOR__ > 32",
+},
+
+// The rest of these are not duplicated enough so far to warrant a reduction,
+// but they are listed in the file so that we can show an error when running
+// compile.bash to make sure a new version gets added to this file.
+
+//any-windows-any

From a178a9e9be12fe407d6df52c0bee6f76e9f23eb5 Mon Sep 17 00:00:00 2001
From: David Vanderson <david.vanderson@gmail.com>
Date: Sun, 22 Oct 2023 22:11:15 -0400
Subject: [PATCH 10/13] update testHeaders for reductions

---
 src/textdiff/testHeaders.zig | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/textdiff/testHeaders.zig b/src/textdiff/testHeaders.zig
index 1be9ed7a..f854dafb 100644
--- a/src/textdiff/testHeaders.zig
+++ b/src/textdiff/testHeaders.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const reductions = @import("reductions.zig"){};
 
 const debug = false;
 
@@ -93,7 +94,26 @@ pub fn main() !void {
                 if (std.mem.startsWith(u8, trimmed, "if")) {
                     if (debug) std.debug.print("- if\n", .{});
                     if (std.mem.indexOf(u8, trimmed, "_ZIG_UH_") != null) {
+                        var found = false;
                         if (std.mem.indexOf(u8, trimmed, versionStr) != null) {
+                            found = true;
+                        } else {
+                            // look for versionStr in each reduction, and see
+                            // if that reduction matches
+                            inline for (@typeInfo(@TypeOf(reductions)).Struct.fields) |f| blk: {
+                                const field = @field(reductions, f.name);
+                                for (0..field.len - 1) |i| {
+                                    if (std.mem.eql(u8, versionStr, field[i])) {
+                                        if (std.mem.indexOf(u8, trimmed, field[field.len - 1]) != null) {
+                                            found = true;
+                                            break :blk;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        if (found) {
                             try outputing.append(3);
                         } else {
                             try outputing.append(2);

From 1604b4e38c0b8c8ddb3eaf32f8ccfea0d635d480 Mon Sep 17 00:00:00 2001
From: David Vanderson <david.vanderson@gmail.com>
Date: Tue, 24 Oct 2023 15:34:24 -0400
Subject: [PATCH 11/13] add HOWTO

---
 src/textdiff/HOWTO.txt      | 31 +++++++++++++++++++++++++++++++
 src/textdiff/reductions.zig |  2 ++
 2 files changed, 33 insertions(+)
 create mode 100644 src/textdiff/HOWTO.txt

diff --git a/src/textdiff/HOWTO.txt b/src/textdiff/HOWTO.txt
new file mode 100644
index 00000000..d9159a2a
--- /dev/null
+++ b/src/textdiff/HOWTO.txt
@@ -0,0 +1,31 @@
+
+zig build
+- should give you (in zig-out/bin): addHeaders, outputHeaders, testHeaders
+- also shells out to diff
+
+
+for the whole thing, run (for me this takes ~30min):
+./src/textdiff/compile.bash headers/*
+
+then to test (takes ~5min):
+./src/textdiff/test.bash headers/*
+
+
+What's going on:
+
+1. addHeaders headers/foo
+- takes files from foo
+- normalizes them into uh_norm
+- for each file:
+    - adds context prefix to each line
+    - outputs to uh_workfile
+    - diffs with file in uh_workspace and modifies uh_workspace
+
+2. outputHeaders uh_headers
+- reads files from uh_workspace and outputs universal headers in uh_headers
+- uses reductions.zig to reduce #if statements
+
+3. testHeaders headers/foo
+- partially evaluates uh_headers for version foo and outputs to uh_test
+- can then diff uh_test uh_norm/foo
+
diff --git a/src/textdiff/reductions.zig b/src/textdiff/reductions.zig
index d791bdcc..020feccf 100644
--- a/src/textdiff/reductions.zig
+++ b/src/textdiff/reductions.zig
@@ -1,3 +1,5 @@
+/// For each field in this file, if all of the given versions are in the same
+/// #if line, we replace it with the final line
 aarch64_linux_gnu: []const []const u8 = &[_][]const u8{
     "aarch64_be-linux-gnu.2.32",
     "aarch64_be-linux-gnu.2.33",

From cb768456d04e80ee9dac0effe503541adbec1d15 Mon Sep 17 00:00:00 2001
From: David Vanderson <david.vanderson@gmail.com>
Date: Tue, 13 May 2025 09:43:12 -0400
Subject: [PATCH 12/13] update to zig 0.14

---
 build.zig                      |  8 ++--
 build.zig.zon                  |  7 ++--
 src/textdiff/addHeaders.zig    | 77 +++++++++++++++-------------------
 src/textdiff/outputHeaders.zig | 43 +++++++++----------
 src/textdiff/testHeaders.zig   | 52 ++++++++++++-----------
 5 files changed, 89 insertions(+), 98 deletions(-)

diff --git a/build.zig b/build.zig
index b513f1d4..d3d4c330 100644
--- a/build.zig
+++ b/build.zig
@@ -1,6 +1,6 @@
 const std = @import("std");
 
-pub fn build(b: *std.build.Builder) void {
+pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
@@ -31,7 +31,7 @@ pub fn build(b: *std.build.Builder) void {
     } else {
         const addHeaders = b.addExecutable(.{
             .name = "addHeaders",
-            .root_source_file = .{ .path = "src/textdiff/addHeaders.zig" },
+            .root_source_file = b.path("src/textdiff/addHeaders.zig"),
             .target = target,
             .optimize = optimize,
         });
@@ -39,7 +39,7 @@ pub fn build(b: *std.build.Builder) void {
 
         const outputHeaders = b.addExecutable(.{
             .name = "outputHeaders",
-            .root_source_file = .{ .path = "src/textdiff/outputHeaders.zig" },
+            .root_source_file = b.path("src/textdiff/outputHeaders.zig"),
             .target = target,
             .optimize = optimize,
         });
@@ -47,7 +47,7 @@ pub fn build(b: *std.build.Builder) void {
 
         const testHeaders = b.addExecutable(.{
             .name = "testHeaders",
-            .root_source_file = .{ .path = "src/textdiff/testHeaders.zig" },
+            .root_source_file = b.path("src/textdiff/testHeaders.zig"),
             .target = target,
             .optimize = optimize,
         });
diff --git a/build.zig.zon b/build.zig.zon
index 49164295..6dec953f 100644
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -1,6 +1,7 @@
 .{
-    .name = "universal-headers",
+    .name = .universal_headers,
     .version = "0.0.1",
-
-    .dependencies = .{ },
+    .fingerprint = 0xb8a12caa0ec708d5,
+    .paths = .{""},
+    .dependencies = .{},
 }
diff --git a/src/textdiff/addHeaders.zig b/src/textdiff/addHeaders.zig
index 279cf688..d818d373 100644
--- a/src/textdiff/addHeaders.zig
+++ b/src/textdiff/addHeaders.zig
@@ -2,39 +2,34 @@ const std = @import("std");
 
 const debug = false;
 
+pub fn printUsage() void {
+    std.debug.print("usage: addHeaders <dir>\n", .{});
+    std.debug.print("normalizes headers from <dir> into uh_norm/<dir>\n", .{});
+    std.debug.print("adds headers from uh_norm/<dir> into uh_workspace\n", .{});
+}
+
 pub fn main() !void {
     var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     const arena = arena_allocator.allocator();
 
     var args = try std.process.argsWithAllocator(arena);
-
-    {
-        var i: usize = 0;
-        while (args.skip()) {
-            i += 1;
-        }
-
-        if (i != 2) {
-            std.debug.print("usage: addHeaders <dir>\n", .{});
-            std.debug.print("normalizes headers from <dir> into uh_norm/<dir>\n", .{});
-            std.debug.print("adds headers from uh_norm/<dir> into uh_workspace\n", .{});
-            return;
-        }
+    _ = args.skip(); // process name
+    const headerDir = args.next() orelse {
+        printUsage();
+        return;
+    };
+
+    if (args.next()) |_| {
+        printUsage();
+        return;
     }
 
-    args = try std.process.argsWithAllocator(arena);
-    _ = args.skip();
-    const headerDir = args.next() orelse return;
-
-    var buf = try arena.alloc(u8, 1000);
-
-    const normalized_dir = try std.fmt.bufPrint(buf, "uh_norm/{s}", .{std.fs.path.basename(headerDir)});
+    const normalized_dir = try std.fmt.allocPrint(arena, "uh_norm/{s}", .{std.fs.path.basename(headerDir)});
     std.fs.cwd().makePath(normalized_dir) catch {};
 
-    buf = try arena.alloc(u8, 1000);
-    const versionStr = try std.fmt.bufPrint(buf, "{s}|", .{std.fs.path.basename(headerDir)});
+    const versionStr = try std.fmt.allocPrint(arena, "{s}|", .{std.fs.path.basename(headerDir)});
 
-    var dir = try std.fs.cwd().openIterableDir(headerDir, .{});
+    var dir = try std.fs.cwd().openDir(headerDir, .{ .iterate = true });
     defer dir.close();
 
     std.fs.cwd().makeDir("uh_workspace") catch {};
@@ -54,9 +49,9 @@ pub fn main() !void {
         // file extension for our sidecar version information
         const extra = ".uhversion.txt";
 
-        var filepath = try std.fs.path.join(arena, &.{ headerDir, entry.path });
-        var workpath = try std.fs.path.join(arena, &.{ "uh_workspace", entry.path });
-        var normalized_path = try std.fs.path.join(arena, &.{ normalized_dir, entry.path });
+        const filepath = try std.fs.path.join(arena, &.{ headerDir, entry.path });
+        const workpath = try std.fs.path.join(arena, &.{ "uh_workspace", entry.path });
+        const normalized_path = try std.fs.path.join(arena, &.{ normalized_dir, entry.path });
 
         // read all the lines of our work-in-progress file
         var worklines = std.ArrayList([]const u8).init(arena);
@@ -83,8 +78,7 @@ pub fn main() !void {
         }
 
         // read all the lines of our work-in-progress sidecar version file
-        buf = try arena.alloc(u8, 1000);
-        const versionpath = try std.fmt.bufPrint(buf, "{s}{s}", .{ workpath, extra });
+        const versionpath = try std.fmt.allocPrint(arena, "{s}{s}", .{ workpath, extra });
         var versionlines = std.ArrayList([]const u8).init(arena);
         {
             var file = try std.fs.cwd().createFile(versionpath, .{ .read = true, .truncate = false });
@@ -154,7 +148,7 @@ pub fn main() !void {
                 var it = std.mem.splitScalar(u8, contents, '\n');
                 while (it.next()) |line| {
                     // normalize whitespace (replace tabs with spaces)
-                    buf = try arena.alloc(u8, line.len);
+                    const buf = try arena.alloc(u8, line.len);
                     _ = std.mem.replace(u8, line, "\t", " ", buf);
 
                     // filter out empty lines
@@ -204,13 +198,13 @@ pub fn main() !void {
         //std.debug.print("filepath: {s}, workpath: {s}\n", .{ filepath, workpath });
 
         // run diff and get the output
-        var diff_stdout = std.ArrayList(u8).init(arena);
-        var diff_stderr = std.ArrayList(u8).init(arena);
+        var diff_stdout: std.ArrayListUnmanaged(u8) = .empty;
+        var diff_stderr: std.ArrayListUnmanaged(u8) = .empty;
         var diff_child = std.process.Child.init(&.{ "diff", "-wdN", workpath, "uh_workfile" }, arena);
         diff_child.stdout_behavior = .Pipe;
         diff_child.stderr_behavior = .Pipe;
         try diff_child.spawn();
-        try diff_child.collectOutput(&diff_stdout, &diff_stderr, 20 * 1024 * 1024);
+        try diff_child.collectOutput(arena, &diff_stdout, &diff_stderr, 20 * 1024 * 1024);
         _ = try diff_child.wait();
 
         //std.debug.print("diff says:\n{s}\n", .{diff_stdout.items});
@@ -255,8 +249,7 @@ pub fn main() !void {
                 // from line_adj to addafter, the lines were the same, so add the version
                 for (last_line..@intCast(line_adj + @as(isize, @intCast(addafter)))) |i| {
                     const old = versionlines.items[i];
-                    buf = try arena.alloc(u8, old.len + versionStr.len);
-                    versionlines.items[i] = try std.fmt.bufPrint(buf, "{s}{s}", .{ old, versionStr });
+                    versionlines.items[i] = try std.fmt.allocPrint(arena, "{s}{s}", .{ old, versionStr });
                 }
 
                 // add lines start..end from new header after line addafter
@@ -303,8 +296,7 @@ pub fn main() !void {
                 // from line_adj to start1, the lines were the same, so add the version
                 for (last_line..@intCast(line_adj + @as(isize, @intCast(start1)))) |i| {
                     const old = versionlines.items[i];
-                    buf = try arena.alloc(u8, old.len + versionStr.len);
-                    versionlines.items[i] = try std.fmt.bufPrint(buf, "{s}{s}", .{ old, versionStr });
+                    versionlines.items[i] = try std.fmt.allocPrint(arena, "{s}{s}", .{ old, versionStr });
                 }
 
                 const where: usize = @intCast(line_adj + @as(isize, @intCast(end1)));
@@ -335,8 +327,7 @@ pub fn main() !void {
 
                 for (last_line..@intCast(line_adj + @as(isize, @intCast(start)))) |i| {
                     const old = versionlines.items[i];
-                    buf = try arena.alloc(u8, old.len + versionStr.len);
-                    versionlines.items[i] = try std.fmt.bufPrint(buf, "{s}{s}", .{ old, versionStr });
+                    versionlines.items[i] = try std.fmt.allocPrint(arena, "{s}{s}", .{ old, versionStr });
                 }
 
                 // we just skip over the lines
@@ -352,8 +343,7 @@ pub fn main() !void {
         //std.debug.print("last_line {d} {d}\n", .{ last_line, versionlines.items.len });
         for (last_line..versionlines.items.len) |i| {
             const old = versionlines.items[i];
-            buf = try arena.alloc(u8, old.len + versionStr.len);
-            versionlines.items[i] = try std.fmt.bufPrint(buf, "{s}{s}", .{ old, versionStr });
+            versionlines.items[i] = try std.fmt.allocPrint(arena, "{s}{s}", .{ old, versionStr });
         }
 
         // write out work-in-progress file back to disk
@@ -392,7 +382,7 @@ pub fn addContext(arena: std.mem.Allocator, lines: *std.ArrayList([]const u8)) !
 
         var pop_context: bool = false;
 
-        var com = in_comment;
+        const com = in_comment;
         if (!in_comment and std.mem.indexOf(u8, line, "/*") != null and std.mem.indexOf(u8, line, "*/") == null) {
             in_comment = true;
         } else if (in_comment and std.mem.indexOf(u8, line, "/*") == null and std.mem.indexOf(u8, line, "*/") != null) {
@@ -445,8 +435,7 @@ pub fn addContext(arena: std.mem.Allocator, lines: *std.ArrayList([]const u8)) !
             try seen_contexts.append(ctx);
         }
 
-        var buf = try arena.alloc(u8, 9 + line.len);
-        lines.items[i] = try std.fmt.bufPrint(buf, "{x:0<8} {s}", .{ context.items[context.items.len - 1], line });
+        lines.items[i] = try std.fmt.allocPrint(arena, "{x:0<8} {s}", .{ context.items[context.items.len - 1], line });
 
         if (pop_context) {
             _ = context.pop();
@@ -468,7 +457,7 @@ pub fn newContext(lines: [][]const u8, i: usize, ctx: u32) u32 {
     var in_comment: bool = false;
     while (ii < lines.len) : (ii += 1) {
         const line = lines[ii];
-        var com = in_comment;
+        const com = in_comment;
         if (!in_comment and std.mem.indexOf(u8, line, "/*") != null and std.mem.indexOf(u8, line, "*/") == null) {
             in_comment = true;
         } else if (in_comment and std.mem.indexOf(u8, line, "/*") == null and std.mem.indexOf(u8, line, "*/") != null) {
diff --git a/src/textdiff/outputHeaders.zig b/src/textdiff/outputHeaders.zig
index 872436bd..9eb88701 100644
--- a/src/textdiff/outputHeaders.zig
+++ b/src/textdiff/outputHeaders.zig
@@ -1,32 +1,30 @@
 const std = @import("std");
 const reductions = @import("reductions.zig"){};
 
+pub fn printUsage() void {
+    std.debug.print("usage: outputHeaders <dir> [version]\n", .{});
+    std.debug.print("takes headers from uh_workspace and outputs to <dir>\n", .{});
+    std.debug.print("if version is given, only output lines matching that version (for testing)\n", .{});
+}
+
 pub fn main() !void {
     var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     const arena = arena_allocator.allocator();
 
     var args = try std.process.argsWithAllocator(arena);
+    _ = args.skip(); // process name
+    const outDir = args.next() orelse {
+        printUsage();
+        return;
+    };
+    const versionStr = args.next();
 
-    {
-        var i: usize = 0;
-        while (args.skip()) {
-            i += 1;
-        }
-
-        if (i != 2 and i != 3) {
-            std.debug.print("usage: outputHeaders <dir> [version]\n", .{});
-            std.debug.print("takes headers from uh_workspace and outputs to <dir>\n", .{});
-            std.debug.print("if version is given, only output lines matching that version (for testing)\n", .{});
-            return;
-        }
+    if (args.next()) |_| {
+        printUsage();
+        return;
     }
 
-    args = try std.process.argsWithAllocator(arena);
-    _ = args.skip();
-    const outDir = args.next() orelse return;
-    const versionStr = args.next();
-
-    var dir = try std.fs.cwd().openIterableDir("uh_workspace", .{});
+    var dir = try std.fs.cwd().openDir("uh_workspace", .{ .iterate = true });
     defer dir.close();
 
     var walker = try dir.walk(arena);
@@ -46,7 +44,7 @@ pub fn main() !void {
         //std.debug.print("entry: base {s} path {s}\n", .{ entry.basename, entry.path });
 
         // read work-in-progress file into memory
-        var workpath = try std.fs.path.join(arena, &.{ "uh_workspace", entry.path });
+        const workpath = try std.fs.path.join(arena, &.{ "uh_workspace", entry.path });
         var worklines = std.ArrayList([]const u8).init(arena);
         {
             var file = try std.fs.cwd().openFile(workpath, .{});
@@ -65,8 +63,7 @@ pub fn main() !void {
         }
 
         // read work-in-progress sidecar version file into memory
-        var buf = try arena.alloc(u8, 1000);
-        const versionpath = try std.fmt.bufPrint(buf, "{s}{s}", .{ workpath, extra });
+        const versionpath = try std.fmt.allocPrint(arena, "{s}{s}", .{ workpath, extra });
         var versionlines = std.ArrayList([]const u8).init(arena);
         {
             var file = try std.fs.cwd().openFile(versionpath, .{});
@@ -85,7 +82,7 @@ pub fn main() !void {
         }
 
         // make writer to output file that will be our universal header
-        var filepath = try std.fs.path.join(arena, &.{ outDir, entry.path });
+        const filepath = try std.fs.path.join(arena, &.{ outDir, entry.path });
         if (std.fs.path.dirname(filepath)) |dirname| {
             try std.fs.cwd().makePath(dirname);
         }
@@ -179,7 +176,7 @@ pub fn outputIfLine(arena: std.mem.Allocator, writer: anytype, versionline: []co
 
     var replacements = std.ArrayList([]const u8).init(arena);
 
-    inline for (@typeInfo(@TypeOf(reductions)).Struct.fields) |f| {
+    inline for (@typeInfo(@TypeOf(reductions)).@"struct".fields) |f| {
         const field = @field(reductions, f.name);
         var found_all = true;
         for (0..field.len - 1) |i| {
diff --git a/src/textdiff/testHeaders.zig b/src/textdiff/testHeaders.zig
index f854dafb..cb14d139 100644
--- a/src/textdiff/testHeaders.zig
+++ b/src/textdiff/testHeaders.zig
@@ -3,6 +3,12 @@ const reductions = @import("reductions.zig"){};
 
 const debug = false;
 
+pub fn printUsage() void {
+    std.debug.print("usage: testHeaders <dir> <outdir> <version>\n", .{});
+    std.debug.print("takes universal headers from <dir>, partially evaluates, and outputs to <outdir>\n", .{});
+    std.debug.print("output files should match originals from that version (maybe whitespace differences)\n", .{});
+}
+
 // This utility goes through universal headers and only evaluates the #if blocks that we added to make them universal
 // - what comes out can be diffed against the original headers for testing
 pub fn main() !void {
@@ -10,28 +16,26 @@ pub fn main() !void {
     const arena = arena_allocator.allocator();
 
     var args = try std.process.argsWithAllocator(arena);
-
-    {
-        var i: usize = 0;
-        while (args.skip()) {
-            i += 1;
-        }
-
-        if (i != 4) {
-            std.debug.print("usage: testHeaders <dir> <outdir> <version>\n", .{});
-            std.debug.print("takes universal headers from <dir>, partially evaluates, and outputs to <outdir>\n", .{});
-            std.debug.print("output files should match originals from that version (maybe whitespace differences)\n", .{});
-            return;
-        }
+    _ = args.skip(); // process name
+    const inDir = args.next() orelse {
+        printUsage();
+        return;
+    };
+    const outDir = args.next() orelse {
+        printUsage();
+        return;
+    };
+    const versionStr = std.fs.path.basename(args.next() orelse {
+        printUsage();
+        return;
+    });
+
+    if (args.next()) |_| {
+        printUsage();
+        return;
     }
 
-    args = try std.process.argsWithAllocator(arena);
-    _ = args.skip();
-    const inDir = args.next() orelse return;
-    const outDir = args.next() orelse return;
-    const versionStr = std.fs.path.basename(args.next() orelse return);
-
-    var dir = try std.fs.cwd().openIterableDir(inDir, .{});
+    var dir = try std.fs.cwd().openDir(inDir, .{ .iterate = true });
     defer dir.close();
 
     var walker = try dir.walk(arena);
@@ -45,7 +49,7 @@ pub fn main() !void {
         //std.debug.print("entry: base {s} path {s}\n", .{ entry.basename, entry.path });
 
         // read universal header into memory
-        var inpath = try std.fs.path.join(arena, &.{ inDir, entry.path });
+        const inpath = try std.fs.path.join(arena, &.{ inDir, entry.path });
         var inlines = std.ArrayList([]const u8).init(arena);
         {
             var file = try std.fs.cwd().openFile(inpath, .{});
@@ -63,7 +67,7 @@ pub fn main() !void {
             }
         }
 
-        var outpath = try std.fs.path.join(arena, &.{ outDir, entry.path });
+        const outpath = try std.fs.path.join(arena, &.{ outDir, entry.path });
         if (std.fs.path.dirname(outpath)) |dirname| {
             try std.fs.cwd().makePath(dirname);
         }
@@ -80,7 +84,7 @@ pub fn main() !void {
         var in_comment: bool = false;
         for (inlines.items) |line| {
             if (debug) std.debug.print("{d} {s}\n", .{ outputing.items.len, line });
-            var com = in_comment;
+            const com = in_comment;
             if (!in_comment and std.mem.indexOf(u8, line, "/*") != null and std.mem.indexOf(u8, line, "*/") == null) {
                 in_comment = true;
             } else if (in_comment and std.mem.indexOf(u8, line, "/*") == null and std.mem.indexOf(u8, line, "*/") != null) {
@@ -100,7 +104,7 @@ pub fn main() !void {
                         } else {
                             // look for versionStr in each reduction, and see
                             // if that reduction matches
-                            inline for (@typeInfo(@TypeOf(reductions)).Struct.fields) |f| blk: {
+                            inline for (@typeInfo(@TypeOf(reductions)).@"struct".fields) |f| blk: {
                                 const field = @field(reductions, f.name);
                                 for (0..field.len - 1) |i| {
                                     if (std.mem.eql(u8, versionStr, field[i])) {

From 57feb35deea03634d8c3f70c4e4286b5cbefc213 Mon Sep 17 00:00:00 2001
From: David Vanderson <david.vanderson@gmail.com>
Date: Tue, 13 May 2025 11:13:27 -0400
Subject: [PATCH 13/13] only use GLIBC_MINOR reductions

---
 src/textdiff/reductions.zig | 1464 ++++++++++++++---------------------
 1 file changed, 562 insertions(+), 902 deletions(-)

diff --git a/src/textdiff/reductions.zig b/src/textdiff/reductions.zig
index 020feccf..619f84a2 100644
--- a/src/textdiff/reductions.zig
+++ b/src/textdiff/reductions.zig
@@ -1,559 +1,559 @@
-/// For each field in this file, if all of the given versions are in the same
-/// #if line, we replace it with the final line
-aarch64_linux_gnu: []const []const u8 = &[_][]const u8{
-    "aarch64_be-linux-gnu.2.32",
-    "aarch64_be-linux-gnu.2.33",
-    "aarch64_be-linux-gnu.2.34",
-    "aarch64_be-linux-gnu.2.35",
-    "aarch64_be-linux-gnu.2.36",
-    "aarch64_be-linux-gnu.2.37",
-    "aarch64_be-linux-gnu.2.38",
-    "aarch64-linux-gnu.2.32",
-    "aarch64-linux-gnu.2.33",
-    "aarch64-linux-gnu.2.34",
-    "aarch64-linux-gnu.2.35",
-    "aarch64-linux-gnu.2.36",
-    "aarch64-linux-gnu.2.37",
-    "aarch64-linux-gnu.2.38",
-    "(defined __aarch64__ AND defined __GLIBC__)", // FIXME
-},
-
-arc_linux_gnu: []const []const u8 = &[_][]const u8{
-    "arc-linux-gnu.2.32",
-    "arc-linux-gnu.2.33",
-    "arc-linux-gnu.2.34",
-    "arc-linux-gnu.2.35",
-    "arc-linux-gnu.2.36",
-    "arc-linux-gnu.2.37",
-    "arc-linux-gnu.2.38",
-    "arc-linux-gnuhf.2.32",
-    "arc-linux-gnuhf.2.33",
-    "arc-linux-gnuhf.2.34",
-    "arc-linux-gnuhf.2.35",
-    "arc-linux-gnuhf.2.36",
-    "arc-linux-gnuhf.2.37",
-    "arc-linux-gnuhf.2.38",
-    "(defined __arc__ AND defined __GLIBC__)", // FIXME
-},
-
-arm_linux_gnu: []const []const u8 = &[_][]const u8{
-    "armeb-linux-gnueabi.2.32",
-    "armeb-linux-gnueabi.2.33",
-    "armeb-linux-gnueabi.2.34",
-    "armeb-linux-gnueabi.2.35",
-    "armeb-linux-gnueabi.2.36",
-    "armeb-linux-gnueabi.2.37",
-    "armeb-linux-gnueabi.2.38",
-    "armeb-linux-gnueabihf.2.32",
-    "armeb-linux-gnueabihf.2.33",
-    "armeb-linux-gnueabihf.2.34",
-    "armeb-linux-gnueabihf.2.35",
-    "armeb-linux-gnueabihf.2.36",
-    "armeb-linux-gnueabihf.2.37",
-    "armeb-linux-gnueabihf.2.38",
-    "arm-linux-gnueabi.2.32",
-    "arm-linux-gnueabi.2.33",
-    "arm-linux-gnueabi.2.34",
-    "arm-linux-gnueabi.2.35",
-    "arm-linux-gnueabi.2.36",
-    "arm-linux-gnueabi.2.37",
-    "arm-linux-gnueabi.2.38",
-    "arm-linux-gnueabihf.2.32",
-    "arm-linux-gnueabihf.2.33",
-    "arm-linux-gnueabihf.2.34",
-    "arm-linux-gnueabihf.2.35",
-    "arm-linux-gnueabihf.2.36",
-    "arm-linux-gnueabihf.2.37",
-    "arm-linux-gnueabihf.2.38",
-    "arm-linux-gnueabihf-v7a.2.32",
-    "arm-linux-gnueabihf-v7a.2.33",
-    "arm-linux-gnueabihf-v7a.2.34",
-    "arm-linux-gnueabihf-v7a.2.35",
-    "arm-linux-gnueabihf-v7a.2.36",
-    "arm-linux-gnueabihf-v7a.2.37",
-    "arm-linux-gnueabihf-v7a.2.38",
-    "arm-linux-gnueabi-v4t.2.32",
-    "arm-linux-gnueabi-v4t.2.33",
-    "arm-linux-gnueabi-v4t.2.34",
-    "arm-linux-gnueabi-v4t.2.35",
-    "arm-linux-gnueabi-v4t.2.36",
-    "arm-linux-gnueabi-v4t.2.37",
-    "arm-linux-gnueabi-v4t.2.38",
-    "(defined __arm__ AND defined __GLIBC__)", // FIXME
-},
-
-csky_linux_gnu: []const []const u8 = &[_][]const u8{
-    "csky-linux-gnuabiv2.2.33",
-    "csky-linux-gnuabiv2.2.34",
-    "csky-linux-gnuabiv2.2.35",
-    "csky-linux-gnuabiv2.2.36",
-    "csky-linux-gnuabiv2.2.37",
-    "csky-linux-gnuabiv2.2.38",
-    "csky-linux-gnuabiv2-soft.2.33",
-    "csky-linux-gnuabiv2-soft.2.34",
-    "csky-linux-gnuabiv2-soft.2.35",
-    "csky-linux-gnuabiv2-soft.2.36",
-    "csky-linux-gnuabiv2-soft.2.37",
-    "csky-linux-gnuabiv2-soft.2.38",
-    "(defined __csky__ AND defined __GLIBC__)", // FIXME
-},
-
-i_linux_gnu: []const []const u8 = &[_][]const u8{
-    "i486-linux-gnu.2.32",
-    "i486-linux-gnu.2.33",
-    "i486-linux-gnu.2.34",
-    "i486-linux-gnu.2.35",
-    "i486-linux-gnu.2.36",
-    "i486-linux-gnu.2.37",
-    "i486-linux-gnu.2.38",
-    "i586-linux-gnu.2.32",
-    "i586-linux-gnu.2.33",
-    "i586-linux-gnu.2.34",
-    "i586-linux-gnu.2.35",
-    "i586-linux-gnu.2.36",
-    "i586-linux-gnu.2.37",
-    "i586-linux-gnu.2.38",
-    "i686-linux-gnu.2.32",
-    "i686-linux-gnu.2.33",
-    "i686-linux-gnu.2.34",
-    "i686-linux-gnu.2.35",
-    "i686-linux-gnu.2.36",
-    "i686-linux-gnu.2.37",
-    "i686-linux-gnu.2.38",
-    "ia64-linux-gnu.2.32",
-    "ia64-linux-gnu.2.33",
-    "ia64-linux-gnu.2.34",
-    "ia64-linux-gnu.2.35",
-    "ia64-linux-gnu.2.36",
-    "ia64-linux-gnu.2.37",
-    "ia64-linux-gnu.2.38",
-    "(defined __ISOME__ AND defined __GLIBC__)", // FIXME
-},
-
-m68k_linux_gnu: []const []const u8 = &[_][]const u8{
-    "m68k-linux-gnu.2.32",
-    "m68k-linux-gnu.2.33",
-    "m68k-linux-gnu.2.34",
-    "m68k-linux-gnu.2.35",
-    "m68k-linux-gnu.2.36",
-    "m68k-linux-gnu.2.37",
-    "m68k-linux-gnu.2.38",
-    "(defined __M68K__ AND defined __GLIBC__)", // FIXME
-},
-
-mips64_linux_gnu: []const []const u8 = &[_][]const u8{
-    "mips64el-linux-gnu-n32.2.32",
-    "mips64el-linux-gnu-n32.2.33",
-    "mips64el-linux-gnu-n32.2.34",
-    "mips64el-linux-gnu-n32.2.35",
-    "mips64el-linux-gnu-n32.2.36",
-    "mips64el-linux-gnu-n32.2.37",
-    "mips64el-linux-gnu-n32.2.38",
-    "mips64el-linux-gnu-n32-nan2008.2.32",
-    "mips64el-linux-gnu-n32-nan2008.2.33",
-    "mips64el-linux-gnu-n32-nan2008.2.34",
-    "mips64el-linux-gnu-n32-nan2008.2.35",
-    "mips64el-linux-gnu-n32-nan2008.2.36",
-    "mips64el-linux-gnu-n32-nan2008.2.37",
-    "mips64el-linux-gnu-n32-nan2008.2.38",
-    "mips64el-linux-gnu-n32-nan2008-soft.2.32",
-    "mips64el-linux-gnu-n32-nan2008-soft.2.33",
-    "mips64el-linux-gnu-n32-nan2008-soft.2.34",
-    "mips64el-linux-gnu-n32-nan2008-soft.2.35",
-    "mips64el-linux-gnu-n32-nan2008-soft.2.36",
-    "mips64el-linux-gnu-n32-nan2008-soft.2.37",
-    "mips64el-linux-gnu-n32-nan2008-soft.2.38",
-    "mips64el-linux-gnu-n32-soft.2.32",
-    "mips64el-linux-gnu-n32-soft.2.33",
-    "mips64el-linux-gnu-n32-soft.2.34",
-    "mips64el-linux-gnu-n32-soft.2.35",
-    "mips64el-linux-gnu-n32-soft.2.36",
-    "mips64el-linux-gnu-n32-soft.2.37",
-    "mips64el-linux-gnu-n32-soft.2.38",
-    "mips64el-linux-gnu-n64.2.32",
-    "mips64el-linux-gnu-n64.2.33",
-    "mips64el-linux-gnu-n64.2.34",
-    "mips64el-linux-gnu-n64.2.35",
-    "mips64el-linux-gnu-n64.2.36",
-    "mips64el-linux-gnu-n64.2.37",
-    "mips64el-linux-gnu-n64.2.38",
-    "mips64el-linux-gnu-n64-nan2008.2.32",
-    "mips64el-linux-gnu-n64-nan2008.2.33",
-    "mips64el-linux-gnu-n64-nan2008.2.34",
-    "mips64el-linux-gnu-n64-nan2008.2.35",
-    "mips64el-linux-gnu-n64-nan2008.2.36",
-    "mips64el-linux-gnu-n64-nan2008.2.37",
-    "mips64el-linux-gnu-n64-nan2008.2.38",
-    "mips64el-linux-gnu-n64-nan2008-soft.2.32",
-    "mips64el-linux-gnu-n64-nan2008-soft.2.33",
-    "mips64el-linux-gnu-n64-nan2008-soft.2.34",
-    "mips64el-linux-gnu-n64-nan2008-soft.2.35",
-    "mips64el-linux-gnu-n64-nan2008-soft.2.36",
-    "mips64el-linux-gnu-n64-nan2008-soft.2.37",
-    "mips64el-linux-gnu-n64-nan2008-soft.2.38",
-    "mips64el-linux-gnu-n64-soft.2.32",
-    "mips64el-linux-gnu-n64-soft.2.33",
-    "mips64el-linux-gnu-n64-soft.2.34",
-    "mips64el-linux-gnu-n64-soft.2.35",
-    "mips64el-linux-gnu-n64-soft.2.36",
-    "mips64el-linux-gnu-n64-soft.2.37",
-    "mips64el-linux-gnu-n64-soft.2.38",
-    "mips64-linux-gnu-n32.2.32",
-    "mips64-linux-gnu-n32.2.33",
-    "mips64-linux-gnu-n32.2.34",
-    "mips64-linux-gnu-n32.2.35",
-    "mips64-linux-gnu-n32.2.36",
-    "mips64-linux-gnu-n32.2.37",
-    "mips64-linux-gnu-n32.2.38",
-    "mips64-linux-gnu-n32-nan2008.2.32",
-    "mips64-linux-gnu-n32-nan2008.2.33",
-    "mips64-linux-gnu-n32-nan2008.2.34",
-    "mips64-linux-gnu-n32-nan2008.2.35",
-    "mips64-linux-gnu-n32-nan2008.2.36",
-    "mips64-linux-gnu-n32-nan2008.2.37",
-    "mips64-linux-gnu-n32-nan2008.2.38",
-    "mips64-linux-gnu-n32-nan2008-soft.2.32",
-    "mips64-linux-gnu-n32-nan2008-soft.2.33",
-    "mips64-linux-gnu-n32-nan2008-soft.2.34",
-    "mips64-linux-gnu-n32-nan2008-soft.2.35",
-    "mips64-linux-gnu-n32-nan2008-soft.2.36",
-    "mips64-linux-gnu-n32-nan2008-soft.2.37",
-    "mips64-linux-gnu-n32-nan2008-soft.2.38",
-    "mips64-linux-gnu-n32-soft.2.32",
-    "mips64-linux-gnu-n32-soft.2.33",
-    "mips64-linux-gnu-n32-soft.2.34",
-    "mips64-linux-gnu-n32-soft.2.35",
-    "mips64-linux-gnu-n32-soft.2.36",
-    "mips64-linux-gnu-n32-soft.2.37",
-    "mips64-linux-gnu-n32-soft.2.38",
-    "mips64-linux-gnu-n64.2.32",
-    "mips64-linux-gnu-n64.2.33",
-    "mips64-linux-gnu-n64.2.34",
-    "mips64-linux-gnu-n64.2.35",
-    "mips64-linux-gnu-n64.2.36",
-    "mips64-linux-gnu-n64.2.37",
-    "mips64-linux-gnu-n64.2.38",
-    "mips64-linux-gnu-n64-nan2008.2.32",
-    "mips64-linux-gnu-n64-nan2008.2.33",
-    "mips64-linux-gnu-n64-nan2008.2.34",
-    "mips64-linux-gnu-n64-nan2008.2.35",
-    "mips64-linux-gnu-n64-nan2008.2.36",
-    "mips64-linux-gnu-n64-nan2008.2.37",
-    "mips64-linux-gnu-n64-nan2008.2.38",
-    "mips64-linux-gnu-n64-nan2008-soft.2.32",
-    "mips64-linux-gnu-n64-nan2008-soft.2.33",
-    "mips64-linux-gnu-n64-nan2008-soft.2.34",
-    "mips64-linux-gnu-n64-nan2008-soft.2.35",
-    "mips64-linux-gnu-n64-nan2008-soft.2.36",
-    "mips64-linux-gnu-n64-nan2008-soft.2.37",
-    "mips64-linux-gnu-n64-nan2008-soft.2.38",
-    "mips64-linux-gnu-n64-soft.2.32",
-    "mips64-linux-gnu-n64-soft.2.33",
-    "mips64-linux-gnu-n64-soft.2.34",
-    "mips64-linux-gnu-n64-soft.2.35",
-    "mips64-linux-gnu-n64-soft.2.36",
-    "mips64-linux-gnu-n64-soft.2.37",
-    "mips64-linux-gnu-n64-soft.2.38",
-    "(defined __MIPS64__ AND defined __GLIBC__)", // FIXME
-},
-
-mipsel_linux_gnu: []const []const u8 = &[_][]const u8{
-    "mipsel-linux-gnu.2.32",
-    "mipsel-linux-gnu.2.33",
-    "mipsel-linux-gnu.2.34",
-    "mipsel-linux-gnu.2.35",
-    "mipsel-linux-gnu.2.36",
-    "mipsel-linux-gnu.2.37",
-    "mipsel-linux-gnu.2.38",
-    "mipsel-linux-gnu-nan2008.2.32",
-    "mipsel-linux-gnu-nan2008.2.33",
-    "mipsel-linux-gnu-nan2008.2.34",
-    "mipsel-linux-gnu-nan2008.2.35",
-    "mipsel-linux-gnu-nan2008.2.36",
-    "mipsel-linux-gnu-nan2008.2.37",
-    "mipsel-linux-gnu-nan2008.2.38",
-    "mipsel-linux-gnu-nan2008-soft.2.32",
-    "mipsel-linux-gnu-nan2008-soft.2.33",
-    "mipsel-linux-gnu-nan2008-soft.2.34",
-    "mipsel-linux-gnu-nan2008-soft.2.35",
-    "mipsel-linux-gnu-nan2008-soft.2.36",
-    "mipsel-linux-gnu-nan2008-soft.2.37",
-    "mipsel-linux-gnu-nan2008-soft.2.38",
-    "mipsel-linux-gnu-soft.2.32",
-    "mipsel-linux-gnu-soft.2.33",
-    "mipsel-linux-gnu-soft.2.34",
-    "mipsel-linux-gnu-soft.2.35",
-    "mipsel-linux-gnu-soft.2.36",
-    "mipsel-linux-gnu-soft.2.37",
-    "mipsel-linux-gnu-soft.2.38",
-    "mipsisa32r6el-linux-gnu.2.32",
-    "mipsisa32r6el-linux-gnu.2.33",
-    "mipsisa32r6el-linux-gnu.2.34",
-    "mipsisa32r6el-linux-gnu.2.35",
-    "mipsisa32r6el-linux-gnu.2.36",
-    "mipsisa32r6el-linux-gnu.2.37",
-    "mipsisa32r6el-linux-gnu.2.38",
-    "mipsisa64r6el-linux-gnu-n32.2.32",
-    "mipsisa64r6el-linux-gnu-n32.2.33",
-    "mipsisa64r6el-linux-gnu-n32.2.34",
-    "mipsisa64r6el-linux-gnu-n32.2.35",
-    "mipsisa64r6el-linux-gnu-n32.2.36",
-    "mipsisa64r6el-linux-gnu-n32.2.37",
-    "mipsisa64r6el-linux-gnu-n32.2.38",
-    "mipsisa64r6el-linux-gnu-n64.2.32",
-    "mipsisa64r6el-linux-gnu-n64.2.33",
-    "mipsisa64r6el-linux-gnu-n64.2.34",
-    "mipsisa64r6el-linux-gnu-n64.2.35",
-    "mipsisa64r6el-linux-gnu-n64.2.36",
-    "mipsisa64r6el-linux-gnu-n64.2.37",
-    "mipsisa64r6el-linux-gnu-n64.2.38",
-    "(defined __MIPSEL__ AND defined __GLIBC__)", // FIXME
-},
-
-mips_linux_gnu: []const []const u8 = &[_][]const u8{
-    "mips-linux-gnu.2.32",
-    "mips-linux-gnu.2.33",
-    "mips-linux-gnu.2.34",
-    "mips-linux-gnu.2.35",
-    "mips-linux-gnu.2.36",
-    "mips-linux-gnu.2.37",
-    "mips-linux-gnu.2.38",
-    "mips-linux-gnu-nan2008.2.32",
-    "mips-linux-gnu-nan2008.2.33",
-    "mips-linux-gnu-nan2008.2.34",
-    "mips-linux-gnu-nan2008.2.35",
-    "mips-linux-gnu-nan2008.2.36",
-    "mips-linux-gnu-nan2008.2.37",
-    "mips-linux-gnu-nan2008.2.38",
-    "mips-linux-gnu-nan2008-soft.2.32",
-    "mips-linux-gnu-nan2008-soft.2.33",
-    "mips-linux-gnu-nan2008-soft.2.34",
-    "mips-linux-gnu-nan2008-soft.2.35",
-    "mips-linux-gnu-nan2008-soft.2.36",
-    "mips-linux-gnu-nan2008-soft.2.37",
-    "mips-linux-gnu-nan2008-soft.2.38",
-    "mips-linux-gnu-soft.2.32",
-    "mips-linux-gnu-soft.2.33",
-    "mips-linux-gnu-soft.2.34",
-    "mips-linux-gnu-soft.2.35",
-    "mips-linux-gnu-soft.2.36",
-    "mips-linux-gnu-soft.2.37",
-    "mips-linux-gnu-soft.2.38",
-    "(defined __MIPS__ AND defined __GLIBC__)", // FIXME
-},
-
-powerpc64_linux_gnu: []const []const u8 = &[_][]const u8{
-    "powerpc64le-linux-gnu.2.32",
-    "powerpc64le-linux-gnu.2.33",
-    "powerpc64le-linux-gnu.2.34",
-    "powerpc64le-linux-gnu.2.35",
-    "powerpc64le-linux-gnu.2.36",
-    "powerpc64le-linux-gnu.2.37",
-    "powerpc64le-linux-gnu.2.38",
-    "powerpc64-linux-gnu.2.32",
-    "powerpc64-linux-gnu.2.33",
-    "powerpc64-linux-gnu.2.34",
-    "powerpc64-linux-gnu.2.35",
-    "powerpc64-linux-gnu.2.36",
-    "powerpc64-linux-gnu.2.37",
-    "powerpc64-linux-gnu.2.38",
-    "(defined __PPC64__ AND defined __GLIBC__)", // FIXME
-},
-
-powerpc_linux_gnu: []const []const u8 = &[_][]const u8{
-    "powerpc-linux-gnu.2.32",
-    "powerpc-linux-gnu.2.33",
-    "powerpc-linux-gnu.2.34",
-    "powerpc-linux-gnu.2.35",
-    "powerpc-linux-gnu.2.36",
-    "powerpc-linux-gnu.2.37",
-    "powerpc-linux-gnu.2.38",
-    "powerpc-linux-gnu-power4.2.32",
-    "powerpc-linux-gnu-power4.2.33",
-    "powerpc-linux-gnu-power4.2.34",
-    "powerpc-linux-gnu-power4.2.35",
-    "powerpc-linux-gnu-power4.2.36",
-    "powerpc-linux-gnu-power4.2.37",
-    "powerpc-linux-gnu-power4.2.38",
-    "powerpc-linux-gnu-soft.2.32",
-    "powerpc-linux-gnu-soft.2.33",
-    "powerpc-linux-gnu-soft.2.34",
-    "powerpc-linux-gnu-soft.2.35",
-    "powerpc-linux-gnu-soft.2.36",
-    "powerpc-linux-gnu-soft.2.37",
-    "powerpc-linux-gnu-soft.2.38",
-    "(defined __PPC__ AND defined __GLIBC__)", // FIXME
-},
-
-riscv32_linux_gnu: []const []const u8 = &[_][]const u8{
-    "riscv32-linux-gnu-rv32imac-ilp32.2.33",
-    "riscv32-linux-gnu-rv32imac-ilp32.2.34",
-    "riscv32-linux-gnu-rv32imac-ilp32.2.35",
-    "riscv32-linux-gnu-rv32imac-ilp32.2.36",
-    "riscv32-linux-gnu-rv32imac-ilp32.2.37",
-    "riscv32-linux-gnu-rv32imac-ilp32.2.38",
-    "riscv32-linux-gnu-rv32imafdc-ilp32.2.33",
-    "riscv32-linux-gnu-rv32imafdc-ilp32.2.34",
-    "riscv32-linux-gnu-rv32imafdc-ilp32.2.35",
-    "riscv32-linux-gnu-rv32imafdc-ilp32.2.36",
-    "riscv32-linux-gnu-rv32imafdc-ilp32.2.37",
-    "riscv32-linux-gnu-rv32imafdc-ilp32.2.38",
-    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.33",
-    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.34",
-    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.35",
-    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.36",
-    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.37",
-    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.38",
-    "(defined __RISCV32__ AND defined __GLIBC__)", // FIXME
-},
-
-riscv64_linux_gnu: []const []const u8 = &[_][]const u8{
-    "riscv64-linux-gnu-rv64imac-lp64.2.32",
-    "riscv64-linux-gnu-rv64imac-lp64.2.33",
-    "riscv64-linux-gnu-rv64imac-lp64.2.34",
-    "riscv64-linux-gnu-rv64imac-lp64.2.35",
-    "riscv64-linux-gnu-rv64imac-lp64.2.36",
-    "riscv64-linux-gnu-rv64imac-lp64.2.37",
-    "riscv64-linux-gnu-rv64imac-lp64.2.38",
-    "riscv64-linux-gnu-rv64imafdc-lp64.2.32",
-    "riscv64-linux-gnu-rv64imafdc-lp64.2.33",
-    "riscv64-linux-gnu-rv64imafdc-lp64.2.34",
-    "riscv64-linux-gnu-rv64imafdc-lp64.2.35",
-    "riscv64-linux-gnu-rv64imafdc-lp64.2.36",
-    "riscv64-linux-gnu-rv64imafdc-lp64.2.37",
-    "riscv64-linux-gnu-rv64imafdc-lp64.2.38",
-    "riscv64-linux-gnu-rv64imafdc-lp64d.2.32",
-    "riscv64-linux-gnu-rv64imafdc-lp64d.2.33",
-    "riscv64-linux-gnu-rv64imafdc-lp64d.2.34",
-    "riscv64-linux-gnu-rv64imafdc-lp64d.2.35",
-    "riscv64-linux-gnu-rv64imafdc-lp64d.2.36",
-    "riscv64-linux-gnu-rv64imafdc-lp64d.2.37",
-    "riscv64-linux-gnu-rv64imafdc-lp64d.2.38",
-    "(defined __RISCV64__ AND defined __GLIBC__)", // FIXME
-},
-
-s390x_linux_gnu: []const []const u8 = &[_][]const u8{
-    "s390x-linux-gnu.2.32",
-    "s390x-linux-gnu.2.33",
-    "s390x-linux-gnu.2.34",
-    "s390x-linux-gnu.2.35",
-    "s390x-linux-gnu.2.36",
-    "s390x-linux-gnu.2.37",
-    "s390x-linux-gnu.2.38",
-    "(defined __S390X__ AND defined __GLIBC__)", // FIXME
-},
-
-sparc64_linux_gnu: []const []const u8 = &[_][]const u8{
-    "sparc64-linux-gnu.2.32",
-    "sparc64-linux-gnu.2.33",
-    "sparc64-linux-gnu.2.34",
-    "sparc64-linux-gnu.2.35",
-    "sparc64-linux-gnu.2.36",
-    "sparc64-linux-gnu.2.37",
-    "sparc64-linux-gnu.2.38",
-    "(defined __SPARC64__ AND defined __GLIBC__)", // FIXME
-},
-
-sparcv8_linux_gnu: []const []const u8 = &[_][]const u8{
-    "sparcv8-linux-gnu-leon3.2.32",
-    "sparcv8-linux-gnu-leon3.2.33",
-    "sparcv8-linux-gnu-leon3.2.34",
-    "sparcv8-linux-gnu-leon3.2.35",
-    "sparcv8-linux-gnu-leon3.2.36",
-    "sparcv8-linux-gnu-leon3.2.37",
-    "sparcv8-linux-gnu-leon3.2.38",
-    "(defined __SPARCV8__ AND defined __GLIBC__)", // FIXME
-},
-
-sparcv9_linux_gnu: []const []const u8 = &[_][]const u8{
-    "sparcv9-linux-gnu.2.32",
-    "sparcv9-linux-gnu.2.33",
-    "sparcv9-linux-gnu.2.34",
-    "sparcv9-linux-gnu.2.35",
-    "sparcv9-linux-gnu.2.36",
-    "sparcv9-linux-gnu.2.37",
-    "sparcv9-linux-gnu.2.38",
-    "(defined __SPARCV9__ AND defined __GLIBC__)", // FIXME
-},
-
-x86_64_linux_gnu: []const []const u8 = &[_][]const u8{
-    "x86_64-linux-gnu.2.32",
-    "x86_64-linux-gnu.2.33",
-    "x86_64-linux-gnu.2.34",
-    "x86_64-linux-gnu.2.35",
-    "x86_64-linux-gnu.2.36",
-    "x86_64-linux-gnu.2.37",
-    "x86_64-linux-gnu.2.38",
-    "x86_64-linux-gnu-x32.2.32",
-    "x86_64-linux-gnu-x32.2.33",
-    "x86_64-linux-gnu-x32.2.34",
-    "x86_64-linux-gnu-x32.2.35",
-    "x86_64-linux-gnu-x32.2.36",
-    "x86_64-linux-gnu-x32.2.37",
-    "x86_64-linux-gnu-x32.2.38",
-    "(defined __X86_64__ AND defined __GLIBC__)", // FIXME
-},
-
-freebsd_gnu: []const []const u8 = &[_][]const u8{
-    "aarch64-freebsd.12.3-gnu",
-    "aarch64-freebsd.13.1-gnu",
-    "powerpc64-freebsd.12.3-gnu",
-    "powerpc64-freebsd.13.1-gnu",
-    "powerpc64le-freebsd.13.1-gnu",
-    "powerpc-freebsd.12.3-gnu",
-    "powerpc-freebsd.13.1-gnu",
-    "riscv64-freebsd.13.1-gnu",
-    "sparc64-freebsd.12.3-gnu",
-    "x86_64-freebsd.12.3-gnu",
-    "x86_64-freebsd.13.1-gnu",
-    "x86-freebsd.12.3-gnu",
-    "x86-freebsd.13.1-gnu",
-    "(defined __FreeBSD__ AND defined __GLIBC__)", // FIXME
-},
-
-freebsd_12_3: []const []const u8 = &[_][]const u8{
-    "aarch64-freebsd.12.3-gnu",
-    "powerpc64-freebsd.12.3-gnu",
-    "powerpc-freebsd.12.3-gnu",
-    "sparc64-freebsd.12.3-gnu",
-    "x86_64-freebsd.12.3-gnu",
-    "x86-freebsd.12.3-gnu",
-    "(__FreeBSD__ > 1203500 AND __FreeBSD__ < 1204000)",
-},
-
-freebsd_13_1: []const []const u8 = &[_][]const u8{
-    "aarch64-freebsd.13.1-gnu",
-    "powerpc64-freebsd.13.1-gnu",
-    "powerpc64le-freebsd.13.1-gnu",
-    "powerpc-freebsd.13.1-gnu",
-    "riscv64-freebsd.13.1-gnu",
-    "x86_64-freebsd.13.1-gnu",
-    "x86-freebsd.13.1-gnu",
-    "(__FreeBSD__ > 1301000 AND __FreeBSD__ < 1302000)",
-},
-
-macos: []const []const u8 = &[_][]const u8{
-    "aarch64-macos.11-none",
-    "aarch64-macos.12-none",
-    "aarch64-macos.13-none",
-    "x86_64-macos.11-none",
-    "x86_64-macos.12-none",
-    "x86_64-macos.13-none",
-    "defined __MACOS__", // FIXME
-},
-
-musl: []const []const u8 = &[_][]const u8{
-    "aarch64-linux-musl",
-    "arm-linux-musl",
-    "i386-linux-musl",
-    "mips64-linux-musl",
-    "mips-linux-musl",
-    "powerpc64-linux-musl",
-    "powerpc-linux-musl",
-    "riscv64-linux-musl",
-    "x86_64-linux-musl",
-    "defined __MUSL__", // FIXME
-},
+// For each field in this file, if all of the given versions are in the same
+// #if line, we replace it with the final line
+//aarch64_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "aarch64_be-linux-gnu.2.32",
+//    "aarch64_be-linux-gnu.2.33",
+//    "aarch64_be-linux-gnu.2.34",
+//    "aarch64_be-linux-gnu.2.35",
+//    "aarch64_be-linux-gnu.2.36",
+//    "aarch64_be-linux-gnu.2.37",
+//    "aarch64_be-linux-gnu.2.38",
+//    "aarch64-linux-gnu.2.32",
+//    "aarch64-linux-gnu.2.33",
+//    "aarch64-linux-gnu.2.34",
+//    "aarch64-linux-gnu.2.35",
+//    "aarch64-linux-gnu.2.36",
+//    "aarch64-linux-gnu.2.37",
+//    "aarch64-linux-gnu.2.38",
+//    "(defined __aarch64__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//arc_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "arc-linux-gnu.2.32",
+//    "arc-linux-gnu.2.33",
+//    "arc-linux-gnu.2.34",
+//    "arc-linux-gnu.2.35",
+//    "arc-linux-gnu.2.36",
+//    "arc-linux-gnu.2.37",
+//    "arc-linux-gnu.2.38",
+//    "arc-linux-gnuhf.2.32",
+//    "arc-linux-gnuhf.2.33",
+//    "arc-linux-gnuhf.2.34",
+//    "arc-linux-gnuhf.2.35",
+//    "arc-linux-gnuhf.2.36",
+//    "arc-linux-gnuhf.2.37",
+//    "arc-linux-gnuhf.2.38",
+//    "(defined __arc__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//arm_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "armeb-linux-gnueabi.2.32",
+//    "armeb-linux-gnueabi.2.33",
+//    "armeb-linux-gnueabi.2.34",
+//    "armeb-linux-gnueabi.2.35",
+//    "armeb-linux-gnueabi.2.36",
+//    "armeb-linux-gnueabi.2.37",
+//    "armeb-linux-gnueabi.2.38",
+//    "armeb-linux-gnueabihf.2.32",
+//    "armeb-linux-gnueabihf.2.33",
+//    "armeb-linux-gnueabihf.2.34",
+//    "armeb-linux-gnueabihf.2.35",
+//    "armeb-linux-gnueabihf.2.36",
+//    "armeb-linux-gnueabihf.2.37",
+//    "armeb-linux-gnueabihf.2.38",
+//    "arm-linux-gnueabi.2.32",
+//    "arm-linux-gnueabi.2.33",
+//    "arm-linux-gnueabi.2.34",
+//    "arm-linux-gnueabi.2.35",
+//    "arm-linux-gnueabi.2.36",
+//    "arm-linux-gnueabi.2.37",
+//    "arm-linux-gnueabi.2.38",
+//    "arm-linux-gnueabihf.2.32",
+//    "arm-linux-gnueabihf.2.33",
+//    "arm-linux-gnueabihf.2.34",
+//    "arm-linux-gnueabihf.2.35",
+//    "arm-linux-gnueabihf.2.36",
+//    "arm-linux-gnueabihf.2.37",
+//    "arm-linux-gnueabihf.2.38",
+//    "arm-linux-gnueabihf-v7a.2.32",
+//    "arm-linux-gnueabihf-v7a.2.33",
+//    "arm-linux-gnueabihf-v7a.2.34",
+//    "arm-linux-gnueabihf-v7a.2.35",
+//    "arm-linux-gnueabihf-v7a.2.36",
+//    "arm-linux-gnueabihf-v7a.2.37",
+//    "arm-linux-gnueabihf-v7a.2.38",
+//    "arm-linux-gnueabi-v4t.2.32",
+//    "arm-linux-gnueabi-v4t.2.33",
+//    "arm-linux-gnueabi-v4t.2.34",
+//    "arm-linux-gnueabi-v4t.2.35",
+//    "arm-linux-gnueabi-v4t.2.36",
+//    "arm-linux-gnueabi-v4t.2.37",
+//    "arm-linux-gnueabi-v4t.2.38",
+//    "(defined __arm__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//csky_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "csky-linux-gnuabiv2.2.33",
+//    "csky-linux-gnuabiv2.2.34",
+//    "csky-linux-gnuabiv2.2.35",
+//    "csky-linux-gnuabiv2.2.36",
+//    "csky-linux-gnuabiv2.2.37",
+//    "csky-linux-gnuabiv2.2.38",
+//    "csky-linux-gnuabiv2-soft.2.33",
+//    "csky-linux-gnuabiv2-soft.2.34",
+//    "csky-linux-gnuabiv2-soft.2.35",
+//    "csky-linux-gnuabiv2-soft.2.36",
+//    "csky-linux-gnuabiv2-soft.2.37",
+//    "csky-linux-gnuabiv2-soft.2.38",
+//    "(defined __csky__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//i_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "i486-linux-gnu.2.32",
+//    "i486-linux-gnu.2.33",
+//    "i486-linux-gnu.2.34",
+//    "i486-linux-gnu.2.35",
+//    "i486-linux-gnu.2.36",
+//    "i486-linux-gnu.2.37",
+//    "i486-linux-gnu.2.38",
+//    "i586-linux-gnu.2.32",
+//    "i586-linux-gnu.2.33",
+//    "i586-linux-gnu.2.34",
+//    "i586-linux-gnu.2.35",
+//    "i586-linux-gnu.2.36",
+//    "i586-linux-gnu.2.37",
+//    "i586-linux-gnu.2.38",
+//    "i686-linux-gnu.2.32",
+//    "i686-linux-gnu.2.33",
+//    "i686-linux-gnu.2.34",
+//    "i686-linux-gnu.2.35",
+//    "i686-linux-gnu.2.36",
+//    "i686-linux-gnu.2.37",
+//    "i686-linux-gnu.2.38",
+//    "ia64-linux-gnu.2.32",
+//    "ia64-linux-gnu.2.33",
+//    "ia64-linux-gnu.2.34",
+//    "ia64-linux-gnu.2.35",
+//    "ia64-linux-gnu.2.36",
+//    "ia64-linux-gnu.2.37",
+//    "ia64-linux-gnu.2.38",
+//    "(defined __ISOME__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//m68k_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "m68k-linux-gnu.2.32",
+//    "m68k-linux-gnu.2.33",
+//    "m68k-linux-gnu.2.34",
+//    "m68k-linux-gnu.2.35",
+//    "m68k-linux-gnu.2.36",
+//    "m68k-linux-gnu.2.37",
+//    "m68k-linux-gnu.2.38",
+//    "(defined __M68K__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//mips64_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "mips64el-linux-gnu-n32.2.32",
+//    "mips64el-linux-gnu-n32.2.33",
+//    "mips64el-linux-gnu-n32.2.34",
+//    "mips64el-linux-gnu-n32.2.35",
+//    "mips64el-linux-gnu-n32.2.36",
+//    "mips64el-linux-gnu-n32.2.37",
+//    "mips64el-linux-gnu-n32.2.38",
+//    "mips64el-linux-gnu-n32-nan2008.2.32",
+//    "mips64el-linux-gnu-n32-nan2008.2.33",
+//    "mips64el-linux-gnu-n32-nan2008.2.34",
+//    "mips64el-linux-gnu-n32-nan2008.2.35",
+//    "mips64el-linux-gnu-n32-nan2008.2.36",
+//    "mips64el-linux-gnu-n32-nan2008.2.37",
+//    "mips64el-linux-gnu-n32-nan2008.2.38",
+//    "mips64el-linux-gnu-n32-nan2008-soft.2.32",
+//    "mips64el-linux-gnu-n32-nan2008-soft.2.33",
+//    "mips64el-linux-gnu-n32-nan2008-soft.2.34",
+//    "mips64el-linux-gnu-n32-nan2008-soft.2.35",
+//    "mips64el-linux-gnu-n32-nan2008-soft.2.36",
+//    "mips64el-linux-gnu-n32-nan2008-soft.2.37",
+//    "mips64el-linux-gnu-n32-nan2008-soft.2.38",
+//    "mips64el-linux-gnu-n32-soft.2.32",
+//    "mips64el-linux-gnu-n32-soft.2.33",
+//    "mips64el-linux-gnu-n32-soft.2.34",
+//    "mips64el-linux-gnu-n32-soft.2.35",
+//    "mips64el-linux-gnu-n32-soft.2.36",
+//    "mips64el-linux-gnu-n32-soft.2.37",
+//    "mips64el-linux-gnu-n32-soft.2.38",
+//    "mips64el-linux-gnu-n64.2.32",
+//    "mips64el-linux-gnu-n64.2.33",
+//    "mips64el-linux-gnu-n64.2.34",
+//    "mips64el-linux-gnu-n64.2.35",
+//    "mips64el-linux-gnu-n64.2.36",
+//    "mips64el-linux-gnu-n64.2.37",
+//    "mips64el-linux-gnu-n64.2.38",
+//    "mips64el-linux-gnu-n64-nan2008.2.32",
+//    "mips64el-linux-gnu-n64-nan2008.2.33",
+//    "mips64el-linux-gnu-n64-nan2008.2.34",
+//    "mips64el-linux-gnu-n64-nan2008.2.35",
+//    "mips64el-linux-gnu-n64-nan2008.2.36",
+//    "mips64el-linux-gnu-n64-nan2008.2.37",
+//    "mips64el-linux-gnu-n64-nan2008.2.38",
+//    "mips64el-linux-gnu-n64-nan2008-soft.2.32",
+//    "mips64el-linux-gnu-n64-nan2008-soft.2.33",
+//    "mips64el-linux-gnu-n64-nan2008-soft.2.34",
+//    "mips64el-linux-gnu-n64-nan2008-soft.2.35",
+//    "mips64el-linux-gnu-n64-nan2008-soft.2.36",
+//    "mips64el-linux-gnu-n64-nan2008-soft.2.37",
+//    "mips64el-linux-gnu-n64-nan2008-soft.2.38",
+//    "mips64el-linux-gnu-n64-soft.2.32",
+//    "mips64el-linux-gnu-n64-soft.2.33",
+//    "mips64el-linux-gnu-n64-soft.2.34",
+//    "mips64el-linux-gnu-n64-soft.2.35",
+//    "mips64el-linux-gnu-n64-soft.2.36",
+//    "mips64el-linux-gnu-n64-soft.2.37",
+//    "mips64el-linux-gnu-n64-soft.2.38",
+//    "mips64-linux-gnu-n32.2.32",
+//    "mips64-linux-gnu-n32.2.33",
+//    "mips64-linux-gnu-n32.2.34",
+//    "mips64-linux-gnu-n32.2.35",
+//    "mips64-linux-gnu-n32.2.36",
+//    "mips64-linux-gnu-n32.2.37",
+//    "mips64-linux-gnu-n32.2.38",
+//    "mips64-linux-gnu-n32-nan2008.2.32",
+//    "mips64-linux-gnu-n32-nan2008.2.33",
+//    "mips64-linux-gnu-n32-nan2008.2.34",
+//    "mips64-linux-gnu-n32-nan2008.2.35",
+//    "mips64-linux-gnu-n32-nan2008.2.36",
+//    "mips64-linux-gnu-n32-nan2008.2.37",
+//    "mips64-linux-gnu-n32-nan2008.2.38",
+//    "mips64-linux-gnu-n32-nan2008-soft.2.32",
+//    "mips64-linux-gnu-n32-nan2008-soft.2.33",
+//    "mips64-linux-gnu-n32-nan2008-soft.2.34",
+//    "mips64-linux-gnu-n32-nan2008-soft.2.35",
+//    "mips64-linux-gnu-n32-nan2008-soft.2.36",
+//    "mips64-linux-gnu-n32-nan2008-soft.2.37",
+//    "mips64-linux-gnu-n32-nan2008-soft.2.38",
+//    "mips64-linux-gnu-n32-soft.2.32",
+//    "mips64-linux-gnu-n32-soft.2.33",
+//    "mips64-linux-gnu-n32-soft.2.34",
+//    "mips64-linux-gnu-n32-soft.2.35",
+//    "mips64-linux-gnu-n32-soft.2.36",
+//    "mips64-linux-gnu-n32-soft.2.37",
+//    "mips64-linux-gnu-n32-soft.2.38",
+//    "mips64-linux-gnu-n64.2.32",
+//    "mips64-linux-gnu-n64.2.33",
+//    "mips64-linux-gnu-n64.2.34",
+//    "mips64-linux-gnu-n64.2.35",
+//    "mips64-linux-gnu-n64.2.36",
+//    "mips64-linux-gnu-n64.2.37",
+//    "mips64-linux-gnu-n64.2.38",
+//    "mips64-linux-gnu-n64-nan2008.2.32",
+//    "mips64-linux-gnu-n64-nan2008.2.33",
+//    "mips64-linux-gnu-n64-nan2008.2.34",
+//    "mips64-linux-gnu-n64-nan2008.2.35",
+//    "mips64-linux-gnu-n64-nan2008.2.36",
+//    "mips64-linux-gnu-n64-nan2008.2.37",
+//    "mips64-linux-gnu-n64-nan2008.2.38",
+//    "mips64-linux-gnu-n64-nan2008-soft.2.32",
+//    "mips64-linux-gnu-n64-nan2008-soft.2.33",
+//    "mips64-linux-gnu-n64-nan2008-soft.2.34",
+//    "mips64-linux-gnu-n64-nan2008-soft.2.35",
+//    "mips64-linux-gnu-n64-nan2008-soft.2.36",
+//    "mips64-linux-gnu-n64-nan2008-soft.2.37",
+//    "mips64-linux-gnu-n64-nan2008-soft.2.38",
+//    "mips64-linux-gnu-n64-soft.2.32",
+//    "mips64-linux-gnu-n64-soft.2.33",
+//    "mips64-linux-gnu-n64-soft.2.34",
+//    "mips64-linux-gnu-n64-soft.2.35",
+//    "mips64-linux-gnu-n64-soft.2.36",
+//    "mips64-linux-gnu-n64-soft.2.37",
+//    "mips64-linux-gnu-n64-soft.2.38",
+//    "(defined __MIPS64__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//mipsel_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "mipsel-linux-gnu.2.32",
+//    "mipsel-linux-gnu.2.33",
+//    "mipsel-linux-gnu.2.34",
+//    "mipsel-linux-gnu.2.35",
+//    "mipsel-linux-gnu.2.36",
+//    "mipsel-linux-gnu.2.37",
+//    "mipsel-linux-gnu.2.38",
+//    "mipsel-linux-gnu-nan2008.2.32",
+//    "mipsel-linux-gnu-nan2008.2.33",
+//    "mipsel-linux-gnu-nan2008.2.34",
+//    "mipsel-linux-gnu-nan2008.2.35",
+//    "mipsel-linux-gnu-nan2008.2.36",
+//    "mipsel-linux-gnu-nan2008.2.37",
+//    "mipsel-linux-gnu-nan2008.2.38",
+//    "mipsel-linux-gnu-nan2008-soft.2.32",
+//    "mipsel-linux-gnu-nan2008-soft.2.33",
+//    "mipsel-linux-gnu-nan2008-soft.2.34",
+//    "mipsel-linux-gnu-nan2008-soft.2.35",
+//    "mipsel-linux-gnu-nan2008-soft.2.36",
+//    "mipsel-linux-gnu-nan2008-soft.2.37",
+//    "mipsel-linux-gnu-nan2008-soft.2.38",
+//    "mipsel-linux-gnu-soft.2.32",
+//    "mipsel-linux-gnu-soft.2.33",
+//    "mipsel-linux-gnu-soft.2.34",
+//    "mipsel-linux-gnu-soft.2.35",
+//    "mipsel-linux-gnu-soft.2.36",
+//    "mipsel-linux-gnu-soft.2.37",
+//    "mipsel-linux-gnu-soft.2.38",
+//    "mipsisa32r6el-linux-gnu.2.32",
+//    "mipsisa32r6el-linux-gnu.2.33",
+//    "mipsisa32r6el-linux-gnu.2.34",
+//    "mipsisa32r6el-linux-gnu.2.35",
+//    "mipsisa32r6el-linux-gnu.2.36",
+//    "mipsisa32r6el-linux-gnu.2.37",
+//    "mipsisa32r6el-linux-gnu.2.38",
+//    "mipsisa64r6el-linux-gnu-n32.2.32",
+//    "mipsisa64r6el-linux-gnu-n32.2.33",
+//    "mipsisa64r6el-linux-gnu-n32.2.34",
+//    "mipsisa64r6el-linux-gnu-n32.2.35",
+//    "mipsisa64r6el-linux-gnu-n32.2.36",
+//    "mipsisa64r6el-linux-gnu-n32.2.37",
+//    "mipsisa64r6el-linux-gnu-n32.2.38",
+//    "mipsisa64r6el-linux-gnu-n64.2.32",
+//    "mipsisa64r6el-linux-gnu-n64.2.33",
+//    "mipsisa64r6el-linux-gnu-n64.2.34",
+//    "mipsisa64r6el-linux-gnu-n64.2.35",
+//    "mipsisa64r6el-linux-gnu-n64.2.36",
+//    "mipsisa64r6el-linux-gnu-n64.2.37",
+//    "mipsisa64r6el-linux-gnu-n64.2.38",
+//    "(defined __MIPSEL__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//mips_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "mips-linux-gnu.2.32",
+//    "mips-linux-gnu.2.33",
+//    "mips-linux-gnu.2.34",
+//    "mips-linux-gnu.2.35",
+//    "mips-linux-gnu.2.36",
+//    "mips-linux-gnu.2.37",
+//    "mips-linux-gnu.2.38",
+//    "mips-linux-gnu-nan2008.2.32",
+//    "mips-linux-gnu-nan2008.2.33",
+//    "mips-linux-gnu-nan2008.2.34",
+//    "mips-linux-gnu-nan2008.2.35",
+//    "mips-linux-gnu-nan2008.2.36",
+//    "mips-linux-gnu-nan2008.2.37",
+//    "mips-linux-gnu-nan2008.2.38",
+//    "mips-linux-gnu-nan2008-soft.2.32",
+//    "mips-linux-gnu-nan2008-soft.2.33",
+//    "mips-linux-gnu-nan2008-soft.2.34",
+//    "mips-linux-gnu-nan2008-soft.2.35",
+//    "mips-linux-gnu-nan2008-soft.2.36",
+//    "mips-linux-gnu-nan2008-soft.2.37",
+//    "mips-linux-gnu-nan2008-soft.2.38",
+//    "mips-linux-gnu-soft.2.32",
+//    "mips-linux-gnu-soft.2.33",
+//    "mips-linux-gnu-soft.2.34",
+//    "mips-linux-gnu-soft.2.35",
+//    "mips-linux-gnu-soft.2.36",
+//    "mips-linux-gnu-soft.2.37",
+//    "mips-linux-gnu-soft.2.38",
+//    "(defined __MIPS__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//powerpc64_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "powerpc64le-linux-gnu.2.32",
+//    "powerpc64le-linux-gnu.2.33",
+//    "powerpc64le-linux-gnu.2.34",
+//    "powerpc64le-linux-gnu.2.35",
+//    "powerpc64le-linux-gnu.2.36",
+//    "powerpc64le-linux-gnu.2.37",
+//    "powerpc64le-linux-gnu.2.38",
+//    "powerpc64-linux-gnu.2.32",
+//    "powerpc64-linux-gnu.2.33",
+//    "powerpc64-linux-gnu.2.34",
+//    "powerpc64-linux-gnu.2.35",
+//    "powerpc64-linux-gnu.2.36",
+//    "powerpc64-linux-gnu.2.37",
+//    "powerpc64-linux-gnu.2.38",
+//    "(defined __PPC64__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//powerpc_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "powerpc-linux-gnu.2.32",
+//    "powerpc-linux-gnu.2.33",
+//    "powerpc-linux-gnu.2.34",
+//    "powerpc-linux-gnu.2.35",
+//    "powerpc-linux-gnu.2.36",
+//    "powerpc-linux-gnu.2.37",
+//    "powerpc-linux-gnu.2.38",
+//    "powerpc-linux-gnu-power4.2.32",
+//    "powerpc-linux-gnu-power4.2.33",
+//    "powerpc-linux-gnu-power4.2.34",
+//    "powerpc-linux-gnu-power4.2.35",
+//    "powerpc-linux-gnu-power4.2.36",
+//    "powerpc-linux-gnu-power4.2.37",
+//    "powerpc-linux-gnu-power4.2.38",
+//    "powerpc-linux-gnu-soft.2.32",
+//    "powerpc-linux-gnu-soft.2.33",
+//    "powerpc-linux-gnu-soft.2.34",
+//    "powerpc-linux-gnu-soft.2.35",
+//    "powerpc-linux-gnu-soft.2.36",
+//    "powerpc-linux-gnu-soft.2.37",
+//    "powerpc-linux-gnu-soft.2.38",
+//    "(defined __PPC__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//riscv32_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "riscv32-linux-gnu-rv32imac-ilp32.2.33",
+//    "riscv32-linux-gnu-rv32imac-ilp32.2.34",
+//    "riscv32-linux-gnu-rv32imac-ilp32.2.35",
+//    "riscv32-linux-gnu-rv32imac-ilp32.2.36",
+//    "riscv32-linux-gnu-rv32imac-ilp32.2.37",
+//    "riscv32-linux-gnu-rv32imac-ilp32.2.38",
+//    "riscv32-linux-gnu-rv32imafdc-ilp32.2.33",
+//    "riscv32-linux-gnu-rv32imafdc-ilp32.2.34",
+//    "riscv32-linux-gnu-rv32imafdc-ilp32.2.35",
+//    "riscv32-linux-gnu-rv32imafdc-ilp32.2.36",
+//    "riscv32-linux-gnu-rv32imafdc-ilp32.2.37",
+//    "riscv32-linux-gnu-rv32imafdc-ilp32.2.38",
+//    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.33",
+//    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.34",
+//    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.35",
+//    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.36",
+//    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.37",
+//    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.38",
+//    "(defined __RISCV32__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//riscv64_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "riscv64-linux-gnu-rv64imac-lp64.2.32",
+//    "riscv64-linux-gnu-rv64imac-lp64.2.33",
+//    "riscv64-linux-gnu-rv64imac-lp64.2.34",
+//    "riscv64-linux-gnu-rv64imac-lp64.2.35",
+//    "riscv64-linux-gnu-rv64imac-lp64.2.36",
+//    "riscv64-linux-gnu-rv64imac-lp64.2.37",
+//    "riscv64-linux-gnu-rv64imac-lp64.2.38",
+//    "riscv64-linux-gnu-rv64imafdc-lp64.2.32",
+//    "riscv64-linux-gnu-rv64imafdc-lp64.2.33",
+//    "riscv64-linux-gnu-rv64imafdc-lp64.2.34",
+//    "riscv64-linux-gnu-rv64imafdc-lp64.2.35",
+//    "riscv64-linux-gnu-rv64imafdc-lp64.2.36",
+//    "riscv64-linux-gnu-rv64imafdc-lp64.2.37",
+//    "riscv64-linux-gnu-rv64imafdc-lp64.2.38",
+//    "riscv64-linux-gnu-rv64imafdc-lp64d.2.32",
+//    "riscv64-linux-gnu-rv64imafdc-lp64d.2.33",
+//    "riscv64-linux-gnu-rv64imafdc-lp64d.2.34",
+//    "riscv64-linux-gnu-rv64imafdc-lp64d.2.35",
+//    "riscv64-linux-gnu-rv64imafdc-lp64d.2.36",
+//    "riscv64-linux-gnu-rv64imafdc-lp64d.2.37",
+//    "riscv64-linux-gnu-rv64imafdc-lp64d.2.38",
+//    "(defined __RISCV64__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//s390x_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "s390x-linux-gnu.2.32",
+//    "s390x-linux-gnu.2.33",
+//    "s390x-linux-gnu.2.34",
+//    "s390x-linux-gnu.2.35",
+//    "s390x-linux-gnu.2.36",
+//    "s390x-linux-gnu.2.37",
+//    "s390x-linux-gnu.2.38",
+//    "(defined __S390X__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//sparc64_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "sparc64-linux-gnu.2.32",
+//    "sparc64-linux-gnu.2.33",
+//    "sparc64-linux-gnu.2.34",
+//    "sparc64-linux-gnu.2.35",
+//    "sparc64-linux-gnu.2.36",
+//    "sparc64-linux-gnu.2.37",
+//    "sparc64-linux-gnu.2.38",
+//    "(defined __SPARC64__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//sparcv8_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "sparcv8-linux-gnu-leon3.2.32",
+//    "sparcv8-linux-gnu-leon3.2.33",
+//    "sparcv8-linux-gnu-leon3.2.34",
+//    "sparcv8-linux-gnu-leon3.2.35",
+//    "sparcv8-linux-gnu-leon3.2.36",
+//    "sparcv8-linux-gnu-leon3.2.37",
+//    "sparcv8-linux-gnu-leon3.2.38",
+//    "(defined __SPARCV8__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//sparcv9_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "sparcv9-linux-gnu.2.32",
+//    "sparcv9-linux-gnu.2.33",
+//    "sparcv9-linux-gnu.2.34",
+//    "sparcv9-linux-gnu.2.35",
+//    "sparcv9-linux-gnu.2.36",
+//    "sparcv9-linux-gnu.2.37",
+//    "sparcv9-linux-gnu.2.38",
+//    "(defined __SPARCV9__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//x86_64_linux_gnu: []const []const u8 = &[_][]const u8{
+//    "x86_64-linux-gnu.2.32",
+//    "x86_64-linux-gnu.2.33",
+//    "x86_64-linux-gnu.2.34",
+//    "x86_64-linux-gnu.2.35",
+//    "x86_64-linux-gnu.2.36",
+//    "x86_64-linux-gnu.2.37",
+//    "x86_64-linux-gnu.2.38",
+//    "x86_64-linux-gnu-x32.2.32",
+//    "x86_64-linux-gnu-x32.2.33",
+//    "x86_64-linux-gnu-x32.2.34",
+//    "x86_64-linux-gnu-x32.2.35",
+//    "x86_64-linux-gnu-x32.2.36",
+//    "x86_64-linux-gnu-x32.2.37",
+//    "x86_64-linux-gnu-x32.2.38",
+//    "(defined __X86_64__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//freebsd_gnu: []const []const u8 = &[_][]const u8{
+//    "aarch64-freebsd.12.3-gnu",
+//    "aarch64-freebsd.13.1-gnu",
+//    "powerpc64-freebsd.12.3-gnu",
+//    "powerpc64-freebsd.13.1-gnu",
+//    "powerpc64le-freebsd.13.1-gnu",
+//    "powerpc-freebsd.12.3-gnu",
+//    "powerpc-freebsd.13.1-gnu",
+//    "riscv64-freebsd.13.1-gnu",
+//    "sparc64-freebsd.12.3-gnu",
+//    "x86_64-freebsd.12.3-gnu",
+//    "x86_64-freebsd.13.1-gnu",
+//    "x86-freebsd.12.3-gnu",
+//    "x86-freebsd.13.1-gnu",
+//    "(defined __FreeBSD__ AND defined __GLIBC__)", // FIXME
+//},
+//
+//freebsd_12_3: []const []const u8 = &[_][]const u8{
+//    "aarch64-freebsd.12.3-gnu",
+//    "powerpc64-freebsd.12.3-gnu",
+//    "powerpc-freebsd.12.3-gnu",
+//    "sparc64-freebsd.12.3-gnu",
+//    "x86_64-freebsd.12.3-gnu",
+//    "x86-freebsd.12.3-gnu",
+//    "(__FreeBSD__ > 1203500 AND __FreeBSD__ < 1204000)",
+//},
+//
+//freebsd_13_1: []const []const u8 = &[_][]const u8{
+//    "aarch64-freebsd.13.1-gnu",
+//    "powerpc64-freebsd.13.1-gnu",
+//    "powerpc64le-freebsd.13.1-gnu",
+//    "powerpc-freebsd.13.1-gnu",
+//    "riscv64-freebsd.13.1-gnu",
+//    "x86_64-freebsd.13.1-gnu",
+//    "x86-freebsd.13.1-gnu",
+//    "(__FreeBSD__ > 1301000 AND __FreeBSD__ < 1302000)",
+//},
+//
+//macos: []const []const u8 = &[_][]const u8{
+//    "aarch64-macos.11-none",
+//    "aarch64-macos.12-none",
+//    "aarch64-macos.13-none",
+//    "x86_64-macos.11-none",
+//    "x86_64-macos.12-none",
+//    "x86_64-macos.13-none",
+//    "defined __MACOS__", // FIXME
+//},
+//
+//musl: []const []const u8 = &[_][]const u8{
+//    "aarch64-linux-musl",
+//    "arm-linux-musl",
+//    "i386-linux-musl",
+//    "mips64-linux-musl",
+//    "mips-linux-musl",
+//    "powerpc64-linux-musl",
+//    "powerpc-linux-musl",
+//    "riscv64-linux-musl",
+//    "x86_64-linux-musl",
+//    "defined __MUSL__", // FIXME
+//},
 
 gnu_2_32: []const []const u8 = &[_][]const u8{
     "aarch64_be-linux-gnu.2.32",
@@ -951,398 +951,58 @@ gnu_2_38: []const []const u8 = &[_][]const u8{
     "arm-linux-gnueabihf.2.38",
     "arm-linux-gnueabihf-v7a.2.38",
     "arm-linux-gnueabi-v4t.2.38",
-    "csky-linux-gnuabiv2.2.38",
-    "csky-linux-gnuabiv2-soft.2.38",
-    "i486-linux-gnu.2.38",
-    "i586-linux-gnu.2.38",
-    "i686-linux-gnu.2.38",
-    "ia64-linux-gnu.2.38",
-    "m68k-linux-gnu.2.38",
-    "mips64el-linux-gnu-n32.2.38",
-    "mips64el-linux-gnu-n32-nan2008.2.38",
-    "mips64el-linux-gnu-n32-nan2008-soft.2.38",
-    "mips64el-linux-gnu-n32-soft.2.38",
-    "mips64el-linux-gnu-n64.2.38",
-    "mips64el-linux-gnu-n64-nan2008.2.38",
-    "mips64el-linux-gnu-n64-nan2008-soft.2.38",
-    "mips64el-linux-gnu-n64-soft.2.38",
-    "mips64-linux-gnu-n32.2.38",
-    "mips64-linux-gnu-n32-nan2008.2.38",
-    "mips64-linux-gnu-n32-nan2008-soft.2.38",
-    "mips64-linux-gnu-n32-soft.2.38",
-    "mips64-linux-gnu-n64.2.38",
-    "mips64-linux-gnu-n64-nan2008.2.38",
-    "mips64-linux-gnu-n64-nan2008-soft.2.38",
-    "mips64-linux-gnu-n64-soft.2.38",
-    "mipsel-linux-gnu.2.38",
-    "mipsel-linux-gnu-nan2008.2.38",
-    "mipsel-linux-gnu-nan2008-soft.2.38",
-    "mipsel-linux-gnu-soft.2.38",
-    "mipsisa32r6el-linux-gnu.2.38",
-    "mipsisa64r6el-linux-gnu-n32.2.38",
-    "mipsisa64r6el-linux-gnu-n64.2.38",
-    "mips-linux-gnu.2.38",
-    "mips-linux-gnu-nan2008.2.38",
-    "mips-linux-gnu-nan2008-soft.2.38",
-    "mips-linux-gnu-soft.2.38",
-    "powerpc64le-linux-gnu.2.38",
-    "powerpc64-linux-gnu.2.38",
-    "powerpc-linux-gnu.2.38",
-    "powerpc-linux-gnu-power4.2.38",
-    "powerpc-linux-gnu-soft.2.38",
-    "riscv32-linux-gnu-rv32imac-ilp32.2.38",
-    "riscv32-linux-gnu-rv32imafdc-ilp32.2.38",
-    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.38",
-    "riscv64-linux-gnu-rv64imac-lp64.2.38",
-    "riscv64-linux-gnu-rv64imafdc-lp64.2.38",
-    "riscv64-linux-gnu-rv64imafdc-lp64d.2.38",
-    "s390x-linux-gnu.2.38",
-    "sparc64-linux-gnu.2.38",
-    "sparcv8-linux-gnu-leon3.2.38",
-    "sparcv9-linux-gnu.2.38",
-    "x86_64-linux-gnu.2.38",
-    "x86_64-linux-gnu-x32.2.38",
-    "__GLIBC_MINOR__ == 38",
-},
-
-gnu_not_2_32: []const []const u8 = &[_][]const u8{
-    "aarch64_be-linux-gnu.2.33",
-    "aarch64_be-linux-gnu.2.34",
-    "aarch64_be-linux-gnu.2.35",
-    "aarch64_be-linux-gnu.2.36",
-    "aarch64_be-linux-gnu.2.37",
-    "aarch64_be-linux-gnu.2.38",
-    "aarch64-linux-gnu.2.33",
-    "aarch64-linux-gnu.2.34",
-    "aarch64-linux-gnu.2.35",
-    "aarch64-linux-gnu.2.36",
-    "aarch64-linux-gnu.2.37",
-    "aarch64-linux-gnu.2.38",
-    "arc-linux-gnu.2.33",
-    "arc-linux-gnu.2.34",
-    "arc-linux-gnu.2.35",
-    "arc-linux-gnu.2.36",
-    "arc-linux-gnu.2.37",
-    "arc-linux-gnu.2.38",
-    "arc-linux-gnuhf.2.33",
-    "arc-linux-gnuhf.2.34",
-    "arc-linux-gnuhf.2.35",
-    "arc-linux-gnuhf.2.36",
-    "arc-linux-gnuhf.2.37",
-    "arc-linux-gnuhf.2.38",
-    "armeb-linux-gnueabi.2.33",
-    "armeb-linux-gnueabi.2.34",
-    "armeb-linux-gnueabi.2.35",
-    "armeb-linux-gnueabi.2.36",
-    "armeb-linux-gnueabi.2.37",
-    "armeb-linux-gnueabi.2.38",
-    "armeb-linux-gnueabihf.2.33",
-    "armeb-linux-gnueabihf.2.34",
-    "armeb-linux-gnueabihf.2.35",
-    "armeb-linux-gnueabihf.2.36",
-    "armeb-linux-gnueabihf.2.37",
-    "armeb-linux-gnueabihf.2.38",
-    "arm-linux-gnueabi.2.33",
-    "arm-linux-gnueabi.2.34",
-    "arm-linux-gnueabi.2.35",
-    "arm-linux-gnueabi.2.36",
-    "arm-linux-gnueabi.2.37",
-    "arm-linux-gnueabi.2.38",
-    "arm-linux-gnueabihf.2.33",
-    "arm-linux-gnueabihf.2.34",
-    "arm-linux-gnueabihf.2.35",
-    "arm-linux-gnueabihf.2.36",
-    "arm-linux-gnueabihf.2.37",
-    "arm-linux-gnueabihf.2.38",
-    "arm-linux-gnueabihf-v7a.2.33",
-    "arm-linux-gnueabihf-v7a.2.34",
-    "arm-linux-gnueabihf-v7a.2.35",
-    "arm-linux-gnueabihf-v7a.2.36",
-    "arm-linux-gnueabihf-v7a.2.37",
-    "arm-linux-gnueabihf-v7a.2.38",
-    "arm-linux-gnueabi-v4t.2.33",
-    "arm-linux-gnueabi-v4t.2.34",
-    "arm-linux-gnueabi-v4t.2.35",
-    "arm-linux-gnueabi-v4t.2.36",
-    "arm-linux-gnueabi-v4t.2.37",
-    "arm-linux-gnueabi-v4t.2.38",
-    "i486-linux-gnu.2.33",
-    "i486-linux-gnu.2.34",
-    "i486-linux-gnu.2.35",
-    "i486-linux-gnu.2.36",
-    "i486-linux-gnu.2.37",
+    "csky-linux-gnuabiv2.2.38",
+    "csky-linux-gnuabiv2-soft.2.38",
     "i486-linux-gnu.2.38",
-    "i586-linux-gnu.2.33",
-    "i586-linux-gnu.2.34",
-    "i586-linux-gnu.2.35",
-    "i586-linux-gnu.2.36",
-    "i586-linux-gnu.2.37",
     "i586-linux-gnu.2.38",
-    "i686-linux-gnu.2.33",
-    "i686-linux-gnu.2.34",
-    "i686-linux-gnu.2.35",
-    "i686-linux-gnu.2.36",
-    "i686-linux-gnu.2.37",
     "i686-linux-gnu.2.38",
-    "ia64-linux-gnu.2.33",
-    "ia64-linux-gnu.2.34",
-    "ia64-linux-gnu.2.35",
-    "ia64-linux-gnu.2.36",
-    "ia64-linux-gnu.2.37",
     "ia64-linux-gnu.2.38",
-    "m68k-linux-gnu.2.33",
-    "m68k-linux-gnu.2.34",
-    "m68k-linux-gnu.2.35",
-    "m68k-linux-gnu.2.36",
-    "m68k-linux-gnu.2.37",
     "m68k-linux-gnu.2.38",
-    "mips64el-linux-gnu-n32.2.33",
-    "mips64el-linux-gnu-n32.2.34",
-    "mips64el-linux-gnu-n32.2.35",
-    "mips64el-linux-gnu-n32.2.36",
-    "mips64el-linux-gnu-n32.2.37",
     "mips64el-linux-gnu-n32.2.38",
-    "mips64el-linux-gnu-n32-nan2008.2.33",
-    "mips64el-linux-gnu-n32-nan2008.2.34",
-    "mips64el-linux-gnu-n32-nan2008.2.35",
-    "mips64el-linux-gnu-n32-nan2008.2.36",
-    "mips64el-linux-gnu-n32-nan2008.2.37",
     "mips64el-linux-gnu-n32-nan2008.2.38",
-    "mips64el-linux-gnu-n32-nan2008-soft.2.33",
-    "mips64el-linux-gnu-n32-nan2008-soft.2.34",
-    "mips64el-linux-gnu-n32-nan2008-soft.2.35",
-    "mips64el-linux-gnu-n32-nan2008-soft.2.36",
-    "mips64el-linux-gnu-n32-nan2008-soft.2.37",
     "mips64el-linux-gnu-n32-nan2008-soft.2.38",
-    "mips64el-linux-gnu-n32-soft.2.33",
-    "mips64el-linux-gnu-n32-soft.2.34",
-    "mips64el-linux-gnu-n32-soft.2.35",
-    "mips64el-linux-gnu-n32-soft.2.36",
-    "mips64el-linux-gnu-n32-soft.2.37",
     "mips64el-linux-gnu-n32-soft.2.38",
-    "mips64el-linux-gnu-n64.2.33",
-    "mips64el-linux-gnu-n64.2.34",
-    "mips64el-linux-gnu-n64.2.35",
-    "mips64el-linux-gnu-n64.2.36",
-    "mips64el-linux-gnu-n64.2.37",
     "mips64el-linux-gnu-n64.2.38",
-    "mips64el-linux-gnu-n64-nan2008.2.33",
-    "mips64el-linux-gnu-n64-nan2008.2.34",
-    "mips64el-linux-gnu-n64-nan2008.2.35",
-    "mips64el-linux-gnu-n64-nan2008.2.36",
-    "mips64el-linux-gnu-n64-nan2008.2.37",
     "mips64el-linux-gnu-n64-nan2008.2.38",
-    "mips64el-linux-gnu-n64-nan2008-soft.2.33",
-    "mips64el-linux-gnu-n64-nan2008-soft.2.34",
-    "mips64el-linux-gnu-n64-nan2008-soft.2.35",
-    "mips64el-linux-gnu-n64-nan2008-soft.2.36",
-    "mips64el-linux-gnu-n64-nan2008-soft.2.37",
     "mips64el-linux-gnu-n64-nan2008-soft.2.38",
-    "mips64el-linux-gnu-n64-soft.2.33",
-    "mips64el-linux-gnu-n64-soft.2.34",
-    "mips64el-linux-gnu-n64-soft.2.35",
-    "mips64el-linux-gnu-n64-soft.2.36",
-    "mips64el-linux-gnu-n64-soft.2.37",
     "mips64el-linux-gnu-n64-soft.2.38",
-    "mips64-linux-gnu-n32.2.33",
-    "mips64-linux-gnu-n32.2.34",
-    "mips64-linux-gnu-n32.2.35",
-    "mips64-linux-gnu-n32.2.36",
-    "mips64-linux-gnu-n32.2.37",
     "mips64-linux-gnu-n32.2.38",
-    "mips64-linux-gnu-n32-nan2008.2.33",
-    "mips64-linux-gnu-n32-nan2008.2.34",
-    "mips64-linux-gnu-n32-nan2008.2.35",
-    "mips64-linux-gnu-n32-nan2008.2.36",
-    "mips64-linux-gnu-n32-nan2008.2.37",
     "mips64-linux-gnu-n32-nan2008.2.38",
-    "mips64-linux-gnu-n32-nan2008-soft.2.33",
-    "mips64-linux-gnu-n32-nan2008-soft.2.34",
-    "mips64-linux-gnu-n32-nan2008-soft.2.35",
-    "mips64-linux-gnu-n32-nan2008-soft.2.36",
-    "mips64-linux-gnu-n32-nan2008-soft.2.37",
     "mips64-linux-gnu-n32-nan2008-soft.2.38",
-    "mips64-linux-gnu-n32-soft.2.33",
-    "mips64-linux-gnu-n32-soft.2.34",
-    "mips64-linux-gnu-n32-soft.2.35",
-    "mips64-linux-gnu-n32-soft.2.36",
-    "mips64-linux-gnu-n32-soft.2.37",
     "mips64-linux-gnu-n32-soft.2.38",
-    "mips64-linux-gnu-n64.2.33",
-    "mips64-linux-gnu-n64.2.34",
-    "mips64-linux-gnu-n64.2.35",
-    "mips64-linux-gnu-n64.2.36",
-    "mips64-linux-gnu-n64.2.37",
     "mips64-linux-gnu-n64.2.38",
-    "mips64-linux-gnu-n64-nan2008.2.33",
-    "mips64-linux-gnu-n64-nan2008.2.34",
-    "mips64-linux-gnu-n64-nan2008.2.35",
-    "mips64-linux-gnu-n64-nan2008.2.36",
-    "mips64-linux-gnu-n64-nan2008.2.37",
     "mips64-linux-gnu-n64-nan2008.2.38",
-    "mips64-linux-gnu-n64-nan2008-soft.2.33",
-    "mips64-linux-gnu-n64-nan2008-soft.2.34",
-    "mips64-linux-gnu-n64-nan2008-soft.2.35",
-    "mips64-linux-gnu-n64-nan2008-soft.2.36",
-    "mips64-linux-gnu-n64-nan2008-soft.2.37",
     "mips64-linux-gnu-n64-nan2008-soft.2.38",
-    "mips64-linux-gnu-n64-soft.2.33",
-    "mips64-linux-gnu-n64-soft.2.34",
-    "mips64-linux-gnu-n64-soft.2.35",
-    "mips64-linux-gnu-n64-soft.2.36",
-    "mips64-linux-gnu-n64-soft.2.37",
     "mips64-linux-gnu-n64-soft.2.38",
-    "mipsel-linux-gnu.2.33",
-    "mipsel-linux-gnu.2.34",
-    "mipsel-linux-gnu.2.35",
-    "mipsel-linux-gnu.2.36",
-    "mipsel-linux-gnu.2.37",
     "mipsel-linux-gnu.2.38",
-    "mipsel-linux-gnu-nan2008.2.33",
-    "mipsel-linux-gnu-nan2008.2.34",
-    "mipsel-linux-gnu-nan2008.2.35",
-    "mipsel-linux-gnu-nan2008.2.36",
-    "mipsel-linux-gnu-nan2008.2.37",
     "mipsel-linux-gnu-nan2008.2.38",
-    "mipsel-linux-gnu-nan2008-soft.2.33",
-    "mipsel-linux-gnu-nan2008-soft.2.34",
-    "mipsel-linux-gnu-nan2008-soft.2.35",
-    "mipsel-linux-gnu-nan2008-soft.2.36",
-    "mipsel-linux-gnu-nan2008-soft.2.37",
     "mipsel-linux-gnu-nan2008-soft.2.38",
-    "mipsel-linux-gnu-soft.2.33",
-    "mipsel-linux-gnu-soft.2.34",
-    "mipsel-linux-gnu-soft.2.35",
-    "mipsel-linux-gnu-soft.2.36",
-    "mipsel-linux-gnu-soft.2.37",
     "mipsel-linux-gnu-soft.2.38",
-    "mipsisa32r6el-linux-gnu.2.33",
-    "mipsisa32r6el-linux-gnu.2.34",
-    "mipsisa32r6el-linux-gnu.2.35",
-    "mipsisa32r6el-linux-gnu.2.36",
-    "mipsisa32r6el-linux-gnu.2.37",
     "mipsisa32r6el-linux-gnu.2.38",
-    "mipsisa64r6el-linux-gnu-n32.2.33",
-    "mipsisa64r6el-linux-gnu-n32.2.34",
-    "mipsisa64r6el-linux-gnu-n32.2.35",
-    "mipsisa64r6el-linux-gnu-n32.2.36",
-    "mipsisa64r6el-linux-gnu-n32.2.37",
     "mipsisa64r6el-linux-gnu-n32.2.38",
-    "mipsisa64r6el-linux-gnu-n64.2.33",
-    "mipsisa64r6el-linux-gnu-n64.2.34",
-    "mipsisa64r6el-linux-gnu-n64.2.35",
-    "mipsisa64r6el-linux-gnu-n64.2.36",
-    "mipsisa64r6el-linux-gnu-n64.2.37",
     "mipsisa64r6el-linux-gnu-n64.2.38",
-    "mips-linux-gnu.2.33",
-    "mips-linux-gnu.2.34",
-    "mips-linux-gnu.2.35",
-    "mips-linux-gnu.2.36",
-    "mips-linux-gnu.2.37",
     "mips-linux-gnu.2.38",
-    "mips-linux-gnu-nan2008.2.33",
-    "mips-linux-gnu-nan2008.2.34",
-    "mips-linux-gnu-nan2008.2.35",
-    "mips-linux-gnu-nan2008.2.36",
-    "mips-linux-gnu-nan2008.2.37",
     "mips-linux-gnu-nan2008.2.38",
-    "mips-linux-gnu-nan2008-soft.2.33",
-    "mips-linux-gnu-nan2008-soft.2.34",
-    "mips-linux-gnu-nan2008-soft.2.35",
-    "mips-linux-gnu-nan2008-soft.2.36",
-    "mips-linux-gnu-nan2008-soft.2.37",
     "mips-linux-gnu-nan2008-soft.2.38",
-    "mips-linux-gnu-soft.2.33",
-    "mips-linux-gnu-soft.2.34",
-    "mips-linux-gnu-soft.2.35",
-    "mips-linux-gnu-soft.2.36",
-    "mips-linux-gnu-soft.2.37",
     "mips-linux-gnu-soft.2.38",
-    "powerpc64le-linux-gnu.2.33",
-    "powerpc64le-linux-gnu.2.34",
-    "powerpc64le-linux-gnu.2.35",
-    "powerpc64le-linux-gnu.2.36",
-    "powerpc64le-linux-gnu.2.37",
     "powerpc64le-linux-gnu.2.38",
-    "powerpc64-linux-gnu.2.33",
-    "powerpc64-linux-gnu.2.34",
-    "powerpc64-linux-gnu.2.35",
-    "powerpc64-linux-gnu.2.36",
-    "powerpc64-linux-gnu.2.37",
     "powerpc64-linux-gnu.2.38",
-    "powerpc-linux-gnu.2.33",
-    "powerpc-linux-gnu.2.34",
-    "powerpc-linux-gnu.2.35",
-    "powerpc-linux-gnu.2.36",
-    "powerpc-linux-gnu.2.37",
     "powerpc-linux-gnu.2.38",
-    "powerpc-linux-gnu-power4.2.33",
-    "powerpc-linux-gnu-power4.2.34",
-    "powerpc-linux-gnu-power4.2.35",
-    "powerpc-linux-gnu-power4.2.36",
-    "powerpc-linux-gnu-power4.2.37",
     "powerpc-linux-gnu-power4.2.38",
-    "powerpc-linux-gnu-soft.2.33",
-    "powerpc-linux-gnu-soft.2.34",
-    "powerpc-linux-gnu-soft.2.35",
-    "powerpc-linux-gnu-soft.2.36",
-    "powerpc-linux-gnu-soft.2.37",
     "powerpc-linux-gnu-soft.2.38",
-    "riscv64-linux-gnu-rv64imac-lp64.2.33",
-    "riscv64-linux-gnu-rv64imac-lp64.2.34",
-    "riscv64-linux-gnu-rv64imac-lp64.2.35",
-    "riscv64-linux-gnu-rv64imac-lp64.2.36",
-    "riscv64-linux-gnu-rv64imac-lp64.2.37",
+    "riscv32-linux-gnu-rv32imac-ilp32.2.38",
+    "riscv32-linux-gnu-rv32imafdc-ilp32.2.38",
+    "riscv32-linux-gnu-rv32imafdc-ilp32d.2.38",
     "riscv64-linux-gnu-rv64imac-lp64.2.38",
-    "riscv64-linux-gnu-rv64imafdc-lp64.2.33",
-    "riscv64-linux-gnu-rv64imafdc-lp64.2.34",
-    "riscv64-linux-gnu-rv64imafdc-lp64.2.35",
-    "riscv64-linux-gnu-rv64imafdc-lp64.2.36",
-    "riscv64-linux-gnu-rv64imafdc-lp64.2.37",
     "riscv64-linux-gnu-rv64imafdc-lp64.2.38",
-    "riscv64-linux-gnu-rv64imafdc-lp64d.2.33",
-    "riscv64-linux-gnu-rv64imafdc-lp64d.2.34",
-    "riscv64-linux-gnu-rv64imafdc-lp64d.2.35",
-    "riscv64-linux-gnu-rv64imafdc-lp64d.2.36",
-    "riscv64-linux-gnu-rv64imafdc-lp64d.2.37",
     "riscv64-linux-gnu-rv64imafdc-lp64d.2.38",
-    "s390x-linux-gnu.2.33",
-    "s390x-linux-gnu.2.34",
-    "s390x-linux-gnu.2.35",
-    "s390x-linux-gnu.2.36",
-    "s390x-linux-gnu.2.37",
     "s390x-linux-gnu.2.38",
-    "sparc64-linux-gnu.2.33",
-    "sparc64-linux-gnu.2.34",
-    "sparc64-linux-gnu.2.35",
-    "sparc64-linux-gnu.2.36",
-    "sparc64-linux-gnu.2.37",
     "sparc64-linux-gnu.2.38",
-    "sparcv8-linux-gnu-leon3.2.33",
-    "sparcv8-linux-gnu-leon3.2.34",
-    "sparcv8-linux-gnu-leon3.2.35",
-    "sparcv8-linux-gnu-leon3.2.36",
-    "sparcv8-linux-gnu-leon3.2.37",
     "sparcv8-linux-gnu-leon3.2.38",
-    "sparcv9-linux-gnu.2.33",
-    "sparcv9-linux-gnu.2.34",
-    "sparcv9-linux-gnu.2.35",
-    "sparcv9-linux-gnu.2.36",
-    "sparcv9-linux-gnu.2.37",
     "sparcv9-linux-gnu.2.38",
-    "x86_64-linux-gnu.2.33",
-    "x86_64-linux-gnu.2.34",
-    "x86_64-linux-gnu.2.35",
-    "x86_64-linux-gnu.2.36",
-    "x86_64-linux-gnu.2.37",
     "x86_64-linux-gnu.2.38",
-    "x86_64-linux-gnu-x32.2.33",
-    "x86_64-linux-gnu-x32.2.34",
-    "x86_64-linux-gnu-x32.2.35",
-    "x86_64-linux-gnu-x32.2.36",
-    "x86_64-linux-gnu-x32.2.37",
     "x86_64-linux-gnu-x32.2.38",
-    "__GLIBC_MINOR__ > 32",
+    "__GLIBC_MINOR__ == 38",
 },
 
 // The rest of these are not duplicated enough so far to warrant a reduction,