voroskoi/aoc2021-zig - Change 7R5IKOBGJYGMA6QA62SX2HV3I273YSVENO6ZH44B5WMOS7CBKWLQC

Remove hard coded allocators from solvers

Created by voroskoi on April 16, 2022

7R5IKOBGJYGMA6QA62SX2HV3I273YSVENO6ZH44B5WMOS7CBKWLQC

Dependencies

In channels

main

Change contents

Insertion in src/main.zig at line 60 [18.50]

[17.2107]

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

Replacement in src/main.zig at line 69 [18.50]

B:BD[17.2444] → [17.2444:2502]

B:BD[17.2502] → [16.0:135]

        // @compileLog(dsa);
        // @compileLog(dsb);
        _ = @field(aoc2021, dsa).first() catch unreachable;
        if (day < 24) _ = @field(aoc2021, dsb).second() catch unreachable;

[17.2444]

[17.2609]

        _ = @field(aoc2021, dsa).first(arena.allocator()) catch unreachable;
        if (day < 24) _ = @field(aoc2021, dsb).second(arena.allocator()) catch unreachable;

Replacement in src/day25a.zig at line 11 [19.35]
B:BD[19.258] → [19.258:287]
```
    const ret = try first();
```
[19.258]
[19.287]
```
    const ret = try first(null);
```

Replacement in src/day25a.zig at line 19 [19.35]

B:BD[19.457] → [19.457:481]

pub fn first() !usize {

[19.457]

[19.481]

pub fn first(allocator: ?std.mem.Allocator) !usize {
    _ = allocator;

Insertion in src/day24b.zig at line 15 [20.35]

[20.369]

    var buf: [100]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);

Replacement in src/day24b.zig at line 19 [20.35]
B:BD[20.413] → [20.413:443]
```
    const ret = try second();
```
[20.413]
[20.443]
```
    const ret = try second(fba.allocator());
```
Replacement in src/day24b.zig at line 27 [20.35]
B:BD[20.624] → [20.624:649]
```
pub fn second() !usize {
```
[20.624]
[20.649]
```
pub fn second(allocator: ?std.mem.Allocator) !usize {
```

Replacement in src/day24b.zig at line 31 [20.35]

B:BD[20.707] → [20.707:806]

    const allocator = std.testing.allocator;
    var stack = std.ArrayList(Pair).init(allocator);

[20.707]

[20.806]

    var stack = std.ArrayList(Pair).init(allocator.?);

Insertion in src/day24a.zig at line 15 [21.35]

[21.369]

    var buf: [100]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);

Replacement in src/day24a.zig at line 19 [21.35]
B:BD[21.413] → [21.413:442]
```
    const ret = try first();
```
[21.413]
[21.442]
```
    const ret = try first(fba.allocator());
```
Replacement in src/day24a.zig at line 27 [21.35]
B:BD[21.623] → [21.623:647]
```
pub fn first() !usize {
```
[21.623]
[21.647]
```
pub fn first(allocator: ?std.mem.Allocator) !usize {
```

Replacement in src/day24a.zig at line 31 [21.35]

B:BD[21.705] → [21.705:804]

    const allocator = std.testing.allocator;
    var stack = std.ArrayList(Pair).init(allocator);

[21.705]

[21.804]

    var stack = std.ArrayList(Pair).init(allocator.?);

Insertion in src/day23b.zig at line 259 [22.35]

[22.8600]

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

Replacement in src/day23b.zig at line 263 [22.35]
B:BD[22.8644] → [22.8644:8674]
```
    const ret = try second();
```
[22.8644]
[22.8674]
```
    const ret = try second(arena.allocator());
```

Replacement in src/day23b.zig at line 282 [22.35]

B:BD[22.9132] → [22.9132:9157]

B:BD[22.9157] → [11.0:138]

∅:D[11.138] → [22.9202:9286]

B:BD[22.9202] → [22.9202:9286]

pub fn second() !usize {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    const allocator = arena.allocator();
    var queue = std.PriorityQueue(StateQueue, void, lessThan).init(allocator, {});

[22.9132]

[22.9286]

pub fn second(allocator: ?std.mem.Allocator) !usize {
    var queue = std.PriorityQueue(StateQueue, void, lessThan).init(allocator.?, {});

Replacement in src/day23b.zig at line 286 [22.35]

B:BD[22.9313] → [22.9313:9377]

    var visited = std.AutoHashMap(State, void).init(allocator);

[22.9313]

[22.9377]

    var visited = std.AutoHashMap(State, void).init(allocator.?);

Replacement in src/day23b.zig at line 320 [22.35]

B:BD[22.10435] → [22.10435:10554]

        var possible_states = try curr.state.getValidStates(allocator);
        defer allocator.free(possible_states);

[22.10435]

[22.10554]

        var possible_states = try curr.state.getValidStates(allocator.?);
        defer allocator.?.free(possible_states);

Insertion in src/day23a.zig at line 257 [23.35]

[23.6103]

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

Replacement in src/day23a.zig at line 261 [23.35]
B:BD[23.6147] → [23.6147:6176]
```
    const ret = try first();
```
[23.6147]
[23.6176]
```
    const ret = try first(arena.allocator());
```

Replacement in src/day23a.zig at line 280 [23.35]

B:BD[23.6634] → [23.6634:6658]

B:BD[23.6658] → [11.139:277]

∅:D[11.277] → [23.6703:6787]

B:BD[23.6703] → [23.6703:6787]

pub fn first() !usize {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    const allocator = arena.allocator();
    var queue = std.PriorityQueue(StateQueue, void, lessThan).init(allocator, {});

[23.6634]

[23.6787]

pub fn first(allocator: ?std.mem.Allocator) !usize {
    var queue = std.PriorityQueue(StateQueue, void, lessThan).init(allocator.?, {});

Replacement in src/day23a.zig at line 284 [23.35]

B:BD[23.6814] → [23.6814:6878]

    var visited = std.AutoHashMap(State, void).init(allocator);

[23.6814]

[23.6878]

    var visited = std.AutoHashMap(State, void).init(allocator.?);

Replacement in src/day23a.zig at line 318 [23.35]

B:BD[23.8131] → [23.8131:8250]

        var possible_states = try curr.state.getValidStates(allocator);
        defer allocator.free(possible_states);

[23.8131]

[23.8250]

        var possible_states = try curr.state.getValidStates(allocator.?);
        defer allocator.?.free(possible_states);

Insertion in src/day22b.zig at line 23 [24.68]

[24.462]

    var buf: [3_000_000]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);
    var arena = std.heap.ArenaAllocator.init(fba.allocator());
    defer arena.deinit();

Replacement in src/day22b.zig at line 29 [24.68]
B:BD[24.506] → [24.506:536]
```
    const ret = try second();
```
[24.506]
[24.536]
```
    const ret = try second(arena.allocator());
```

Deletion in src/day22b.zig at line 36 [24.68]

B:BD[24.713] → [24.713:833]


pub fn second() !isize {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();

Replacement in src/day22b.zig at line 37 [24.68]

B:BD[24.834] → [24.834:912]

    const input = try parseInput(allocator);
    defer allocator.free(input);

[24.834]

[24.912]

pub fn second(allocator: ?std.mem.Allocator) !isize {
    const input = try parseInput(allocator.?);
    defer allocator.?.free(input);

Replacement in src/day22b.zig at line 42 [24.68]

B:BD[24.942] → [24.942:984]

    var cubes = SubCubes.init(allocator);

[24.942]

[24.984]

    var cubes = SubCubes.init(allocator.?);

Replacement in src/day22b.zig at line 46 [24.68]

B:BD[24.1036] → [24.1036:1113]

        var overlaps = std.AutoHashMap(Cuboid, SubCubeType).init(allocator);

[24.1036]

[24.1113]

        var overlaps = std.AutoHashMap(Cuboid, SubCubeType).init(allocator.?);

Insertion in src/day22a.zig at line 21 [10.35]

[10.342]

    var buf: [100_000]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);
    var arena = std.heap.ArenaAllocator.init(fba.allocator());
    defer arena.deinit();

Replacement in src/day22a.zig at line 27 [10.35]
B:BD[10.386] → [10.386:415]
```
    const ret = try first();
```
[10.386]
[10.415]
```
    const ret = try first(arena.allocator());
```

Replacement in src/day22a.zig at line 37 [10.35]

B:BD[10.621] → [10.621:690]

pub fn first() !usize {
    const allocator = std.testing.allocator;

[10.621]

[10.690]

pub fn first(allocator: ?std.mem.Allocator) !usize {
    const input = try parseInput(allocator.?);
    defer allocator.?.free(input);

Deletion in src/day22a.zig at line 41 [10.35]

B:BD[10.691] → [10.691:770]

    const input = try parseInput(allocator);
    defer allocator.free(input);

Insertion in src/day21b.zig at line 8 [25.35]

[25.150]

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

Replacement in src/day21b.zig at line 12 [25.35]
B:BD[25.194] → [25.194:224]
```
    const ret = try second();
```
[25.194]
[25.224]
```
    const ret = try second(arena.allocator());
```
Replacement in src/day21b.zig at line 22 [25.35]
B:BD[25.455] → [25.455:480]
```
pub fn second() !usize {
```
[25.455]
[25.480]
```
pub fn second(allocator: ?std.mem.Allocator) !usize {
```
Replacement in src/day21b.zig at line 25 [25.35]
B:BD[25.510] → [25.510:555]
B:BD[25.555] → [25.555:556]
B:BD[25.556] → [25.556:595]
```
    const allocator = std.testing.allocator;
    var cache = Cache.init(allocator);
```
[25.510]
[25.595]
```
    var cache = Cache.init(allocator.?);
```
Replacement in src/day21a.zig at line 9 [8.35]
B:BD[8.196] → [8.196:225]
```
    const ret = try first();
```
[8.196]
[8.225]
```
    const ret = try first(null);
```

Replacement in src/day21a.zig at line 17 [8.35]

B:BD[8.398] → [8.398:422]

pub fn first() !usize {

[8.398]

[8.422]

pub fn first(allocator: ?std.mem.Allocator) !usize {
    _ = allocator;

Insertion in src/day20b.zig at line 22 [15.65]

[15.441]

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

Replacement in src/day20b.zig at line 26 [15.65]
B:BD[15.485] → [15.485:515]
```
    const ret = try second();
```
[15.485]
[15.515]
```
    const ret = try second(arena.allocator());
```

Deletion in src/day20b.zig at line 33 [15.65]

B:BD[15.686] → [15.686:824]


pub fn second() !usize {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    const allocator = arena.allocator();

Replacement in src/day20b.zig at line 34 [15.65]

B:BD[15.825] → [15.825:868]

    var image = try parseInput(allocator);

[15.825]

[15.868]

pub fn second(allocator: ?std.mem.Allocator) !usize {
    var image = try parseInput(allocator.?);

Replacement in src/day20b.zig at line 42 [15.65]

B:BD[15.1040] → [15.1040:1117]

        var next = try Pixels.initEmpty(allocator, (next_size * next_size));

[15.1040]

[15.1117]

        var next = try Pixels.initEmpty(allocator.?, (next_size * next_size));

Insertion in src/day20a.zig at line 22 [26.35]

[26.426]

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

Replacement in src/day20a.zig at line 26 [26.35]
B:BD[26.470] → [26.470:499]
```
    const ret = try first();
```
[26.470]
[26.499]
```
    const ret = try first(arena.allocator());
```

Deletion in src/day20a.zig at line 33 [26.35]

B:BD[26.669] → [26.669:694]

B:BD[26.694] → [15.3842:3954]


pub fn first() !usize {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    const allocator = arena.allocator();

Replacement in src/day20a.zig at line 34 [26.35]

B:BD[26.740] → [26.740:783]

    var image = try parseInput(allocator);

[26.740]

[26.783]

pub fn first(allocator: ?std.mem.Allocator) !usize {
    var image = try parseInput(allocator.?);

Replacement in src/day20a.zig at line 42 [26.35]

B:BD[26.933] → [15.4048:4125]

        var next = try Pixels.initEmpty(allocator, (next_size * next_size));

[26.933]

[26.971]

        var next = try Pixels.initEmpty(allocator.?, (next_size * next_size));

Insertion in src/day19b.zig at line 19 [27.35]

[27.335]

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

Replacement in src/day19b.zig at line 23 [27.35]
B:BD[27.379] → [27.379:409]
```
    const ret = try second();
```
[27.379]
[27.409]
```
    const ret = try second(arena.allocator());
```

Replacement in src/day19b.zig at line 31 [27.35]

B:BD[27.582] → [27.582:609]

B:BD[27.609] → [12.0:138]

∅:D[12.138] → [27.703:746]

B:BD[27.703] → [27.703:746]

pub fn second() !RetType {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    const allocator = arena.allocator();
    const sd = try parseInput(allocator);

[27.582]

[27.746]

pub fn second(allocator: ?std.mem.Allocator) !RetType {
    const sd = try parseInput(allocator.?);

Replacement in src/day19b.zig at line 35 [27.35]
B:BD[27.781] → [27.781:812]
```
            allocator.free(s);
```
[27.781]
[27.812]
```
            allocator.?.free(s);
```

Replacement in src/day19b.zig at line 41 [27.35]

B:BD[27.906] → [27.906:980]

    var absolutes = std.AutoArrayHashMap(ScanLine, void).init(allocator);

[27.906]

[27.980]

    var absolutes = std.AutoArrayHashMap(ScanLine, void).init(allocator.?);

Replacement in src/day19b.zig at line 59 [27.35]

∅:D[14.145] → [27.1412:1489]

B:BD[27.1412] → [27.1412:1489]

                var offsets = std.AutoHashMap(ScanLine, u4).init(allocator);

[14.145]

[27.1489]

                var offsets = std.AutoHashMap(ScanLine, u4).init(allocator.?);

Insertion in src/day19a.zig at line 19 [28.35]

[28.335]

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

Replacement in src/day19a.zig at line 23 [28.35]
B:BD[28.379] → [28.379:408]
```
    const ret = try first();
```
[28.379]
[28.408]
```
    const ret = try first(arena.allocator());
```

Replacement in src/day19a.zig at line 31 [28.35]

B:BD[28.580] → [28.580:606]

B:BD[28.606] → [12.139:277]

∅:D[12.277] → [28.700:743]

B:BD[28.700] → [28.700:743]

pub fn first() !RetType {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    const allocator = arena.allocator();
    const sd = try parseInput(allocator);

[28.580]

[28.743]

pub fn first(allocator: ?std.mem.Allocator) !RetType {
    const sd = try parseInput(allocator.?);

Replacement in src/day19a.zig at line 35 [28.35]
B:BD[28.778] → [28.778:809]
```
            allocator.free(s);
```
[28.778]
[28.809]
```
            allocator.?.free(s);
```

Replacement in src/day19a.zig at line 39 [28.35]

B:BD[28.855] → [28.855:929]

    var absolutes = std.AutoArrayHashMap(ScanLine, void).init(allocator);

[28.855]

[28.929]

    var absolutes = std.AutoArrayHashMap(ScanLine, void).init(allocator.?);

Replacement in src/day19a.zig at line 54 [28.35]

∅:D[13.143] → [28.1316:1393]

B:BD[28.1316] → [28.1316:1393]

                var offsets = std.AutoHashMap(ScanLine, u4).init(allocator);

[13.143]

[28.1393]

                var offsets = std.AutoHashMap(ScanLine, u4).init(allocator.?);

Replacement in src/day18b.zig at line 36 [29.303]
B:BD[29.1175] → [29.1175:1205]
```
    const ret = try second();
```
[29.1175]
[29.1205]
```
    const ret = try second(std.heap.page_allocator);
```

Replacement in src/day18b.zig at line 44 [29.303]

B:BD[29.1376] → [29.1376:1534]

pub fn second() !usize {
    const gpa = std.heap.page_allocator;
    var arena = std.heap.ArenaAllocator.init(gpa);
    const allocator = arena.allocator();

[29.1376]

[29.1534]

pub fn second(allocator: ?std.mem.Allocator) !usize {
    var arena = std.heap.ArenaAllocator.init(allocator.?);

Replacement in src/day18b.zig at line 48 [29.303]

B:BD[29.1561] → [29.1561:1604]

    var input = try parseInput(allocator);

[29.1561]

[29.1604]

    var input = try parseInput(arena.allocator());

Replacement in src/day18b.zig at line 57 [29.303]

B:BD[29.1760] → [29.1760:1931]

            const first = try parseSnail(allocator, &a[0..], null, &pos);
            const ab = try first.add(allocator, &b[0..]);
            try reduce(allocator, ab);

[29.1760]

[29.1931]

            const first = try parseSnail(arena.allocator(), &a[0..], null, &pos);
            const ab = try first.add(arena.allocator(), &b[0..]);
            try reduce(arena.allocator(), ab);

Replacement in src/day18a.zig at line 36 [9.35]

B:BD[9.907] → [9.907:936]

    const ret = try first();

[9.907]

[9.936]

    const ret = try first(std.heap.page_allocator);

Replacement in src/day18a.zig at line 44 [9.35]
B:BD[9.1107] → [9.1107:1131]
```
pub fn first() !usize {
```
[9.1107]
[9.1131]
```
pub fn first(allocator: ?std.mem.Allocator) !usize {
```

Replacement in src/day18a.zig at line 48 [9.35]

B:BD[9.1216] → [9.1216:1349]

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

[9.1216]

[9.1349]

    var arena = std.heap.ArenaAllocator.init(allocator.?);

Replacement in src/day18a.zig at line 57 [9.35]

B:BD[9.1540] → [9.1540:1609]

            ret = try parseSnail(allocator, &line[0..], null, &pos);

[9.1540]

[9.1609]

            ret = try parseSnail(arena.allocator(), &line[0..], null, &pos);

Replacement in src/day18a.zig at line 59 [9.35]

B:BD[9.1626] → [9.1626:1720]

            ret = try ret.add(allocator, &line[0..]);
            try reduce(allocator, ret);

[9.1626]

[9.1720]

            ret = try ret.add(arena.allocator(), &line[0..]);
            try reduce(arena.allocator(), ret);

Replacement in src/day17b.zig at line 43 [30.170]

B:BD[30.1338] → [30.1338:1365]

pub fn second() !RetType {

[30.1338]

[30.1365]

pub fn second(allocator: ?std.mem.Allocator) !RetType {
    _ = allocator;

Replacement in src/day17b.zig at line 99 [30.170]
B:BD[30.2696] → [30.2696:2726]
```
    const ret = try second();
```
[30.2696]
[30.2726]
```
    const ret = try second(null);
```

Replacement in src/day17a.zig at line 36 [7.35]

B:BD[7.967] → [7.967:993]

pub fn first() !RetType {

[7.967]

[7.993]

pub fn first(allocator: ?std.mem.Allocator) !RetType {
    _ = allocator;

Replacement in src/day17a.zig at line 51 [7.35]
B:BD[7.1278] → [7.1278:1307]
```
    const ret = try first();
```
[7.1278]
[7.1307]
```
    const ret = try first(null);
```

Deletion in src/day16b.zig at line 37 [31.170]

B:BD[31.1300] → [31.1300:1428]

B:BD[31.1428] → [31.1428:1429]

B:BD[31.1429] → [31.1429:1474]


pub fn second() !RetType {
    // var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    // const allocator = gpa.allocator();
    const allocator = std.testing.allocator;

Replacement in src/day16b.zig at line 38 [31.170]

B:BD[31.1475] → [31.1475:1553]

    const input = try parseInput(allocator);
    defer allocator.free(input);

[31.1475]

[31.1553]

pub fn second(allocator: ?std.mem.Allocator) !RetType {
    const input = try parseInput(allocator.?);
    defer allocator.?.free(input);

Replacement in src/day16b.zig at line 42 [31.170]

B:BD[31.1554] → [31.1554:1611]

    var arena = std.heap.ArenaAllocator.init(allocator);

[31.1554]

[31.1611]

    var arena = std.heap.ArenaAllocator.init(allocator.?);

Insertion in src/day16b.zig at line 183 [31.170]

[31.5712]

    var buf: [100_000]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);
    var arena = std.heap.ArenaAllocator.init(fba.allocator());
    defer arena.deinit();

Replacement in src/day16b.zig at line 189 [31.170]
B:BD[31.5756] → [31.5756:5786]
```
    const ret = try second();
```
[31.5756]
[31.5786]
```
    const ret = try second(arena.allocator());
```

Replacement in src/day16a.zig at line 38 [31.6098]

B:BD[31.7229] → [31.7229:7349]

B:BD[31.7349] → [31.7349:7350]

B:BD[31.7350] → [31.7350:7428]

pub fn first() !RetType {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    const input = try parseInput(allocator);
    defer allocator.free(input);

[31.7229]

[31.7428]

pub fn first(allocator: ?std.mem.Allocator) !RetType {
    const input = try parseInput(allocator.?);
    defer allocator.?.free(input);

Replacement in src/day16a.zig at line 42 [31.6098]

B:BD[31.7429] → [31.7429:7486]

    var arena = std.heap.ArenaAllocator.init(allocator);

[31.7429]

[31.7486]

    var arena = std.heap.ArenaAllocator.init(allocator.?);

Insertion in src/day16a.zig at line 125 [31.6098]

[31.9829]

    var buf: [100_000]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);
    var arena = std.heap.ArenaAllocator.init(fba.allocator());
    defer arena.deinit();

Replacement in src/day16a.zig at line 131 [31.6098]
B:BD[31.9873] → [31.9873:9902]
```
    const ret = try first();
```
[31.9873]
[31.9902]
```
    const ret = try first(arena.allocator());
```

Deletion in src/day15b.zig at line 66 [32.170]

B:BD[32.1803] → [32.1803:1933]


pub fn second() anyerror!RetType {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();

Insertion in src/day15b.zig at line 67 [32.170]

[32.1934]

pub fn second(allocator: ?std.mem.Allocator) anyerror!RetType {

Replacement in src/day15b.zig at line 73 [32.170]
B:BD[32.2125] → [32.2125:2168]
```
    var queue = Queue.init(allocator, {});
```
[32.2125]
[32.2168]
```
    var queue = Queue.init(allocator.?, {});
```

Insertion in src/day15b.zig at line 122 [32.170]

[32.3881]

    var buf: [25_000]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);

Replacement in src/day15b.zig at line 126 [32.170]
B:BD[32.3925] → [32.3925:3955]
```
    const ret = try second();
```
[32.3925]
[32.3955]
```
    const ret = try second(fba.allocator());
```

Deletion in src/day15a.zig at line 49 [6.35]

B:BD[6.1030] → [6.1030:1159]


pub fn first() anyerror!RetType {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();

Insertion in src/day15a.zig at line 50 [6.35]

[6.1160]

pub fn first(allocator: ?std.mem.Allocator) anyerror!RetType {

Replacement in src/day15a.zig at line 56 [6.35]

B:BD[6.1314] → [6.1314:1357]

    var queue = Queue.init(allocator, {});

[6.1314]

[6.1357]

    var queue = Queue.init(allocator.?, {});

Insertion in src/day15a.zig at line 105 [6.35]

[6.3022]

    var buf: [10_000]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);

Replacement in src/day15a.zig at line 109 [6.35]
B:BD[6.3066] → [6.3066:3095]
```
    const ret = try first();
```
[6.3066]
[6.3095]
```
    const ret = try first(fba.allocator());
```

Replacement in src/day14b.zig at line 36 [33.170]

B:BD[33.944] → [33.944:1113]

pub fn second() anyerror!RetType {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    var p = try parseInput(allocator);

[33.944]

[33.1113]

pub fn second(allocator: ?std.mem.Allocator) anyerror!RetType {
    var p = try parseInput(allocator.?);

Replacement in src/day14b.zig at line 40 [33.170]

B:BD[33.1142] → [33.1142:1202]

    var pairs = std.StringHashMap(RetType).init(allocator);

[33.1142]

[33.1202]

    var pairs = std.StringHashMap(RetType).init(allocator.?);

Replacement in src/day14b.zig at line 52 [33.170]

B:BD[33.1540] → [33.1540:1597]

    var arena = std.heap.ArenaAllocator.init(allocator);

[33.1540]

[33.1597]

    var arena = std.heap.ArenaAllocator.init(allocator.?);

Replacement in src/day14b.zig at line 57 [33.170]

B:BD[33.1687] → [33.1687:1756]

        var next_pairs = std.StringHashMap(RetType).init(allocator);

[33.1687]

[33.1756]

        var next_pairs = std.StringHashMap(RetType).init(allocator.?);

Replacement in src/day14b.zig at line 74 [33.170]

B:BD[33.2562] → [33.2562:2624]

    var chars = std.AutoHashMap(u8, RetType).init(allocator);

[33.2562]

[33.2624]

    var chars = std.AutoHashMap(u8, RetType).init(allocator.?);

Insertion in src/day14b.zig at line 102 [33.170]

[33.3335]

    var buf: [500_000]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);

Replacement in src/day14b.zig at line 106 [33.170]
B:BD[33.3379] → [33.3379:3409]
```
    const ret = try second();
```
[33.3379]
[33.3409]
```
    const ret = try second(fba.allocator());
```

Replacement in src/day14a.zig at line 36 [5.35]

B:BD[5.809] → [5.809:977]

pub fn first() anyerror!RetType {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    var p = try parseInput(allocator);

[5.809]

[5.977]

pub fn first(allocator: ?std.mem.Allocator) anyerror!RetType {
    var p = try parseInput(allocator.?);

Replacement in src/day14a.zig at line 40 [5.35]

B:BD[5.1006] → [5.1006:1066]

    var pairs = std.StringHashMap(RetType).init(allocator);

[5.1006]

[5.1066]

    var pairs = std.StringHashMap(RetType).init(allocator.?);

Replacement in src/day14a.zig at line 52 [5.35]

B:BD[5.1404] → [5.1404:1461]

    var arena = std.heap.ArenaAllocator.init(allocator);

[5.1404]

[5.1461]

    var arena = std.heap.ArenaAllocator.init(allocator.?);

Replacement in src/day14a.zig at line 57 [5.35]

B:BD[5.1551] → [5.1551:1620]

        var next_pairs = std.StringHashMap(RetType).init(allocator);

[5.1551]

[5.1620]

        var next_pairs = std.StringHashMap(RetType).init(allocator.?);

Replacement in src/day14a.zig at line 74 [5.35]

B:BD[5.2426] → [5.2426:2488]

    var chars = std.AutoHashMap(u8, RetType).init(allocator);

[5.2426]

[5.2488]

    var chars = std.AutoHashMap(u8, RetType).init(allocator.?);

Insertion in src/day14a.zig at line 102 [5.35]

[5.3199]

    var buf: [75_000]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);

Replacement in src/day14a.zig at line 106 [5.35]
B:BD[5.3243] → [5.3243:3272]
```
    const ret = try first();
```
[5.3243]
[5.3272]
```
    const ret = try first(fba.allocator());
```

Replacement in src/day13b.zig at line 90 [34.170]

B:BD[34.2745] → [34.2745:2914]

pub fn second() anyerror!RetType {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    var p = try parseInput(allocator);

[34.2745]

[34.2914]

pub fn second(allocator: ?std.mem.Allocator) anyerror!RetType {
    var p = try parseInput(allocator.?);

Replacement in src/day13b.zig at line 98 [34.170]

B:BD[34.3017] → [34.3017:3071]

        try p.Fold(allocator, fold.axis, fold.value);

[34.3017]

[34.3071]

        try p.Fold(allocator.?, fold.axis, fold.value);

Insertion in src/day13b.zig at line 118 [34.170]

[34.3556]

    var buf: [75_000]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);

Replacement in src/day13b.zig at line 122 [34.170]
B:BD[34.3600] → [34.3600:3630]
```
    const ret = try second();
```
[34.3600]
[34.3630]
```
    const ret = try second(fba.allocator());
```

Replacement in src/day13a.zig at line 90 [34.3922]

B:BD[34.6498] → [34.6498:6666]

pub fn first() anyerror!RetType {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    var p = try parseInput(allocator);

[34.6498]

[34.6666]

pub fn first(allocator: ?std.mem.Allocator) anyerror!RetType {
    var p = try parseInput(allocator.?);

Replacement in src/day13a.zig at line 97 [34.3922]

B:BD[34.6736] → [34.6736:6810]

    try p.Fold(allocator, p.folds.items[0].axis, p.folds.items[0].value);

[34.6736]

[34.6810]

    try p.Fold(allocator.?, p.folds.items[0].axis, p.folds.items[0].value);

Insertion in src/day13a.zig at line 103 [34.3922]

[34.6890]

    var buf: [75_000]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);

Replacement in src/day13a.zig at line 107 [34.3922]
B:BD[34.6934] → [34.6934:6963]
```
    const ret = try first();
```
[34.6934]
[34.6963]
```
    const ret = try first(fba.allocator());
```

Replacement in src/day12b.zig at line 59 [35.70]

B:BD[35.1785] → [35.1785:1957]

pub fn second() anyerror!RetType {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    var cave = try parseInput(allocator);

[35.1785]

[35.1957]

pub fn second(allocator: ?std.mem.Allocator) anyerror!RetType {
    var cave = try parseInput(allocator.?);

Replacement in src/day12b.zig at line 64 [35.70]
B:BD[35.1985] → [35.1985:2024]
```
    var cache = Cache.init(allocator);
```
[35.1985]
[35.2024]
```
    var cache = Cache.init(allocator.?);
```

Insertion in src/day12b.zig at line 113 [35.70]

[35.3284]

    var buf: [25_000]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);

Replacement in src/day12b.zig at line 117 [35.70]
B:BD[35.3328] → [35.3328:3358]
```
    const ret = try second();
```
[35.3328]
[35.3358]
```
    const ret = try second(fba.allocator());
```

Replacement in src/day12a.zig at line 59 [4.70]

B:BD[4.1758] → [4.1758:1929]

pub fn first() anyerror!RetType {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    var cave = try parseInput(allocator);

[4.1758]

[4.1929]

pub fn first(allocator: ?std.mem.Allocator) anyerror!RetType {
    var cave = try parseInput(allocator.?);

Replacement in src/day12a.zig at line 64 [4.70]
B:BD[4.1957] → [4.1957:1996]
```
    var cache = Cache.init(allocator);
```
[4.1957]
[4.1996]
```
    var cache = Cache.init(allocator.?);
```

Insertion in src/day12a.zig at line 108 [4.70]

[4.3038]

    var buf: [15_000]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);

Replacement in src/day12a.zig at line 112 [4.70]
B:BD[4.3082] → [4.3082:3111]
```
    const ret = try first();
```
[4.3082]
[4.3111]
```
    const ret = try first(fba.allocator());
```

Replacement in src/day11b.zig at line 42 [36.170]

B:BD[36.943] → [36.943:978]

pub fn second() anyerror!RetType {

[36.943]

[36.978]

pub fn second(allocator: ?std.mem.Allocator) anyerror!RetType {
    _ = allocator;

Replacement in src/day11b.zig at line 118 [36.170]
B:BD[36.2801] → [36.2801:2831]
```
    const ret = try second();
```
[36.2801]
[36.2831]
```
    const ret = try second(null);
```

Replacement in src/day11a.zig at line 42 [3.35]

B:BD[3.809] → [3.809:843]

pub fn first() anyerror!RetType {

[3.809]

[3.843]

pub fn first(allocator: ?std.mem.Allocator) anyerror!RetType {
    _ = allocator;

Replacement in src/day11a.zig at line 106 [3.35]
B:BD[3.2475] → [3.2475:2504]
```
    const ret = try first();
```
[3.2475]
[3.2504]
```
    const ret = try first(null);
```

Replacement in src/day10b.zig at line 72 [37.233]

B:BD[37.2005] → [37.2005:2040]

pub fn second() anyerror!RetType {

[37.2005]

[37.2040]

pub fn second(allocator: ?std.mem.Allocator) anyerror!RetType {
    _ = allocator;

Replacement in src/day10b.zig at line 80 [37.233]
B:BD[37.2146] → [37.2146:2176]
```
    const ret = try second();
```
[37.2146]
[37.2176]
```
    const ret = try second(null);
```

Replacement in src/day10a.zig at line 61 [37.2493]

B:BD[37.3924] → [37.3924:3958]

pub fn first() anyerror!RetType {

[37.3924]

[37.3958]

pub fn first(allocator: ?std.mem.Allocator) anyerror!RetType {
    _ = allocator;

Replacement in src/day10a.zig at line 69 [37.2493]
B:BD[37.4064] → [37.4064:4093]
```
    const ret = try first();
```
[37.4064]
[37.4093]
```
    const ret = try first(null);
```
Replacement in src/day09b.zig at line 69 [38.233]
B:BD[38.1947] → [38.1947:1982]
```
pub fn second() anyerror!RetType {
```
[38.1947]
[38.1982]
```
pub fn second(allocator: ?std.mem.Allocator) anyerror!RetType {
```

Replacement in src/day09b.zig at line 74 [38.233]

B:BD[38.2051] → [38.2051:2207]

    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    var seen = std.AutoHashMap(Point, void).init(allocator);

[38.2051]

[38.2207]

    var seen = std.AutoHashMap(Point, void).init(allocator.?);

Replacement in src/day09b.zig at line 77 [38.233]

B:BD[38.2233] → [38.2233:2317]

    var basins = std.PriorityQueue(RetType, void, greaterThan).init(allocator, {});

[38.2233]

[38.2317]

    var basins = std.PriorityQueue(RetType, void, greaterThan).init(allocator.?, {});

Insertion in src/day09b.zig at line 101 [38.233]

[38.3159]

    var buf: [10_000]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);

Replacement in src/day09b.zig at line 105 [38.233]
B:BD[38.3203] → [38.3203:3233]
```
    const ret = try second();
```
[38.3203]
[38.3233]
```
    const ret = try second(fba.allocator());
```

Replacement in src/day09a.zig at line 35 [38.3543]

B:BD[38.4215] → [38.4215:4249]

pub fn first() anyerror!RetType {

[38.4215]

[38.4249]

pub fn first(allocator: ?std.mem.Allocator) anyerror!RetType {
    _ = allocator;

Replacement in src/day09a.zig at line 61 [38.3543]
B:BD[38.4975] → [38.4975:5004]
```
    const ret = try first();
```
[38.4975]
[38.5004]
```
    const ret = try first(null);
```

Replacement in src/day08b.zig at line 82 [39.233]

B:BD[39.2528] → [39.2528:2563]

pub fn second() anyerror!RetType {

[39.2528]

[39.2563]

pub fn second(allocator: ?std.mem.Allocator) anyerror!RetType {
    _ = allocator;

Replacement in src/day08b.zig at line 144 [39.233]
B:BD[39.4286] → [39.4286:4316]
```
    const ret = try second();
```
[39.4286]
[39.4316]
```
    const ret = try second(null);
```

Replacement in src/day08a.zig at line 27 [39.4626]

B:BD[39.5308] → [39.5308:5342]

pub fn first() anyerror!RetType {

[39.5308]

[39.5342]

pub fn first(allocator: ?std.mem.Allocator) anyerror!RetType {
    _ = allocator;

Replacement in src/day08a.zig at line 35 [39.4626]
B:BD[39.5448] → [39.5448:5477]
```
    const ret = try first();
```
[39.5448]
[39.5477]
```
    const ret = try first(null);
```

Replacement in src/day07b.zig at line 32 [40.470]

B:BD[40.1175] → [41.1137:1170]

pub fn second() anyerror!usize {

[40.1175]

[40.1204]

pub fn second(allocator: ?std.mem.Allocator) anyerror!usize {
    _ = allocator;

Replacement in src/day07b.zig at line 52 [40.470]
B:BD[40.1589] → [41.1171:1201]
```
    const ret = try second();
```
[40.1589]
[40.1611]
```
    const ret = try second(null);
```

Replacement in src/day07a.zig at line 26 [42.34]

B:BD[42.641] → [41.1398:1430]

pub fn first() anyerror!usize {

[42.641]

[41.1430]

pub fn first(allocator: ?std.mem.Allocator) anyerror!usize {
    _ = allocator;

Replacement in src/day07a.zig at line 45 [42.34]
B:BD[42.1934] → [41.1466:1495]
```
    const ret = try first();
```
[42.1934]
[42.1956]
```
    const ret = try first(null);
```

Replacement in src/day06b.zig at line 51 [40.1921]

B:BD[40.2959] → [41.1641:1674]

pub fn second() anyerror!usize {

[40.2959]

[40.2988]

pub fn second(allocator: ?std.mem.Allocator) anyerror!usize {
    _ = allocator;

Replacement in src/day06b.zig at line 59 [40.1921]
B:BD[40.3101] → [41.1675:1705]
```
    const ret = try second();
```
[40.3101]
[40.3123]
```
    const ret = try second(null);
```

Replacement in src/day06a.zig at line 51 [43.34]

B:BD[43.1072] → [41.1859:1891]

pub fn first() anyerror!usize {

[43.1072]

[43.1100]

pub fn first(allocator: ?std.mem.Allocator) anyerror!usize {
    _ = allocator;

Replacement in src/day06a.zig at line 59 [43.34]
B:BD[43.1280] → [41.1892:1921]
```
    const ret = try first();
```
[43.1280]
[43.1302]
```
    const ret = try first(null);
```

Replacement in src/day05b.zig at line 71 [40.3438]

B:BD[40.5596] → [41.2067:2102]

pub fn second() anyerror!RetType {

[40.5596]

[40.5627]

pub fn second(allocator: ?std.mem.Allocator) anyerror!RetType {
    _ = allocator;

Replacement in src/day05b.zig at line 92 [40.3438]
B:BD[40.6191] → [41.2103:2133]
```
    const ret = try second();
```
[40.6191]
[40.6213]
```
    const ret = try second(null);
```

Replacement in src/day05a.zig at line 71 [44.95]

B:BD[44.2460] → [41.2281:2315]

pub fn first() anyerror!RetType {

[44.2460]

[44.2490]

pub fn first(allocator: ?std.mem.Allocator) anyerror!RetType {
    _ = allocator;

Replacement in src/day05a.zig at line 85 [44.95]
B:BD[44.3138] → [41.2316:2345]
```
    const ret = try first();
```
[44.3138]
[44.3160]
```
    const ret = try first(null);
```

Replacement in src/day04b.zig at line 79 [40.6522]

B:BD[40.8595] → [41.2491:2526]

∅:D[41.2526] → [40.8626:8761]

B:BD[40.8626] → [40.8626:8761]

pub fn second() anyerror!retSize {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    var bg = try parseInput(allocator);

[40.8595]

[40.8761]

pub fn second(allocator: ?std.mem.Allocator) anyerror!retSize {
    var bg = try parseInput(allocator.?);

Replacement in src/day04b.zig at line 86 [40.6522]

B:BD[40.8853] → [40.8853:8911]

    var to_remove = std.ArrayList(usize).init(allocator);

[40.8853]

[40.8911]

    var to_remove = std.ArrayList(usize).init(allocator.?);

Insertion in src/day04b.zig at line 124 [40.6522]

[40.10223]

    var buf: [500 * grid_size * grid_size]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);

Replacement in src/day04b.zig at line 128 [40.6522]
B:BD[40.10267] → [41.2527:2557]
```
    const ret = try second();
```
[40.10267]
[40.10289]
```
    const ret = try second(fba.allocator());
```
Deletion in src/day04a.zig at line 78 [45.59]
B:BD[45.2131] → [45.2131:2132]
B:BD[45.2132] → [41.2704:2738]
∅:D[41.2738] → [45.2162:2256]
B:BD[45.2162] → [45.2162:2256]
```
pub fn first() anyerror!retSize {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
```

Replacement in src/day04a.zig at line 79 [45.59]

B:BD[45.2257] → [45.2257:2297]

    var bg = try parseInput(allocator);

[45.2257]

[45.2297]

pub fn first(allocator: ?std.mem.Allocator) anyerror!retSize {
    var bg = try parseInput(allocator.?);

Insertion in src/day04a.zig at line 111 [45.59]

[45.4871]

    var buf: [500 * grid_size * grid_size]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buf);

Replacement in src/day04a.zig at line 115 [45.59]
B:BD[45.4915] → [41.2739:2768]
```
    const ret = try first();
```
[45.4915]
[45.4937]
```
    const ret = try first(fba.allocator());
```
Replacement in src/day03b.zig at line 8 [40.10597]
B:BD[40.10722] → [41.2915:2950]
```
pub fn second() anyerror!retSize {
```
[40.10722]
[40.10753]
```
pub fn second(allocator: ?std.mem.Allocator) anyerror!retSize {
```

Deletion in src/day03b.zig at line 11 [40.10597]

B:BD[40.10840] → [40.10840:10994]


    var buffer: [1000 * lineSize * 100]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buffer);
    const allocator = fba.allocator();

Replacement in src/day03b.zig at line 12 [40.10597]

B:BD[40.10995] → [40.10995:11057]

    var lines_array = std.ArrayList(retSize).init(allocator);

[40.10995]

[40.11057]

    var lines_array = std.ArrayList(retSize).init(allocator.?);

Replacement in src/day03b.zig at line 14 [40.10597]

B:BD[40.11089] → [40.11089:11152]

    var lines_array2 = std.ArrayList(retSize).init(allocator);

[40.11089]

[40.11152]

    var lines_array2 = std.ArrayList(retSize).init(allocator.?);

Replacement in src/day03b.zig at line 22 [40.10597]

B:BD[40.11382] → [40.11382:11502]

    const ox = try getOxigenRating(allocator, &lines_array);
    const co = try getCO2Rating(allocator, &lines_array2);

[40.11382]

[40.11502]

    const ox = try getOxigenRating(allocator.?, &lines_array);
    const co = try getCO2Rating(allocator.?, &lines_array2);

Insertion in src/day03b.zig at line 131 [40.10597]

[40.14364]

    var buffer: [1000 * lineSize * 100]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buffer);

Replacement in src/day03b.zig at line 135 [40.10597]
B:BD[40.14408] → [41.2951:2981]
```
    const ret = try second();
```
[40.14408]
[40.14430]
```
    const ret = try second(fba.allocator());
```

Replacement in src/day03a.zig at line 8 [46.62]

B:BD[46.187] → [2.141:175]

pub fn first() anyerror!RetType {

[46.187]

[46.217]

pub fn first(allocator: ?std.mem.Allocator) anyerror!RetType {
    _ = allocator;

Replacement in src/day03a.zig at line 62 [46.62]
B:BD[46.4766] → [41.3166:3195]
```
    const ret = try first();
```
[46.4766]
[46.4788]
```
    const ret = try first(null);
```

Replacement in src/day02b.zig at line 7 [40.14741]

B:BD[40.14834] → [41.3343:3378]

pub fn second() anyerror!intType {

[40.14834]

[40.14865]

pub fn second(allocator: ?std.mem.Allocator) anyerror!intType {
    _ = allocator;

Replacement in src/day02b.zig at line 45 [40.14741]
B:BD[40.15809] → [41.3379:3409]
```
    const ret = try second();
```
[40.15809]
[40.15831]
```
    const ret = try second(null);
```

Replacement in src/day02a.zig at line 7 [47.65]

B:BD[47.158] → [41.3558:3592]

pub fn first() anyerror!intType {

[47.158]

[47.188]

pub fn first(allocator: ?std.mem.Allocator) anyerror!intType {
    _ = allocator;

Replacement in src/day02a.zig at line 42 [47.65]
B:BD[47.1966] → [41.3593:3622]
```
    const ret = try first();
```
[47.1966]
[47.1988]
```
    const ret = try first(null);
```

Replacement in src/day01b.zig at line 9 [40.16141]

B:BD[40.16380] → [41.3767:3806]

pub fn second() anyerror!decimalSize {

[40.16380]

[40.16415]

pub fn second(allocator: ?std.mem.Allocator) anyerror!decimalSize {
    _ = allocator;

Replacement in src/day01b.zig at line 47 [40.16141]
B:BD[40.17398] → [41.3807:3837]
```
    const ret = try second();
```
[40.17398]
[40.17420]
```
    const ret = try second(null);
```

Replacement in src/day01a.zig at line 9 [18.125]

B:BD[18.404] → [41.3988:4026]

pub fn first() anyerror!decimalSize {

[18.404]

[48.0]

pub fn first(allocator: ?std.mem.Allocator) anyerror!decimalSize {
    _ = allocator;

Replacement in src/day01a.zig at line 41 [18.125]
B:BD[18.1649] → [41.4027:4056]
```
    const ret = try first();
```
[18.1649]
[18.1671]
```
    const ret = try first(null);
```