const std = @import("std");
const print = std.debug.print;

pub fn solve(part: []u8, reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
    if (std.mem.eql(u8, part, "1")) {
        try part1(reader, allocator);
    } else {
        try part2(reader, allocator);
    }
}

const Range = struct { start: usize, end: usize };

fn part1(reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
    var output: usize = 0;

    var ranges = try std.ArrayList(Range).initCapacity(allocator, 0);
    defer ranges.deinit(allocator);

    while (reader.takeDelimiter('\n')) |line| {
        if (line == null or line.?.len == 0){
            break;
        }

        var split = std.mem.splitScalar(u8, line.?, '-');
        const start = try std.fmt.parseInt(usize, split.next().?, 10);
        const end = try std.fmt.parseInt(usize, split.next().?, 10);

        try ranges.append(allocator, Range{ .start=start, .end=end});

    } else |_| {}

    while (reader.takeDelimiter('\n')) |line| {
        if (line == null) {
            break;
        }

        const id = try std.fmt.parseInt(usize, line.?, 10);

        for(ranges.items) |range| {
            if (id >= range.start and id <= range.end) {
                output += 1;
                break;
            }
        }

    } else |_| {}

    print("{d}\n", .{output});
}

fn cmp(_: void, a: Range, b: Range) bool {
        return a.start < b.start;
}

fn part2(reader: *std.Io.Reader, allocator: std.mem.Allocator) !void {
    var output: usize = 0;

    var ranges = try std.ArrayList(Range).initCapacity(allocator, 0);
    defer ranges.deinit(allocator);

    while (reader.takeDelimiter('\n')) |line| {
        if (line == null or line.?.len == 0){
            break;
        }

        var split = std.mem.splitScalar(u8, line.?, '-');
        const start = try std.fmt.parseInt(usize, split.next().?, 10);
        const end = try std.fmt.parseInt(usize, split.next().?, 10);

        try ranges.append(allocator, Range{ .start=start, .end=end});

    } else |_| {}


    std.mem.sort(Range,ranges.items, {}, cmp);

    var more = try std.ArrayList(Range).initCapacity(allocator, 0);
    defer more.deinit(allocator);

    outer: for (ranges.items) |r| {

        const start = r.start;
        const end = r.end;

        for (more.items) |*range| {
            if (start >= range.start and start <= range.end) {
                if (end > range.end){
                    range.end = end;
                }
                continue :outer;
            } else if (start < range.start and end >= range.start) {
                range.start = start;
                continue :outer;
            }
        }

        try more.append(allocator, Range{ .start=start, .end=end});

    }

    for (more.items) |range| {
        output += range.end - range.start + 1;
    }

    print("{d}\n", .{output});
}