const std = @import("std");

// const List = std.ArrayListAlignedUnmanaged;

// const MyList = List(u8, .fromByteUnits(1 << 20));

pub fn main() u8 {
    const Test = struct {
        foo: struct {
            pub fn blub() void {
                std.debug.print("nah\n", .{});
            }

            bar: u64 = 0,

            pub fn blah(x: @This()) void {
                _ = x;
                std.debug.print("\nyeah\n", .{});
            }

            baz: u64 = 0,
        } = .{},
    };

    (Test{}).foo.blah();

    // const arr: [argc]u8 = undefined;
    // arr[0] = argv[0][0];
    // std.debug.print("{}\n", .{arr[0]});

    // const alloc = std.heap.smp_allocator;

    // var my_list = try MyList.initCapacity(alloc, 4);
    // try my_list.append(alloc, 0);
    // try my_list.append(alloc, 1);
    // try my_list.append(alloc, 2);
    // try my_list.append(alloc, 3);

    // std.debug.print("addrs: {}, {}, {}, {}\n", .{
    //     &my_list.items[0],
    //     &my_list.items[1],
    //     &my_list.items[2],
    //     &my_list.items[3],
    // });

    return 0;
}

// pub fn main() u8 {
//     const y: [3]u64 = .{ 1, 2, 3 };
//     const x: struct { u8, u64, u8 } = y;
//     @import("std").debug.print("{}\n", .{x[0] + x[1] + x[2]});

//     std.debug.print("{}\n", .{@sizeOf(struct { u64, ?u8 })});

//     return while (true) if (true) break 1;

//     const x: ?*u64 = null;
//     const y: ?*u32 = @ptrCast(x);
//     _ = y;
// }

// const x: ?u8 = 5;
// if (x == null) {
//     return 1;
// } else |val| {
//     return val;
// }
// var list = std.ArrayList(u8).init(std.heap.smp_allocator);
// try parseUniHex("1f4a9", &list);
// std.debug.print("{s}\n", .{list.items});

// fn parseUniHex(
//     str: []const u8,
//     s: *std.ArrayList(u8),
// ) !void {
//     var uc: u21 = parseHexDigit1(str[0]);
//     for (str[1..]) |c| {
//         uc = try std.math.shlExact(u21, uc, 4);
//         uc |= parseHexDigit1(c);
//     }

//     std.debug.print("{u}\n", .{uc});

//     const n = try std.unicode.utf8CodepointSequenceLength(uc);
//     const buf = try s.addManyAsSlice(n);
//     _ = try std.unicode.utf8Encode(uc, buf);
// }

// fn parseHexByte1(h1: u8, h2: u8) u8 {
//     const hi = parseHexDigit1(h1);
//     const lo = parseHexDigit1(h2);
//     return hi << 4 | lo;
// }

// fn parseHexDigit1(c: u8) u8 {
//     return switch (c) {
//         '0'...'9' => c - '0',
//         'A'...'F' => c - 'A' + 10,
//         'a'...'f' => c - 'a' + 10,
//         else => @panic(""),
//     };
// }

// fn parseHexByte2(h1: u8, h2: u8) u8 {
//     const hi: u8 = parseHexDigit2(h1);
//     const lo = parseHexDigit2(h2);
//     return hi << 4 | lo;
// }

// fn parseHexDigit2(c: u8) u4 {
//     return @intCast(switch (c) {
//         '0'...'9' => c - '0',
//         'A'...'F' => c - 'A' + 10,
//         'a'...'f' => c - 'a' + 10,
//         else => @panic(""),
//     });
// }

// fn parseUniHex1(str: []const u8) !u21 {
//     var uc: u21 = parseHexDigit1(str[0]);
//     for (str[1..]) |c| {
//         uc = try std.math.shlExact(u21, uc, 4);
//         uc |= parseHexDigit1(c);
//     }
//     return uc;
// }

// fn parseUniHex2(str: []const u8) !u21 {
//     var uc: u21 = parseHexDigit2(str[0]);
//     for (str[1..]) |c| {
//         uc = try std.math.shlExact(u21, uc, 4);
//         uc |= parseHexDigit2(c);
//     }
//     return uc;
// }