diff -rN -u old-rig/src/main.zig new-rig/src/main.zig
--- old-rig/src/main.zig	2025-04-19 21:38:56.189663207 +0000
+++ new-rig/src/main.zig	2025-04-19 21:38:56.193663202 +0000
@@ -5,6 +5,7 @@
 
 pub fn main() !void {
     var gpa_alloc = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa_alloc.deinit();
     const alloc = gpa_alloc.allocator();
 
     var seed: u64 = undefined;
@@ -29,29 +30,47 @@
     const root_path = if (home != null) home.? else "/usr";
     const local_path = if (home != null) ".local" else "local";
 
-    const forenames = try std.fmt.allocPrint(alloc, "{s}/{s}/{s}/forenames/{s}.txt", .{ root_path, local_path, base_path, country });
-    defer alloc.free(forenames);
-    const surnames = try std.fmt.allocPrint(alloc, "{s}/{s}/{s}/surnames/{s}.txt", .{ root_path, local_path, base_path, country });
-    defer alloc.free(surnames);
-    const zips = try std.fmt.allocPrint(alloc, "{s}/{s}/{s}/zips/{s}.tsv", .{ root_path, local_path, base_path, country });
-    defer alloc.free(zips);
+    const forenames_path = try std.fmt.allocPrint(alloc, "{s}/{s}/{s}/forenames/{s}.txt", .{ root_path, local_path, base_path, country });
+    defer alloc.free(forenames_path);
+    const surnames_path = try std.fmt.allocPrint(alloc, "{s}/{s}/{s}/surnames/{s}.txt", .{ root_path, local_path, base_path, country });
+    defer alloc.free(surnames_path);
+    const zip_codes_path = try std.fmt.allocPrint(alloc, "{s}/{s}/{s}/zips/{s}.tsv", .{ root_path, local_path, base_path, country });
+    defer alloc.free(zip_codes_path);
 
     const stdout_file = std.io.getStdOut().writer();
     var bw = std.io.bufferedWriter(stdout_file);
     const stdout = bw.writer();
 
-    try stdout.print("Looking for {s}, {s}, {s}\n", .{ forenames, surnames, zips });
+    //try stdout.print("Looking for {s}, {s}, {s}\n", .{ forenames_path, surnames_path, zip_codes_path });
 
-    const f_lines = try readData(alloc, forenames);
-    defer f_lines.deinit();
+    const forenames = try readData(alloc, forenames_path);
+    defer forenames.deinit();
+    const forenames_count: u32 = @intCast(forenames.items.len - 1);
+    const forename_index = calculateRandomEntry(random, forenames_count);
+    //try stdout.print("Using forename {d} of {d}.\n", .{ forename_index, forenames_count });
+    const random_forename = forenames.items[forename_index];
+    defer alloc.free(random_forename);
+
+    const surnames = try readData(alloc, surnames_path);
+    defer surnames.deinit();
+    const surnames_count: u32 = @intCast(surnames.items.len - 1);
+    const surname_index = calculateRandomEntry(random, surnames_count);
+    //try stdout.print("Using surname {d} of {d}.\n", .{ surname_index, surnames_count });
+    const random_surname = surnames.items[surname_index];
+    defer alloc.free(random_surname);
+
+    const zip_codes = try readData(alloc, zip_codes_path);
+    defer zip_codes.deinit();
+    const zip_codes_count: u32 = @intCast(zip_codes.items.len - 1);
+    const zip_code_index = calculateRandomEntry(random, zip_codes_count);
+    //try stdout.print("Using zip code {d} of {d}.\n", .{ zip_code_index, zip_codes_count });
+    const random_zip_code = zip_codes.items[zip_code_index];
+    defer alloc.free(random_zip_code);
 
-    const f_max: u32 = @intCast(f_lines.items.len - 1);
-    const f_rand = calculateRandomEntry(random, f_max);
-    std.debug.print("Using forename {d} of {d}.\n", .{ f_rand, f_max });
-
-    const f_name = f_lines.items[1];
-    std.debug.print("n: {s}\n", .{&f_name});
-    //try stdout.print("Got {s}.", .{f_name});
+    const random_address = try alloc.dupe(u8, random_zip_code);
+    std.mem.replaceScalar(u8, random_address, '\t', ' ');
+
+    try stdout.print("{s} {s}, {s}\n", .{random_forename, random_surname, random_address});
 
     try bw.flush(); // don't forget to flush!
 }
@@ -65,19 +84,32 @@
     const file = try fs.openFileAbsolute(path, .{});
     defer file.close();
 
-    const stat = try file.stat();
-    const buffer = try file.readToEndAlloc(allocator, stat.size);
-    defer allocator.free(buffer);
-    var lines = std.mem.split(u8, buffer, "\n");
-    errdefer allocator.free(lines);
-    var result = std.ArrayList([]const u8).init(allocator);
-    errdefer result.deinit();
-    while (lines.next()) |line| {
-        result.append(line) catch |e| {
-            switch (e) {
-                else => std.debug.print("error: {any}", .{e}),
+    var buf_reader = std.io.bufferedReader(file.reader());
+    const reader = buf_reader.reader();
+
+    var lines = std.ArrayList([]const u8).init(allocator);
+    errdefer lines.deinit();
+
+    var line = std.ArrayList(u8).init(allocator);
+    defer line.deinit();
+
+    const writer = line.writer();
+    while (reader.streamUntilDelimiter(writer, '\n', null)) {
+        defer line.clearRetainingCapacity();
+        //std.debug.print("read line: '{s}'\n", .{line.items});
+        const str = try std.fmt.allocPrint(allocator, "{s}", .{line.items});
+        errdefer allocator.free(str);
+        try lines.append(str);
+    } else |e| switch (e) {
+        error.EndOfStream => {
+            if (line.items.len > 0) {
+                //std.debug.print("read line: '{s}'\n", .{line.items});
+                const str = try std.fmt.allocPrint(allocator, "{s}", .{line.items});
+                errdefer allocator.free(str);
+                try lines.append(str);
             }
-        };
+        },
+        else => return e, // Escalate error.
     }
-    return result;
+    return lines;
 }