From b250eb6135475699a945324c005890e8e1b4dd0b Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Wed, 28 Oct 2026 21:03:48 -0300 Subject: kitty graphics conformance for terminal panes: a core suite (test/kitty.zig, `zig build kitty-test`, in unit-test) and an end-to-end harness (`zig build kitty-harness`, tty and gui); four gaps it found fixed, one left The core suite feeds a pane's output as pty reads do and checks what the program reads back, ghostty's image storage and the ImagePlaces a frame draws: queries and their errors, q=0/1/2, f=24/32/100 and o=z, chunked m=1 split at every read size, t=f/t=t/t=s, a=T and C=1 cursor movement, a=p by placement id with source rects and re-puts, image numbers, every d= delete (a/A i/I n/N c/C p/P q/Q x/X y/Y z/Z r/R) and a delete abandoning a chunked load, Unicode placeholders over two rows with implicit columns and a placement named in the underline colour, scroll/resize/reflow, the alternate screen, clear (ED 2 + ED 3), replies per pane and never in the cells, many replies from one read, kitty before DA, CAN/SUB, an oversized image, 300 images against the storage limit, animations and relative placements. The harness runs test/kitty_client.zig in a pane's bash (query, a 16-chunk 8x4-cell place, the three media, quiet levels, CAN, show then delete) and kitten icat (stream and detect) and chafa when installed. Outside, the tty arm is a kitty terminal (a ghostty-vt emulator): the image pardes re-emits lands at the cell after ANCHOR>, 8x4 cells a row at a time, the client's own commands and replies never pass through, and d=I frees what was sent. The gui arm reads the GPU capture. Fixed: kitty file, temporary-file and shared-memory media (libghostty defaults to direct only; now allWithTempDir like ghostty and kitty); replies past 256 bytes of one read were cut mid-sequence (4 KiB now, an answer that does not fit dropped whole and counted); animations never played (TerminalImages draws renderData(), ticks ImageStorage.animationTick on the core clock, nextWake wakes for the next frame); relative placements (P=/Q=/H=/V=) were not drawn (resolveChain, as ghostty's renderer). image.decode no longer jumps through stb_image's null allocator before image.start. Known gap (a knownGap test): no z-index; every image is drawn over the cells in storage order. Co-Authored-By: Claude Opus 5.5 --- test/kitty.zig | 778 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 778 insertions(+) create mode 100644 test/kitty.zig (limited to 'test/kitty.zig') diff --git a/test/kitty.zig b/test/kitty.zig new file mode 100644 index 00000000..3f9776fa --- /dev/null +++ b/test/kitty.zig @@ -0,0 +1,778 @@ +//! Kitty graphics protocol conformance for terminal panes, at the core. +//! +//! zig build kitty-test -Dplatform=tty|gui these cases alone +//! zig build unit-test they run with the rest +//! +//! ghostty-vt implements the protocol; what pardes owns is the proxy around +//! it: a program's APC reaches the emulator whole however the pty splits it, +//! the emulator's replies go back to that program's pty (and nowhere else), +//! and what the emulator stores is drawn where the program put it. Each case +//! feeds a pane's output the way a pty read does and checks all three: the +//! bytes the program would read back, ghostty's image storage, and the +//! `ImagePlace`s a frame hands the shell (which a tty re-emits to the outer +//! terminal and the GUI draws; test/kitty_harness.zig follows them there). +//! +//! A case pardes does not pass yet is a `knownGap`: its check runs, the test +//! is skipped with the reason while it fails, and fails once it passes, so +//! the marker goes when the gap closes. +const std = @import("std"); +const pardes = @import("pardes"); +const Pardes = pardes.Pardes; +const config = pardes.config; +const terminal = pardes.panes.terminal; + +const gpa = std.testing.allocator; + +// 4x2 pixels, the left half red and the right half blue, in every encoding +// the protocol has (generated with Python's zlib and a hand-built PNG). +const rgb_b64 = "/wAA/wAAAAD/AAD//wAA/wAAAAD/AAD/"; +const rgba_b64 = "/wAA//8AAP8AAP//AAD///8AAP//AAD/AAD//wAA//8="; +const rgb_zlib_b64 = "eJz7z8Dwn4EBTPz/j8QGAGO0B/k="; +const png_b64 = "iVBORw0KGgoAAAANSUhEUgAAAAQAAAACCAIAAADwyuo0AAAAE0lEQVR4nGP4z8AARGDiPwMyBwBnsgf5Q2OaZwAAAABJRU5ErkJggg=="; +const rgb_raw = [_]u8{ 255, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 255, 255, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 255 }; +// 256x256 transparent RGBA, zlib: 256 KiB stored per copy for 373 bytes sent. +const blank_256_zlib_b64 = "eNrtwTEBAAAAwqD1T+1tB6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN4AADwAAQ=="; + +const red = [4]u8{ 255, 0, 0, 255 }; +const blue = [4]u8{ 0, 0, 255, 255 }; + +/// `ESC _ G ; ESC \` +inline fn apc(comptime control: []const u8, comptime payload: []const u8) []const u8 { + return comptime "\x1b_G" ++ control ++ ";" ++ payload ++ "\x1b\\"; +} + +/// What the protocol answers: `ESC _ G ; ESC \` +inline fn reply(comptime keys: []const u8, comptime message: []const u8) []const u8 { + return comptime "\x1b_G" ++ keys ++ ";" ++ message ++ "\x1b\\"; +} + +fn knownGap(comptime reason: []const u8, passes: bool) !void { + if (passes) { + std.debug.print("kitty: a known gap passes now, drop its marker: {s}\n", .{reason}); + return error.KnownGapNowPasses; + } + std.debug.print("kitty: known gap: {s}\n", .{reason}); + return error.SkipZigTest; +} + +/// A session of `shells` (1, or up to 3) terminal panes with 10x20 pixel cells, under a +/// shell that draws pixels, every pane's keyboard at its pty. +const Rig = struct { + p: *Pardes, + frame: std.heap.ArenaAllocator, + /// What each pane's program has read back since `take`. + read: [pardes.MAX_PANES]std.ArrayList(u8) = @splat(.empty), + + fn init(shells: u8) !Rig { + // f=100 decodes through pardes's own decoder (stb_image), which the + // shells start at launch. + pardes.image.start(std.testing.io, gpa); + // ghostty warns of every refused command; the refusals are the point. + std.testing.log_level = .err; + // A core boots one shell or the classic three. + const p = try Pardes.init(gpa, .{ .cols = 120, .rows = 40, .shells = if (shells > 1) 3 else 1 }); + p.native_images = true; + p.update(.{ .resize = .{ .cols = 120, .rows = 40, .cell_pixels = .{ .w = 10, .h = 20 } } }); + for (p.panes) |slot| if (slot) |each| { + each.body.mode = .tty; + }; + var r: Rig = .{ .p = p, .frame = .init(gpa) }; + r.drain(); + for (&r.read) |*b| b.clearRetainingCapacity(); + return r; + } + + fn deinit(r: *Rig) void { + for (&r.read) |*b| b.deinit(gpa); + r.frame.deinit(); + r.p.deinit(); + pardes.image.stop(); + } + + fn drain(r: *Rig) void { + while (r.p.nextEffect()) |effect| { + if (effect == .write) r.read[effect.write.pane].appendSlice(gpa, effect.write.bytes.slice()) catch @panic("OOM"); + } + } + + /// One pty read of pane `id`'s output. + fn feed(r: *Rig, id: u8, bytes: []const u8) void { + r.p.update(.{ .output = .{ .pane = id, .bytes = bytes } }); + r.drain(); + } + + /// The same output, as reads of `step` bytes. + fn feedSplit(r: *Rig, id: u8, bytes: []const u8, step: usize) void { + var at: usize = 0; + while (at < bytes.len) : (at += step) r.feed(id, bytes[at..@min(bytes.len, at + step)]); + } + + /// What pane `id`'s program read back, since the last take. + fn take(r: *Rig, id: u8) ![]u8 { + defer r.read[id].clearRetainingCapacity(); + return r.frame.allocator().dupe(u8, r.read[id].items); + } + + fn pane(r: *Rig, id: u8) *pardes.Pane { + return r.p.panes[id].?; + } + + fn vt(r: *Rig, id: u8) @TypeOf(&r.pane(id).terminal.?.vt) { + return &r.pane(id).terminal.?.vt; + } + + fn storage(r: *Rig, id: u8) @TypeOf(&r.vt(id).screens.active.kitty_images) { + return &r.vt(id).screens.active.kitty_images; + } + + fn places(r: *Rig) ![]const ?pardes.ImagePlace { + _ = r.frame.reset(.retain_capacity); + const s = try r.p.render(r.frame.allocator()); + return s.images[0..s.nimages]; + } + + /// The top-left cell of pane `id`'s body, in screen cells. + fn origin(r: *Rig, id: u8) struct { x: u16, y: u16 } { + const rect = r.p.rects[id]; + return .{ .x = rect.x + config.GUTTER, .y = r.p.bodyTop(r.pane(id), rect) }; + } + + /// The places drawn for the image a program called `image_id`. + fn placesOf(r: *Rig, image_id: u32) ![]const pardes.ImagePlace { + var out: std.ArrayList(pardes.ImagePlace) = .empty; + for (try r.places()) |maybe| if (maybe) |place| if (place.native.page == image_id) + try out.append(r.frame.allocator(), place); + return out.items; + } + + fn placementCount(r: *Rig, id: u8) usize { + return r.storage(id).placements.count(); + } + + fn hasImage(r: *Rig, id: u8, image_id: u32) bool { + return r.storage(id).imageById(image_id) != null; + } +}; + +/// The pixel at `(x, y)` of a drawn place's whole image, as RGBA. +fn pixel(place: pardes.ImagePlace, x: usize, y: usize) [4]u8 { + return place.rgba[(y * place.iw + x) * 4 ..][0..4].*; +} + +test "kitty: a support query is answered on the asking pane's pty and stores nothing" { + var r = try Rig.init(2); + defer r.deinit(); + r.feed(1, apc("i=31,s=1,v=1,a=q,t=d,f=24", "AAAA")); + try std.testing.expectEqualStrings(reply("i=31", "OK"), try r.take(1)); + try std.testing.expectEqualStrings("", try r.take(0)); + try std.testing.expect(!r.hasImage(1, 31)); + try std.testing.expectEqual(@as(usize, 0), (try r.places()).len); +} + +test "kitty: a query that cannot load says why, with its keys" { + var r = try Rig.init(1); + defer r.deinit(); + // Too little data for a 2x2 RGB image. + r.feed(0, apc("i=32,s=2,v=2,a=q,t=d,f=24", "AAAA")); + const got = try r.take(0); + try std.testing.expect(std.mem.startsWith(u8, got, "\x1b_Gi=32;E")); + try std.testing.expect(std.mem.endsWith(u8, got, "\x1b\\")); + try std.testing.expectEqual(@as(usize, 1), std.mem.count(u8, got, "\x1b_G")); +} + +test "kitty: quiet levels: q=1 drops the OK, q=2 the errors too" { + const Case = struct { control: []const u8, payload: []const u8, answered: bool }; + const cases = [_]Case{ + .{ .control = "i=33,s=1,v=1,a=q,f=24,q=0", .payload = "AAAA", .answered = true }, + .{ .control = "i=33,s=1,v=1,a=q,f=24,q=1", .payload = "AAAA", .answered = false }, + .{ .control = "i=33,s=2,v=2,a=q,f=24,q=1", .payload = "AAAA", .answered = true }, + .{ .control = "i=33,s=2,v=2,a=q,f=24,q=2", .payload = "AAAA", .answered = false }, + .{ .control = "i=33,s=4,v=2,a=t,f=24,q=1", .payload = rgb_b64, .answered = false }, + .{ .control = "i=33,a=p,q=2", .payload = "", .answered = false }, + }; + for (cases) |c| { + var r = try Rig.init(1); + defer r.deinit(); + const bytes = try std.fmt.allocPrint(r.frame.allocator(), "\x1b_G{s};{s}\x1b\\", .{ c.control, c.payload }); + r.feed(0, bytes); + const got = try r.take(0); + std.testing.expectEqual(c.answered, got.len > 0) catch |err| { + std.debug.print("q case {s}: read back {f}\n", .{ c.control, std.ascii.hexEscape(got, .lower) }); + return err; + }; + } +} + +test "kitty: RGB, RGBA, PNG and zlib-compressed RGB all draw the same pixels" { + const Case = struct { control: []const u8, payload: []const u8 }; + const cases = [_]Case{ + .{ .control = "a=T,i=1,f=24,s=4,v=2,c=2,r=1", .payload = rgb_b64 }, + .{ .control = "a=T,i=1,f=32,s=4,v=2,c=2,r=1", .payload = rgba_b64 }, + .{ .control = "a=T,i=1,f=100,c=2,r=1", .payload = png_b64 }, + .{ .control = "a=T,i=1,f=24,o=z,s=4,v=2,c=2,r=1", .payload = rgb_zlib_b64 }, + }; + for (cases) |c| { + var r = try Rig.init(1); + defer r.deinit(); + r.feed(0, try std.fmt.allocPrint(r.frame.allocator(), "\x1b_G{s};{s}\x1b\\", .{ c.control, c.payload })); + try std.testing.expectEqualStrings(reply("i=1", "OK"), try r.take(0)); + const img = r.storage(0).imageById(1) orelse return error.NotStored; + try std.testing.expectEqual(@as(u32, 4), img.width); + try std.testing.expectEqual(@as(u32, 2), img.height); + const drawn = try r.placesOf(1); + try std.testing.expectEqual(@as(usize, 1), drawn.len); + try std.testing.expectEqual(@as(usize, 4), drawn[0].iw); + for ([_][2]usize{ .{ 0, 0 }, .{ 1, 1 } }) |at| try std.testing.expectEqual(red, pixel(drawn[0], at[0], at[1])); + for ([_][2]usize{ .{ 2, 0 }, .{ 3, 1 } }) |at| try std.testing.expectEqual(blue, pixel(drawn[0], at[0], at[1])); + } +} + +test "kitty: a chunked transmission arrives whole however the pty splits it, answered once" { + // Three chunks of base64 (each a multiple of four), the keys on the first. + const chunked = apc("a=T,i=2,f=24,s=4,v=2,c=2,r=1,m=1", rgb_b64[0..8]) ++ + apc("m=1", rgb_b64[8..20]) ++ apc("m=0", rgb_b64[20..]); + for ([_]usize{ 1, 2, 3, 5, 7, 16, 64, chunked.len }) |step| { + var r = try Rig.init(1); + defer r.deinit(); + r.feedSplit(0, chunked, step); + try std.testing.expectEqualStrings(reply("i=2", "OK"), try r.take(0)); + const img = r.storage(0).imageById(2) orelse return error.NotStored; + try std.testing.expectEqualSlices(u8, &rgb_raw, img.data.bytes().?); + try std.testing.expectEqual(@as(usize, 1), (try r.placesOf(2)).len); + } +} + +test "kitty: text around an APC prints, in the same read and split across reads" { + for ([_]usize{ 1, 4, 1024 }) |step| { + var r = try Rig.init(1); + defer r.deinit(); + r.feedSplit(0, "before" ++ apc("a=t,i=3,f=24,s=4,v=2,q=2", rgb_b64) ++ "after", step); + const text = try terminal.screenTextAlloc(r.pane(0), r.frame.allocator()); + try std.testing.expect(std.mem.indexOf(u8, text, "beforeafter") != null); + try std.testing.expect(r.hasImage(0, 3)); + } +} + +const shm = struct { + extern "c" fn shm_open(name: [*:0]const u8, flag: c_int, mode: std.c.mode_t) c_int; + extern "c" fn shm_unlink(name: [*:0]const u8) c_int; +}; + +fn writeTemp(path: [:0]const u8, bytes: []const u8) !void { + const fd = std.c.open(path, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true }, @as(std.c.mode_t, 0o600)); + if (fd < 0) return error.OpenFailed; + defer _ = std.c.close(fd); + if (std.c.write(fd, bytes.ptr, bytes.len) != @as(isize, @intCast(bytes.len))) return error.WriteFailed; +} + +fn exists(path: [:0]const u8) bool { + return std.c.access(path, std.c.F_OK) == 0; +} + +fn b64(arena: std.mem.Allocator, bytes: []const u8) ![]const u8 { + const enc = std.base64.standard.Encoder; + const out = try arena.alloc(u8, enc.calcSize(bytes.len)); + return enc.encode(out, bytes); +} + +test "kitty: file, temporary-file and shared-memory media load, and the terminal removes what it should" { + var r = try Rig.init(1); + defer r.deinit(); + const arena = r.frame.allocator(); + const pid = std.c.getpid(); + + // t=f: a file the program keeps. + const file = try std.fmt.allocPrintSentinel(arena, "/tmp/pardes-kitty-{d}-file.rgb", .{pid}, 0); + try writeTemp(file, &rgb_raw); + defer _ = std.c.unlink(file); + r.feed(0, try std.fmt.allocPrint(arena, "\x1b_Ga=t,t=f,i=41,f=24,s=4,v=2;{s}\x1b\\", .{try b64(arena, file)})); + const file_reply = try r.take(0); + // t=t: a temporary file, which the terminal deletes once read; its name + // must say it is one. + const temp = try std.fmt.allocPrintSentinel(arena, "/tmp/tty-graphics-protocol-pardes-{d}.rgb", .{pid}, 0); + try writeTemp(temp, &rgb_raw); + defer _ = std.c.unlink(temp); + r.feed(0, try std.fmt.allocPrint(arena, "\x1b_Ga=t,t=t,i=42,f=24,s=4,v=2;{s}\x1b\\", .{try b64(arena, temp)})); + const temp_reply = try r.take(0); + // t=s: a POSIX shared memory object, which the terminal unlinks. + const name = try std.fmt.allocPrintSentinel(arena, "/pardes-kitty-{d}", .{pid}, 0); + const fd = shm.shm_open(name, @bitCast(std.c.O{ .ACCMODE = .RDWR, .CREAT = true, .TRUNC = true }), 0o600); + if (fd < 0) return error.ShmOpenFailed; + defer _ = shm.shm_unlink(name); + if (std.c.write(fd, &rgb_raw, rgb_raw.len) != rgb_raw.len) return error.WriteFailed; + _ = std.c.close(fd); + r.feed(0, try std.fmt.allocPrint(arena, "\x1b_Ga=t,t=s,i=43,f=24,s=4,v=2,S={d};{s}\x1b\\", .{ rgb_raw.len, try b64(arena, name) })); + const shm_reply = try r.take(0); + + const passes = std.mem.eql(u8, file_reply, reply("i=41", "OK")) and + std.mem.eql(u8, temp_reply, reply("i=42", "OK")) and + std.mem.eql(u8, shm_reply, reply("i=43", "OK")); + if (!passes) { + std.debug.print("media replies: f {f} | t {f} | s {f}\n", .{ + std.ascii.hexEscape(file_reply, .lower), + std.ascii.hexEscape(temp_reply, .lower), + std.ascii.hexEscape(shm_reply, .lower), + }); + return error.MediumRefused; + } + for ([_]u32{ 41, 42, 43 }) |id| { + const img = r.storage(0).imageById(id) orelse return error.NotStored; + try std.testing.expectEqualSlices(u8, &rgb_raw, img.data.bytes().?); + } + try std.testing.expect(exists(file)); + try std.testing.expect(!exists(temp)); +} + +test "kitty: a temporary file outside the temp directory, or not named as one, is refused" { + var r = try Rig.init(1); + defer r.deinit(); + const arena = r.frame.allocator(); + const file = try std.fmt.allocPrintSentinel(arena, "/tmp/pardes-kitty-{d}-notemp.rgb", .{std.c.getpid()}, 0); + try writeTemp(file, &rgb_raw); + defer _ = std.c.unlink(file); + r.feed(0, try std.fmt.allocPrint(arena, "\x1b_Ga=t,t=t,i=44,f=24,s=4,v=2;{s}\x1b\\", .{try b64(arena, file)})); + const got = try r.take(0); + try std.testing.expect(std.mem.startsWith(u8, got, "\x1b_Gi=44;E")); + try std.testing.expect(!r.hasImage(0, 44)); + // Refused, it is left where it was. + try std.testing.expect(exists(file)); +} + +test "kitty: a=T draws at the cursor and moves the cursor past the image; C=1 leaves it" { + for ([_]bool{ false, true }) |still| { + var r = try Rig.init(1); + defer r.deinit(); + if (still) + r.feed(0, "\x1b[3;5H" ++ apc("a=T,i=4,f=24,s=4,v=2,c=2,r=2,C=1,q=2", rgb_b64)) + else + r.feed(0, "\x1b[3;5H" ++ apc("a=T,i=4,f=24,s=4,v=2,c=2,r=2,q=2", rgb_b64)); + const cursor = r.vt(0).screens.active.cursor; + if (still) { + try std.testing.expectEqual(@as(usize, 4), cursor.x); + try std.testing.expectEqual(@as(usize, 2), cursor.y); + } else { + // Kitty: one cell past the image's right edge, on its last row. + try std.testing.expectEqual(@as(usize, 6), cursor.x); + try std.testing.expectEqual(@as(usize, 3), cursor.y); + } + const drawn = try r.placesOf(4); + // A cell row at a time: two rows. + try std.testing.expectEqual(@as(usize, 2), drawn.len); + const o = r.origin(0); + try std.testing.expectEqual(o.x + 4, drawn[0].x); + try std.testing.expectEqual(o.y + 2, drawn[0].y); + try std.testing.expectEqual(o.y + 3, drawn[1].y); + for (drawn) |place| try std.testing.expectEqual(@as(u16, 2), place.w); + } +} + +test "kitty: a=p places one image twice by placement id, a source rect crops it, and a re-put moves it" { + var r = try Rig.init(1); + defer r.deinit(); + r.feed(0, apc("a=t,i=7,f=24,s=4,v=2", rgb_b64)); + try std.testing.expectEqualStrings(reply("i=7", "OK"), try r.take(0)); + try std.testing.expectEqual(@as(usize, 0), (try r.placesOf(7)).len); + r.feed(0, "\x1b[1;1H" ++ apc("a=p,i=7,p=1,c=2,r=1", "")); + try std.testing.expectEqualStrings(reply("i=7,p=1", "OK"), try r.take(0)); + // The right half only (x=2, w=2): blue, in one cell. + r.feed(0, "\x1b[6;10H" ++ apc("a=p,i=7,p=2,x=2,y=0,w=2,h=2,c=1,r=1", "")); + try std.testing.expectEqualStrings(reply("i=7,p=2", "OK"), try r.take(0)); + try std.testing.expectEqual(@as(usize, 2), r.placementCount(0)); + const o = r.origin(0); + var drawn = try r.placesOf(7); + try std.testing.expectEqual(@as(usize, 2), drawn.len); + var cropped: ?pardes.ImagePlace = null; + for (drawn) |place| if (place.y == o.y + 5) { + cropped = place; + }; + const crop = cropped orelse return error.CroppedPlacementMissing; + try std.testing.expectEqual(o.x + 9, crop.x); + try std.testing.expectEqual(@as(u16, 1), crop.w); + const g = crop.native.geometry.?; + try std.testing.expectEqual(@as(u32, 2), g.src.x); + try std.testing.expectEqual(@as(u32, 2), g.src.w); + // Put again under the same id, placement 1 moves; it is not doubled. + r.feed(0, "\x1b[10;1H" ++ apc("a=p,i=7,p=1,c=2,r=1,q=1", "")); + try std.testing.expectEqual(@as(usize, 2), r.placementCount(0)); + drawn = try r.placesOf(7); + var at_ten = false; + var at_one = false; + for (drawn) |place| { + if (place.y == o.y + 9) at_ten = true; + if (place.y == o.y) at_one = true; + } + try std.testing.expect(at_ten and !at_one); +} + +test "kitty: a=p of an image that is not there answers ENOENT" { + var r = try Rig.init(1); + defer r.deinit(); + r.feed(0, apc("a=p,i=99", "")); + const got = try r.take(0); + try std.testing.expect(std.mem.startsWith(u8, got, "\x1b_Gi=99;ENOENT")); +} + +test "kitty: an image number gets an id, which the reply carries" { + var r = try Rig.init(1); + defer r.deinit(); + r.feed(0, apc("a=t,I=5,f=24,s=4,v=2", rgb_b64)); + const got = try r.take(0); + // `i=,I=5;OK` + try std.testing.expect(std.mem.startsWith(u8, got, "\x1b_Gi=")); + try std.testing.expect(std.mem.endsWith(u8, got, ",I=5;OK\x1b\\")); + try std.testing.expect(r.storage(0).imageByNumber(5) != null); +} + +test "kitty: z-index orders images, and a negative one goes under the text" { + var r = try Rig.init(1); + defer r.deinit(); + r.feed(0, "\x1b[1;1H" ++ apc("a=T,i=8,f=24,s=4,v=2,c=2,r=1,z=-1,q=2", rgb_b64) ++ "\x1b[1;1Htext"); + try std.testing.expectEqual(@as(usize, 1), r.placementCount(0)); + var it = r.storage(0).placements.iterator(); + try std.testing.expectEqual(@as(i32, -1), it.next().?.value_ptr.z); + try knownGap("pardes draws every terminal image over the cells, in storage order: an ImagePlace has no z-index, so z<0 (under the text) and the order between overlapping images are lost", @hasField(pardes.ImagePlace, "z")); +} + +/// A screen with two images in known places, for the deletes: +/// image 1: placement 1 at (0,0) 2x1, placement 2 at (10,5) 2x1, z=5 +/// image 2: placement 1 at (20,8) 2x2, z=-3 +/// and the cursor parked at (20,8), on image 2. +fn deleteScene(r: *Rig) void { + r.feed(0, apc("a=t,i=1,f=24,s=4,v=2,q=2", rgb_b64) ++ apc("a=t,i=2,f=24,s=4,v=2,q=2", rgb_b64)); + r.feed(0, "\x1b[1;1H" ++ apc("a=p,i=1,p=1,c=2,r=1,C=1,q=2", "") ++ + "\x1b[6;11H" ++ apc("a=p,i=1,p=2,c=2,r=1,z=5,C=1,q=2", "") ++ + "\x1b[9;21H" ++ apc("a=p,i=2,p=1,c=2,r=2,z=-3,C=1,q=2", "")); +} + +test "kitty: every delete takes the placements it names, and the uppercase ones free the image" { + const Case = struct { + control: []const u8, + /// Placements left, and whether images 1 and 2 are still stored. + left: usize, + one: bool, + two: bool, + }; + const cases = [_]Case{ + .{ .control = "a=d", .left = 0, .one = true, .two = true }, // d=a is the default + .{ .control = "a=d,d=a", .left = 0, .one = true, .two = true }, + .{ .control = "a=d,d=A", .left = 0, .one = false, .two = false }, + .{ .control = "a=d,d=i,i=1", .left = 1, .one = true, .two = true }, + .{ .control = "a=d,d=I,i=1", .left = 1, .one = false, .two = true }, + .{ .control = "a=d,d=i,i=1,p=2", .left = 2, .one = true, .two = true }, + .{ .control = "a=d,d=c", .left = 2, .one = true, .two = true }, + .{ .control = "a=d,d=C", .left = 2, .one = true, .two = false }, + .{ .control = "a=d,d=p,x=11,y=6", .left = 2, .one = true, .two = true }, + .{ .control = "a=d,d=P,x=21,y=10", .left = 2, .one = true, .two = false }, + .{ .control = "a=d,d=q,x=11,y=6,z=5", .left = 2, .one = true, .two = true }, + .{ .control = "a=d,d=q,x=11,y=6,z=4", .left = 3, .one = true, .two = true }, + .{ .control = "a=d,d=x,x=2", .left = 2, .one = true, .two = true }, + .{ .control = "a=d,d=X,x=22", .left = 2, .one = true, .two = false }, + .{ .control = "a=d,d=y,y=6", .left = 2, .one = true, .two = true }, + .{ .control = "a=d,d=Y,y=10", .left = 2, .one = true, .two = false }, + .{ .control = "a=d,d=z,z=-3", .left = 2, .one = true, .two = true }, + .{ .control = "a=d,d=Z,z=-3", .left = 2, .one = true, .two = false }, + .{ .control = "a=d,d=r,x=1,y=1", .left = 1, .one = true, .two = true }, + .{ .control = "a=d,d=R,x=1,y=2", .left = 0, .one = false, .two = false }, + }; + for (cases) |c| { + var r = try Rig.init(1); + defer r.deinit(); + deleteScene(&r); + try std.testing.expectEqual(@as(usize, 3), r.placementCount(0)); + try std.testing.expectEqual(@as(usize, 4), (try r.places()).len); + r.feed(0, try std.fmt.allocPrint(r.frame.allocator(), "\x1b_G{s}\x1b\\", .{c.control})); + const drawn = (try r.places()).len; + const got = .{ r.placementCount(0), r.hasImage(0, 1), r.hasImage(0, 2) }; + std.testing.expectEqual(.{ c.left, c.one, c.two }, got) catch |err| { + std.debug.print("delete {s}: left {d}, image 1 {}, image 2 {}\n", .{ c.control, got[0], got[1], got[2] }); + return err; + }; + // Deletes never answer, and the frame draws what is left: a 2x1 + // placement is one place, the 2x2 one two. + try std.testing.expectEqualStrings("", try r.take(0)); + var rows: usize = 0; + var it = r.storage(0).placements.iterator(); + while (it.next()) |entry| rows += if (entry.key_ptr.image_id == 2) 2 else 1; + try std.testing.expectEqual(rows, drawn); + } +} + +test "kitty: deletes by image number take that image's placements, and N frees it" { + for ([_]bool{ false, true }) |free| { + var r = try Rig.init(1); + defer r.deinit(); + r.feed(0, "\x1b[1;1H" ++ apc("a=T,I=11,f=24,s=4,v=2,c=2,r=1,C=1,q=2", rgb_b64) ++ + "\x1b[5;1H" ++ apc("a=T,i=2,f=24,s=4,v=2,c=2,r=1,C=1,q=2", rgb_b64)); + try std.testing.expectEqual(@as(usize, 2), r.placementCount(0)); + if (free) r.feed(0, apc("a=d,d=N,I=11", "")) else r.feed(0, apc("a=d,d=n,I=11", "")); + try std.testing.expectEqual(@as(usize, 1), r.placementCount(0)); + try std.testing.expectEqual(!free, r.storage(0).imageByNumber(11) != null); + try std.testing.expect(r.hasImage(0, 2)); + try std.testing.expectEqual(@as(usize, 1), (try r.places()).len); + } +} + +test "kitty: a delete abandons a chunked load in progress" { + var r = try Rig.init(1); + defer r.deinit(); + r.feed(0, apc("a=t,i=9,f=24,s=4,v=2,m=1", rgb_b64[0..8])); + r.feed(0, apc("a=d,d=A", "")); + r.feed(0, apc("m=0", rgb_b64[8..])); + try std.testing.expect(!r.hasImage(0, 9)); +} + +test "kitty: Unicode placeholders draw a virtual placement over two rows, with implicit columns" { + var r = try Rig.init(1); + defer r.deinit(); + // Image 7 in the placeholders' foreground; row diacritics U+0305 (0) + // and U+030D (1); the first cell of each row names its column (U+0305 = + // 0) and the next one carries on from it with no diacritic of its own. + r.feed(0, apc("a=T,U=1,i=7,f=24,s=4,v=2,c=2,r=2,q=2", rgb_b64) ++ + "\x1b[2;3H\x1b[38;2;0;0;7m\u{10EEEE}\u{0305}\u{0305}\u{10EEEE}" ++ + "\x1b[3;3H\u{10EEEE}\u{030D}\u{0305}\u{10EEEE}\x1b[39mX"); + const drawn = try r.placesOf(7); + const o = r.origin(0); + try std.testing.expectEqual(@as(usize, 2), drawn.len); + try std.testing.expectEqual(o.x + 2, drawn[0].x); + try std.testing.expectEqual(o.y + 1, drawn[0].y); + try std.testing.expectEqual(o.y + 2, drawn[1].y); + for (drawn) |place| try std.testing.expectEqual(@as(u16, 2), place.w); + // The top row shows the image's top half, the bottom its bottom half. + try std.testing.expectEqual(@as(u32, 0), drawn[0].native.geometry.?.src.y); + try std.testing.expectEqual(@as(u32, 1), drawn[1].native.geometry.?.src.y); +} + +test "kitty: a placeholder naming its placement in the underline colour picks that placement" { + var r = try Rig.init(1); + defer r.deinit(); + // Two virtual placements of image 7: p=1 one cell, p=2 two cells wide. + r.feed(0, apc("a=t,i=7,f=24,s=4,v=2,q=2", rgb_b64) ++ + apc("a=p,U=1,i=7,p=1,c=1,r=1,q=2", "") ++ apc("a=p,U=1,i=7,p=2,c=2,r=1,q=2", "") ++ + "\x1b[1;1H\x1b[38;2;0;0;7m\x1b[58;2;0;0;2m\u{10EEEE}\u{0305}\u{0305}\u{10EEEE}\x1b[39;59m"); + const drawn = try r.placesOf(7); + try std.testing.expectEqual(@as(usize, 1), drawn.len); + // Placement 2 spans two cells, so each cell is half the image. + try std.testing.expectEqual(@as(u16, 2), drawn[0].w); +} + +test "kitty: an image follows its text when the shell scrolls, resizes and reflows" { + var r = try Rig.init(1); + defer r.deinit(); + r.feed(0, "\x1b[5;1Hmarker" ++ apc("a=T,i=10,f=24,s=4,v=2,c=2,r=1,q=2", rgb_b64)); + const o = r.origin(0); + try std.testing.expectEqual(o.y + 4, (try r.placesOf(10))[0].y); + // Two lines of output at the bottom scroll it up two rows. + r.feed(0, "\x1b[40;1H\n\n"); + try std.testing.expectEqual(o.y + 2, (try r.placesOf(10))[0].y); + // A narrower pane reflows the text; the image stays on its row. + const pane = r.pane(0); + terminal.resizeGrid(pane, gpa, 40, pane.rows); + const text = try terminal.screenTextAlloc(pane, r.frame.allocator()); + var row: usize = 0; + var lines = std.mem.splitScalar(u8, text, '\n'); + while (lines.next()) |line| : (row += 1) if (std.mem.startsWith(u8, line, "marker")) break; + const drawn = try r.placesOf(10); + try std.testing.expectEqual(@as(usize, 1), drawn.len); + const viewport_top: usize = @intCast(terminal.gridOffset(pane)); + try std.testing.expectEqual(o.y + @as(u16, @intCast(row - viewport_top)), drawn[0].y); +} + +test "kitty: the alternate screen has its own images, and the primary's come back after it" { + var r = try Rig.init(1); + defer r.deinit(); + r.feed(0, "\x1b[1;1H" ++ apc("a=T,i=11,f=24,s=4,v=2,c=2,r=1,q=2", rgb_b64)); + r.feed(0, "\x1b[?1049h"); + try std.testing.expectEqual(@as(usize, 0), (try r.placesOf(11)).len); + // yazi's way in: the image goes on the alternate screen. + r.feed(0, "\x1b[3;3H" ++ apc("a=T,i=12,f=24,s=4,v=2,c=2,r=1,q=2", rgb_b64)); + try std.testing.expectEqual(@as(usize, 1), (try r.placesOf(12)).len); + try std.testing.expect(!r.hasImage(0, 11)); // per screen + r.feed(0, "\x1b[?1049l"); + try std.testing.expectEqual(@as(usize, 0), (try r.placesOf(12)).len); + try std.testing.expectEqual(@as(usize, 1), (try r.placesOf(11)).len); +} + +test "kitty: clear (ED 2 + ED 3) takes the images away, and they stay away" { + var r = try Rig.init(1); + defer r.deinit(); + r.feed(0, "\x1b[1;1H" ++ apc("a=T,i=13,f=24,s=4,v=2,c=2,r=1,q=2", rgb_b64)); + var nl: [2 * 60]u8 = undefined; + for (0..60) |i| nl[2 * i ..][0..2].* = "\r\n".*; + r.feed(0, &nl); + r.feed(0, "\x1b[H\x1b[2J\x1b[3J"); + try std.testing.expectEqual(@as(usize, 0), r.placementCount(0)); + try std.testing.expectEqual(@as(usize, 0), (try r.places()).len); + r.feed(0, "after clear\r\n"); + try std.testing.expectEqual(@as(usize, 0), (try r.places()).len); +} + +test "kitty: replies go to the pane that asked, never another, and never into the drawn cells" { + var r = try Rig.init(3); + defer r.deinit(); + r.feed(1, apc("i=51,s=1,v=1,a=q,f=24", "AAAA")); + r.feed(2, apc("i=52,s=1,v=1,a=q,f=24", "AAAA")); + r.feed(1, apc("a=t,i=53,f=24,s=4,v=2", rgb_b64)); + r.feed(2, apc("a=p,i=53", "")); + try std.testing.expectEqualStrings(reply("i=51", "OK") ++ reply("i=53", "OK"), try r.take(1)); + try std.testing.expect(std.mem.startsWith(u8, try r.take(2), reply("i=52", "OK") ++ "\x1b_Gi=53;ENOENT")); + try std.testing.expectEqualStrings("", try r.take(0)); + // Images are per pane: pane 2 never sees pane 1's. + try std.testing.expect(r.hasImage(1, 53) and !r.hasImage(2, 53)); + _ = try r.places(); + const s = &r.p.surface; + for (0..s.rows) |y| for (0..s.cols) |x| { + const g = s.at(@intCast(x), @intCast(y)).grapheme(); + try std.testing.expect(std.mem.indexOfScalar(u8, g, 0x1b) == null); + try std.testing.expect(!std.mem.eql(u8, g, "_")); + }; +} + +test "kitty: many replies from one read all arrive, each whole, in order" { + var r = try Rig.init(1); + defer r.deinit(); + var batch: std.ArrayList(u8) = .empty; + defer batch.deinit(gpa); + var want: std.ArrayList(u8) = .empty; + defer want.deinit(gpa); + for (100..164) |id| { + try batch.print(gpa, "\x1b_Gi={d},s=1,v=1,a=q,f=24;AAAA\x1b\\", .{id}); + try want.print(gpa, "\x1b_Gi={d};OK\x1b\\", .{id}); + } + r.feed(0, batch.items); + try std.testing.expectEqualStrings(want.items, try r.take(0)); +} + +test "kitty: answers past what one read may hold are dropped whole, never cut" { + var r = try Rig.init(1); + defer r.deinit(); + var batch: std.ArrayList(u8) = .empty; + defer batch.deinit(gpa); + // Each fails with a long EINVAL: far more answer than the pane holds. + for (1..1001) |id| try batch.print(gpa, "\x1b_Gi={d},s=2,v=2,a=q,f=24;AAAA\x1b\\", .{id}); + r.feed(0, batch.items); + const got = try r.take(0); + try std.testing.expect(got.len > 0); + try std.testing.expect(r.pane(0).terminal.?.reply_dropped > 0); + // Whole sequences only, each its own `ESC _ G ... ESC \`. + var rest = got; + while (rest.len > 0) { + try std.testing.expect(std.mem.startsWith(u8, rest, "\x1b_Gi=")); + const end = std.mem.indexOf(u8, rest, "\x1b\\") orelse return error.CutAnswer; + try std.testing.expect(std.mem.indexOf(u8, rest[3..end], "\x1b") == null); + rest = rest[end + 2 ..]; + } + // The next read is answered again. + r.feed(0, apc("i=31,s=1,v=1,a=q,f=24", "AAAA")); + try std.testing.expectEqualStrings(reply("i=31", "OK"), try r.take(0)); +} + +test "kitty: the graphics answer comes before DA's, as a probe expects" { + var r = try Rig.init(1); + defer r.deinit(); + // yazi, chafa and kitten icat probe this way and wait for DA to end it. + r.feed(0, apc("i=31,s=1,v=1,a=q,t=d,f=24", "AAAA") ++ "\x1b[c"); + const got = try r.take(0); + const kitty = std.mem.indexOf(u8, got, reply("i=31", "OK")) orelse return error.NoKittyReply; + const da = std.mem.indexOf(u8, got, "\x1b[?") orelse return error.NoDaReply; + try std.testing.expect(kitty < da); +} + +test "kitty: a cancelled (CAN, SUB) APC runs nothing, answers nothing, and the text goes on" { + for ([_][]const u8{ "\x18", "\x1a" }) |cancel| { + var r = try Rig.init(1); + defer r.deinit(); + r.feed(0, "\x1b_Ga=T,i=60,f=24,s=4,v=2;" ++ rgb_b64); + r.feed(0, cancel); + r.feed(0, "after"); + try std.testing.expect(!r.hasImage(0, 60)); + try std.testing.expectEqualStrings("", try r.take(0)); + const text = try terminal.screenTextAlloc(r.pane(0), r.frame.allocator()); + try std.testing.expect(std.mem.indexOf(u8, text, "after") != null); + } +} + +test "kitty: an image too large to hold is refused with an error" { + var r = try Rig.init(1); + defer r.deinit(); + // Past ghostty's 10000-pixel side. + r.feed(0, apc("a=t,i=61,f=32,s=20000,v=2,o=z", blank_256_zlib_b64)); + const got = try r.take(0); + try std.testing.expect(std.mem.startsWith(u8, got, "\x1b_Gi=61;E")); + try std.testing.expect(!r.hasImage(0, 61)); +} + +test "kitty: many images stay inside the pane's storage limit, oldest out first, and go with the pane" { + var r = try Rig.init(1); + defer r.deinit(); + const storage = r.storage(0); + var buf: [600]u8 = undefined; + // 256 KiB each: 300 of them is past the 64 MiB a screen may hold. + for (1..301) |id| r.feed(0, try std.fmt.bufPrint(&buf, "\x1b_Ga=t,i={d},f=32,s=256,v=256,o=z,q=2;{s}\x1b\\", .{ id, blank_256_zlib_b64 })); + try std.testing.expect(storage.total_bytes <= storage.total_limit); + try std.testing.expect(storage.images.count() < 300); + try std.testing.expect(r.hasImage(0, 300)); + try std.testing.expect(!r.hasImage(0, 1)); + try std.testing.expectEqualStrings("", try r.take(0)); + // The testing allocator checks the pane gives all of it back (deinit). +} + +test "kitty: an animation's frames play" { + var r = try Rig.init(1); + defer r.deinit(); + // Root frame red, frame 2 blue (a whole-frame RGB replacement), then + // run it: s=3, looping. + const blue_frame = "AAD/AAD/AAD/AAD/AAD/AAD/AAD/AAD/"; + r.feed(0, "\x1b[1;1H" ++ apc("a=T,i=70,f=24,s=4,v=2,c=2,r=1,q=2", rgb_b64) ++ + apc("a=f,i=70,f=24,s=4,v=2,z=40,q=2", blue_frame) ++ + // The root frame's gap is 0 (gapless, skipped) until it is given one. + apc("a=a,i=70,r=1,z=40,q=2", "") ++ + apc("a=a,i=70,s=3,v=1,q=2", "")); + const img = r.storage(0).imageById(70) orelse return error.NotStored; + try std.testing.expect(img.animation != null); + // On the core's clock: the first frame drawn starts it (red), the core + // asks to wake for the next, and a frame drawn after 40 ms shows blue. + const base: u64 = 10 * std.time.ns_per_s; + r.p.advance(base); + const first = try r.placesOf(70); + try std.testing.expectEqual(red, pixel(first[0], 0, 0)); + try std.testing.expect(r.p.nextWake() != null); + var shows_blue = false; + for (1..20) |k| { + r.p.advance(base + k * 50 * std.time.ns_per_ms); + const drawn = try r.placesOf(70); + if (drawn.len == 1 and std.mem.eql(u8, &pixel(drawn[0], 0, 0), &blue)) shows_blue = true; + } + try std.testing.expect(shows_blue); + // Stopped (s=1), nothing more to wake for. + r.feed(0, apc("a=a,i=70,s=1,q=2", "")); + _ = try r.places(); + try std.testing.expectEqual(@as(?u64, null), terminal.animationDueMs(r.pane(0))); +} + +test "kitty: a placement relative to another (P=, Q=) is drawn at its parent's cell plus H/V" { + var r = try Rig.init(1); + defer r.deinit(); + r.feed(0, apc("a=t,i=80,f=24,s=4,v=2,q=2", rgb_b64) ++ "\x1b[2;2H" ++ + apc("a=p,i=80,p=1,c=2,r=1,q=2", "") ++ + // Three cells right of placement 1, one row down; then one relative + // to that, a chain two deep. + apc("a=p,i=80,p=2,P=80,Q=1,H=3,V=1,c=2,r=1,q=2", "") ++ + apc("a=p,i=80,p=3,P=80,Q=2,H=3,c=2,r=1,q=2", "")); + try std.testing.expectEqual(@as(usize, 3), r.placementCount(0)); + const drawn = try r.placesOf(80); + try std.testing.expectEqual(@as(usize, 3), drawn.len); + const o = r.origin(0); + var cells: [3][2]u16 = undefined; + for (drawn, 0..) |place, i| cells[i] = .{ place.x - o.x, place.y - o.y }; + std.mem.sort([2]u16, &cells, {}, struct { + fn lt(_: void, a: [2]u16, b: [2]u16) bool { + return a[0] < b[0]; + } + }.lt); + try std.testing.expectEqual([2]u16{ 1, 1 }, cells[0]); + try std.testing.expectEqual([2]u16{ 4, 2 }, cells[1]); + try std.testing.expectEqual([2]u16{ 7, 2 }, cells[2]); + // Its parent deleted, a relative placement goes with it. + r.feed(0, apc("a=d,d=i,i=80,p=1", "")); + try std.testing.expectEqual(@as(usize, 0), (try r.placesOf(80)).len); +} -- cgit v1.3 From 30b7fd64b4b819abafd293f4ef45bf8ece3082e2 Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Wed, 28 Oct 2026 21:54:47 -0300 Subject: kitty media: a FIFO, device or huge file named by t=f, t=t or t=s no longer hangs pardes or swells it (ghostty's loader patched at build time) A program in a pane that named a FIFO (`mkfifo /tmp/f`, then t=f, t=t, or t=s through /dev/shm) hung the whole editor: ghostty's loader opens the path and only then checks that it is a regular file, and an open for reading waits for a writer. A device was opened too before being refused (an open may do something), and any image file up to ghostty's 400 MB was read and held before a screen's 64 MiB storage could refuse it. build.zig's patchGhosttyKitty patches src/terminal/kitty/graphics_image.zig with count-checked anchors, as vaxis and mvzr are: on Linux a path is probed with O_PATH (which opens nothing), must be a regular file, and that same inode is reopened through /proc/self/fd; shared memory must be a regular file (stat of /dev/shm/ first, then shm_open non-blocking and fstat); max_size is TerminalImages.storage_limit. Which paths are accepted stays ghostty's (kitty's) policy, which the user accepts. Tests: a FIFO by each medium and through a /dev/shm symlink does not block (a watchdog thread opens it for writing after 1.5 s and the test fails if it had to); /proc, /sys, devices and directories are refused; t=t leaves a tty-graphics-protocol file outside the temp directory, and one behind a /tmp symlink; a 100 MiB file is refused. Co-Authored-By: Claude Opus 5.5 --- build.zig | 75 ++++++++++++++++++++++++++++++ test/kitty.zig | 144 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 219 insertions(+) (limited to 'test/kitty.zig') diff --git a/build.zig b/build.zig index 2f1c45e1..034d7284 100644 --- a/build.zig +++ b/build.zig @@ -906,6 +906,7 @@ pub fn build(b: *std.Build) void { const ghostty_vt = dep.module("ghostty-vt"); ghostty_vt_for_snap = ghostty_vt; ghostty_vt.addImport("uucode", uucode_mod); + patchGhosttyKitty(b, io, dep, ghostty_vt); ghostty_core_vt = ghostty_vt; } // override uucode on vaxis LAST so it wins over ghostty's build() wiring. @@ -1956,6 +1957,80 @@ fn installHome(b: *std.Build, artifact: *std.Build.Step.Compile, home_bin: ?[]co /// tracked one by one, since the configure runs again on every build anyway /// (findProgram and gitCommit poison its cache). // ponytail: untracked repo reads; b.dependOnFileContents each one if the configure cache ever stays pure. +/// ghostty's kitty graphics loader (src/terminal/kitty/graphics_image.zig), +/// patched at build time so a fresh fetch keeps it, for what a program in a +/// pane may name with t=f, t=t and t=s (test/kitty.zig): +/// - a path is opened for reading only once it is known to be a regular +/// file: ghostty opens first and checks after, and the open of a FIFO +/// waits for a writer (pardes hung) while a device's open may do +/// something. On Linux an O_PATH probe looks, which opens nothing, and +/// the same inode is reopened through /proc/self/fd. +/// - shared memory is opened non-blocking and must be a regular file, so +/// a FIFO in /dev/shm (or a symlink there to one) neither hangs nor maps. +/// - an image may be no larger than a screen's storage +/// (TerminalImages.storage_limit) rather than ghostty's 400 MB, which a +/// program could make pardes read and hold before refusing it. +fn patchGhosttyKitty(b: *std.Build, io: std.Io, dep: *std.Build.Dependency, vt: *std.Build.Module) void { + const rel = "src/terminal/kitty/graphics_image.zig"; + var src = configureRead(b, io, dep.builder.root, rel, 1 << 22) catch @panic("read ghostty's graphics_image.zig"); + const edits = [_][2][]const u8{ + .{ + "const max_size = 400 * 1024 * 1024; // 400MB", + "const max_size = 64 * 1024 * 1024; // pardes (build.zig): a screen's storage, TerminalImages.storage_limit", + }, + .{ + \\ var file = std.Io.Dir.cwd().openFile( + \\ io, + \\ path, + \\ .{}, + \\ ) catch |err| { + , + \\ var file = pardesOpenRegular(io, path) catch |err| { + }, + .{ + " const fd = std.c.shm_open(pathz, @as(c_int, @bitCast(std.c.O{ .ACCMODE = .RDONLY })), @as(u16, 0));", + \\ // pardes (build.zig): a FIFO there must not hang the open, and + \\ // on Linux nothing but a regular file is opened at all. + \\ if (comptime builtin.target.os.tag == .linux) if (path.len > 0 and path[0] == '/') { + \\ var dev: [std.Io.Dir.max_path_bytes]u8 = undefined; + \\ const full = std.fmt.bufPrint(&dev, "/dev/shm{s}", .{path}) catch return error.InvalidData; + \\ const shm_stat = std.Io.Dir.cwd().statFile(io, full, .{}) catch return error.InvalidData; + \\ if (shm_stat.kind != .file) return error.InvalidData; + \\ }; + \\ const fd = std.c.shm_open(pathz, @as(c_int, @bitCast(std.c.O{ .ACCMODE = .RDONLY, .NONBLOCK = true })), @as(u16, 0)); + }, + .{ + " if (stat.size <= 0) return error.InvalidData;", + " if (stat.kind != .file) return error.InvalidData; // pardes (build.zig)\n if (stat.size <= 0) return error.InvalidData;", + }, + }; + for (edits) |edit| { + if (std.mem.count(u8, src, edit[0]) != 1) std.debug.panic("ghostty's {s} changed at `{s}`: redo its patch in build.zig", .{ rel, edit[0] }); + src = std.mem.replaceOwned(u8, b.allocator, src, edit[0], edit[1]) catch @panic("OOM"); + } + const helper = + \\ + \\/// pardes (build.zig): `path`, opened for reading only once it is known + \\/// to be a regular file. Elsewhere than Linux, ghostty's open as it was. + \\fn pardesOpenRegular(io: std.Io, path: []const u8) !std.Io.File { + \\ if (comptime builtin.target.os.tag != .linux) return std.Io.Dir.cwd().openFile(io, path, .{}); + \\ const probe = try std.Io.Dir.cwd().openFile(io, path, .{ .path_only = true }); + \\ defer probe.close(io); + \\ const stat = try probe.stat(io); + \\ if (stat.kind != .file) return error.NotRegularFile; + \\ var buf: [32]u8 = undefined; + \\ const same = std.fmt.bufPrint(&buf, "/proc/self/fd/{d}", .{probe.handle}) catch unreachable; + \\ return std.Io.Dir.cwd().openFile(io, same, .{}); + \\} + \\ + ; + const files = b.addWriteFiles(); + // The rest of src as it is; fonts are the app's, not the library's. + _ = files.addCopyDirectory(dep.path("src"), "", .{ .exclude_extensions = &.{ "graphics_image.zig", ".ttf", ".otf" } }); + _ = files.add("terminal/kitty/graphics_image.zig", b.fmt("{s}{s}", .{ src, helper })); + vt.root_source_file = files.getDirectory().path(b, "lib_vt.zig"); +} + fn configureRead(b: *std.Build, io: std.Io, root: std.Build.Cache.Path, sub: []const u8, limit: usize) ![]u8 { return root.root_dir.handle.readFileAlloc(io, b.pathJoin(&.{ root.subPathOrDot(), sub }), b.allocator, .limited(limit)); } diff --git a/test/kitty.zig b/test/kitty.zig index 3f9776fa..e760e8d6 100644 --- a/test/kitty.zig +++ b/test/kitty.zig @@ -776,3 +776,147 @@ test "kitty: a placement relative to another (P=, Q=) is drawn at its parent's c r.feed(0, apc("a=d,d=i,i=80,p=1", "")); try std.testing.expectEqual(@as(usize, 0), (try r.placesOf(80)).len); } + +// ---- What t=f, t=t and t=s may make pardes open ---- +// +// A program in a pane names paths on pardes's machine. Which paths ghostty's +// loader accepts is its policy (kitty's, which the user accepts); what pardes +// owns is that none of them hangs or crashes it or blows its memory: a FIFO +// (an open for reading waits for a writer), a device (an open may do +// something), a file no screen could hold. And t=t deletes temporary files +// only. + +extern "c" fn mkfifo(path: [*:0]const u8, mode: std.c.mode_t) c_int; +extern "c" fn symlink(target: [*:0]const u8, link: [*:0]const u8) c_int; +extern "c" fn usleep(us: c_uint) c_int; +extern "c" fn ftruncate(fd: c_int, len: i64) c_int; +extern "c" fn getcwd(buf: [*]u8, size: usize) ?[*:0]u8; + +const Guard = struct { + path: [:0]const u8, + done: std.atomic.Value(bool) = .init(false), + blocked: std.atomic.Value(bool) = .init(false), + + /// After 1.5 s still running, the feed is stuck in an open of the FIFO: + /// open it for writing, which lets that open return. + fn run(g: *Guard) void { + for (0..150) |_| { + if (g.done.load(.acquire)) return; + _ = usleep(10_000); + } + g.blocked.store(true, .release); + const fd = std.c.open(g.path, .{ .ACCMODE = .WRONLY }, @as(std.c.mode_t, 0)); + if (fd >= 0) _ = std.c.close(fd); + } +}; + +/// Feeds `bytes`; whether the feed blocked opening `fifo`. +fn feedBlocks(r: *Rig, bytes: []const u8, fifo: [:0]const u8) !bool { + var g: Guard = .{ .path = fifo }; + const t = try std.Thread.spawn(.{}, Guard.run, .{&g}); + r.feed(0, bytes); + g.done.store(true, .release); + t.join(); + return g.blocked.load(.acquire); +} + +test "kitty: a FIFO named by t=f, t=t or t=s never blocks pardes" { + var r = try Rig.init(1); + defer r.deinit(); + const arena = r.frame.allocator(); + const pid = std.c.getpid(); + const Case = struct { medium: u8, fifo: [:0]const u8, name: []const u8 }; + const file = try std.fmt.allocPrintSentinel(arena, "/tmp/pardes-kitty-{d}-fifo", .{pid}, 0); + const temp = try std.fmt.allocPrintSentinel(arena, "/tmp/tty-graphics-protocol-pardes-{d}-fifo", .{pid}, 0); + const shm_path = try std.fmt.allocPrintSentinel(arena, "/dev/shm/pardes-kitty-{d}-fifo", .{pid}, 0); + const cases = [_]Case{ + .{ .medium = 'f', .fifo = file, .name = file }, + .{ .medium = 't', .fifo = temp, .name = temp }, + .{ .medium = 's', .fifo = shm_path, .name = shm_path["/dev/shm".len..] }, + }; + for (cases) |c| { + _ = std.c.unlink(c.fifo); + if (mkfifo(c.fifo, 0o600) != 0) return error.MkfifoFailed; + defer _ = std.c.unlink(c.fifo); + const cmd = try std.fmt.allocPrint(arena, "\x1b_Ga=t,t={c},i=90,f=24,s=1,v=1;{s}\x1b\\", .{ c.medium, try b64(arena, c.name) }); + const blocked = try feedBlocks(&r, cmd, c.fifo); + if (blocked) std.debug.print("t={c}: pardes blocked opening the FIFO {s}\n", .{ c.medium, c.fifo }); + try std.testing.expect(!blocked); + try std.testing.expect(std.mem.startsWith(u8, try r.take(0), "\x1b_Gi=90;E")); + try std.testing.expect(!r.hasImage(0, 90)); + } +} + +test "kitty: t=s through a /dev/shm symlink to a FIFO does not block pardes either" { + var r = try Rig.init(1); + defer r.deinit(); + const arena = r.frame.allocator(); + const pid = std.c.getpid(); + const fifo = try std.fmt.allocPrintSentinel(arena, "/tmp/pardes-kitty-{d}-shmfifo", .{pid}, 0); + _ = std.c.unlink(fifo); + if (mkfifo(fifo, 0o600) != 0) return error.MkfifoFailed; + defer _ = std.c.unlink(fifo); + const link = try std.fmt.allocPrintSentinel(arena, "/dev/shm/pardes-kitty-{d}-link", .{pid}, 0); + _ = std.c.unlink(link); + if (symlink(fifo, link) != 0) return error.SymlinkFailed; + defer _ = std.c.unlink(link); + const cmd = try std.fmt.allocPrint(arena, "\x1b_Ga=t,t=s,i=91,f=24,s=1,v=1;{s}\x1b\\", .{try b64(arena, link["/dev/shm".len..])}); + try std.testing.expect(!try feedBlocks(&r, cmd, fifo)); + try std.testing.expect(std.mem.startsWith(u8, try r.take(0), "\x1b_Gi=91;E")); +} + +test "kitty: t=f and t=t refuse /proc, /sys, devices and directories" { + var r = try Rig.init(1); + defer r.deinit(); + const arena = r.frame.allocator(); + const refused = [_][]const u8{ "/proc/self/status", "/sys/devices/system/cpu/online", "/dev/null", "/dev/zero", "/dev/urandom", "/tmp", "/" }; + for ([_]u8{ 'f', 't' }) |medium| for (refused) |path| { + // A raw 1x1 pixel needs 3 bytes (S=3): any readable file would do. + r.feed(0, try std.fmt.allocPrint(arena, "\x1b_Ga=t,t={c},i=92,f=24,s=1,v=1,S=3;{s}\x1b\\", .{ medium, try b64(arena, path) })); + try std.testing.expect(std.mem.startsWith(u8, try r.take(0), "\x1b_Gi=92;E")); + try std.testing.expect(!r.hasImage(0, 92)); + }; +} + +test "kitty: t=t deletes only a temporary file: one outside the temp directory, or behind a symlink, stays" { + var r = try Rig.init(1); + defer r.deinit(); + const arena = r.frame.allocator(); + const pid = std.c.getpid(); + var cwd_buf: [4096]u8 = undefined; + const cwd = std.mem.span(getcwd(&cwd_buf, cwd_buf.len) orelse return error.NoCwd); + // Outside /tmp, /dev/shm and $TMPDIR: the build's own cache. + const dir = try std.fmt.allocPrintSentinel(arena, "{s}/.zig-cache/tmp/pardes-kitty-{d}", .{ cwd, pid }, 0); + _ = std.c.mkdir(dir, 0o700); + defer _ = std.c.rmdir(dir); + const kept = try std.fmt.allocPrintSentinel(arena, "{s}/tty-graphics-protocol-kept.rgb", .{dir}, 0); + try writeTemp(kept, &rgb_raw); + defer _ = std.c.unlink(kept); + const link = try std.fmt.allocPrintSentinel(arena, "/tmp/tty-graphics-protocol-pardes-{d}-link", .{pid}, 0); + _ = std.c.unlink(link); + if (symlink(kept, link) != 0) return error.SymlinkFailed; + defer _ = std.c.unlink(link); + for ([_][:0]const u8{ kept, link }) |path| { + r.feed(0, try std.fmt.allocPrint(arena, "\x1b_Ga=t,t=t,i=93,f=24,s=4,v=2;{s}\x1b\\", .{try b64(arena, path)})); + try std.testing.expect(std.mem.startsWith(u8, try r.take(0), "\x1b_Gi=93;E")); + try std.testing.expect(!r.hasImage(0, 93)); + try std.testing.expect(exists(kept)); + } +} + +test "kitty: a file bigger than a screen may hold is refused, not read whole" { + var r = try Rig.init(1); + defer r.deinit(); + const arena = r.frame.allocator(); + // 100 MiB, sparse: 5120x5120 RGBA, past the 64 MiB a screen holds. + const big = try std.fmt.allocPrintSentinel(arena, "/tmp/pardes-kitty-{d}-big.rgba", .{std.c.getpid()}, 0); + const fd = std.c.open(big, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true }, @as(std.c.mode_t, 0o600)); + if (fd < 0) return error.OpenFailed; + _ = ftruncate(fd, 5120 * 5120 * 4); + _ = std.c.close(fd); + defer _ = std.c.unlink(big); + r.feed(0, try std.fmt.allocPrint(arena, "\x1b_Ga=t,t=f,i=94,f=32,s=5120,v=5120;{s}\x1b\\", .{try b64(arena, big)})); + const got = try r.take(0); + try std.testing.expect(std.mem.startsWith(u8, got, "\x1b_Gi=94;E")); + try std.testing.expect(!r.hasImage(0, 94)); +} -- cgit v1.3 From 2e237ef20b6a5d9f680d80a560d144c0f67dff91 Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Wed, 28 Oct 2026 21:54:47 -0300 Subject: kitty fuzz: seeded random kitty traffic through a terminal pane (test/kitty.zig), in kitty-test and unit-test Commands with any action, keys and values (huge, negative, zero, junk), payloads valid and broken (base64, a cut PNG), CAN, SUB and ESC mid-command, half of them loads and placements with random geometry so they reach the storage and the frame; placeholders with every diacritic, 24-bit and 256-colour ids and underline-colour placements; cursor moves, scroll regions, insert/delete lines, ED 2/3, the alternate screen; window and cell-size resizes and grid resizes; frames between; every batch split into reads anywhere. Each seed checks no crash, no leak (the testing allocator) and that every answer parses as a whole ESC _ G ... ESC \ or CSI. A bad answer shrinks to its shortest failing prefix; PARDES_KITTY_FUZZ=, PARDES_KITTY_FUZZ_SEED and PARDES_KITTY_FUZZ_STEPS for long runs and replays. Found nothing: 900 seeds of 400 steps pass, with frames drawing up to 42 places. Co-Authored-By: Claude Opus 5.5 --- test/kitty.zig | 214 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 214 insertions(+) (limited to 'test/kitty.zig') diff --git a/test/kitty.zig b/test/kitty.zig index e760e8d6..a100e7a6 100644 --- a/test/kitty.zig +++ b/test/kitty.zig @@ -920,3 +920,217 @@ test "kitty: a file bigger than a screen may hold is refused, not read whole" { try std.testing.expect(std.mem.startsWith(u8, got, "\x1b_Gi=94;E")); try std.testing.expect(!r.hasImage(0, 94)); } + +// ---- Fuzz ---- +// +// Seeded random kitty traffic, the way a confused or hostile program sends +// it: commands with any keys and values, payloads valid and broken, CAN and +// SUB mid-command, placeholders with any diacritics, cursor moves, ED 2/3, +// the alternate screen, window and cell-size resizes and frames between, +// split into reads anywhere. Each seed checks that pardes neither crashes +// nor leaks (the testing allocator) and that every answer parses. +// +// PARDES_KITTY_FUZZ= more seeds (default 24) +// PARDES_KITTY_FUZZ_SEED= one seed, printing each step +// PARDES_KITTY_FUZZ_STEPS= steps per seed (default 400) +// +// A crash prints `seed S step N`: rerun that seed with fewer steps to +// shrink it. A bad answer shrinks itself to the shortest failing prefix. + +fn envNumber(name: [*:0]const u8, default: u64) u64 { + const v = std.c.getenv(name) orelse return default; + return std.fmt.parseInt(u64, std.mem.span(v), 10) catch default; +} + +const fuzz_keys = "aiIpfsvxywhcrXYzCUPQHVmoqtSOd"; +const fuzz_actions = "tTpdqfac"; +const fuzz_deletes = "aAiInNcCpPqQxXyYzZrRfF"; + +fn fuzzValue(rng: std.Random, out: *std.ArrayList(u8), arena: std.mem.Allocator) !void { + switch (rng.uintLessThan(u8, 10)) { + 0 => try out.appendSlice(arena, "0"), + 1 => try out.print(arena, "{d}", .{rng.int(u32)}), + 2 => try out.print(arena, "-{d}", .{rng.uintLessThan(u32, 1 << 31)}), + 3 => try out.appendSlice(arena, "4294967295"), + 4 => try out.appendSlice(arena, "99999999999999999999"), + 5 => try out.appendSlice(arena, "x"), + else => try out.print(arena, "{d}", .{rng.uintLessThan(u32, 12)}), + } +} + +/// A command that loads, or places what is loaded, with any geometry: it +/// gets past the parser to the storage and the drawing. +fn fuzzPlacement(rng: std.Random, arena: std.mem.Allocator) ![]const u8 { + var out: std.ArrayList(u8) = .empty; + const id = 1 + rng.uintLessThan(u32, 4); + switch (rng.uintLessThan(u8, 3)) { + 0 => try out.print(arena, "\x1b_Ga=T,f=24,s=4,v=2,i={d},q=2", .{id}), + 1 => try out.print(arena, "\x1b_Ga=p,i={d},q=2", .{id}), + else => try out.print(arena, "\x1b_Ga=T,f=100,i={d},q=2", .{id}), + } + const keys = "crxywhXYzCUpPQHV"; + for (0..rng.uintLessThan(usize, 6)) |_| { + try out.print(arena, ",{c}=", .{keys[rng.uintLessThan(usize, keys.len)]}); + try fuzzValue(rng, &out, arena); + } + try out.append(arena, ';'); + if (std.mem.startsWith(u8, out.items, "\x1b_Ga=T,f=24")) try out.appendSlice(arena, rgb_b64); + if (std.mem.startsWith(u8, out.items, "\x1b_Ga=T,f=100")) try out.appendSlice(arena, png_b64); + try out.appendSlice(arena, "\x1b\\"); + return out.items; +} + +fn fuzzCommand(rng: std.Random, arena: std.mem.Allocator) ![]const u8 { + if (rng.boolean()) return fuzzPlacement(rng, arena); + var out: std.ArrayList(u8) = .empty; + try out.appendSlice(arena, "\x1b_G"); + const action = fuzz_actions[rng.uintLessThan(usize, fuzz_actions.len)]; + try out.print(arena, "a={c}", .{action}); + if (action == 'd') try out.print(arena, ",d={c}", .{fuzz_deletes[rng.uintLessThan(usize, fuzz_deletes.len)]}); + for (0..rng.uintLessThan(usize, 7)) |_| { + const key = fuzz_keys[rng.uintLessThan(usize, fuzz_keys.len)]; + try out.print(arena, ",{c}=", .{key}); + switch (key) { + 'f' => try out.appendSlice(arena, ([_][]const u8{ "24", "32", "100", "7" })[rng.uintLessThan(usize, 4)]), + 't' => try out.appendSlice(arena, ([_][]const u8{ "d", "f", "t", "s", "q" })[rng.uintLessThan(usize, 5)]), + 'o' => try out.appendSlice(arena, if (rng.boolean()) "z" else "y"), + else => try fuzzValue(rng, &out, arena), + } + } + // Mostly the small ids the rest reuse, so commands meet each other. + if (rng.uintLessThan(u8, 4) != 0) try out.print(arena, ",i={d}", .{1 + rng.uintLessThan(u32, 4)}); + if (rng.boolean()) try out.print(arena, ",s={d},v={d}", .{ rng.uintLessThan(u32, 6), rng.uintLessThan(u32, 6) }); + try out.append(arena, ';'); + switch (rng.uintLessThan(u8, 8)) { + 0 => try out.appendSlice(arena, rgb_b64), + 1 => try out.appendSlice(arena, rgba_b64), + 2 => try out.appendSlice(arena, png_b64), + 3 => try out.appendSlice(arena, rgb_zlib_b64), + 4 => {}, // nothing + 5 => { + // base64, broken: random characters, wrong padding. + for (0..rng.uintLessThan(usize, 40)) |_| try out.append(arena, "AB/+=x!Z09"[rng.uintLessThan(usize, 10)]); + }, + 6 => try out.appendSlice(arena, png_b64[0..rng.uintLessThan(usize, png_b64.len)]), + else => try out.appendSlice(arena, "AAAA"), + } + switch (rng.uintLessThan(u8, 12)) { + 0 => try out.append(arena, 0x18), // CAN + 1 => try out.append(arena, 0x1a), // SUB + 2 => try out.appendSlice(arena, "\x1b[m"), // ESC aborting it + else => try out.appendSlice(arena, "\x1b\\"), + } + return out.items; +} + +fn fuzzOutput(rng: std.Random, arena: std.mem.Allocator) ![]const u8 { + return switch (rng.uintLessThan(u8, 9)) { + 0 => try std.fmt.allocPrint(arena, "\x1b[{d};{d}H", .{ 1 + rng.uintLessThan(u32, 50), 1 + rng.uintLessThan(u32, 150) }), + 1 => "line\r\n", + 2 => "\x1b[H\x1b[2J\x1b[3J", + 3 => if (rng.boolean()) "\x1b[?1049h" else "\x1b[?1049l", + 4 => blk: { + // Placeholders: an image id in the colour (24-bit or 256), any + // diacritics, up to three per cell. + var out: std.ArrayList(u8) = .empty; + if (rng.boolean()) + try out.print(arena, "\x1b[38;2;{d};{d};{d}m", .{ rng.int(u8), rng.int(u8), rng.uintLessThan(u8, 5) }) + else + try out.print(arena, "\x1b[38;5;{d}m", .{rng.uintLessThan(u8, 5)}); + if (rng.boolean()) try out.print(arena, "\x1b[58;5;{d}m", .{rng.uintLessThan(u8, 4)}); + for (0..1 + rng.uintLessThan(usize, 6)) |_| { + try out.appendSlice(arena, "\u{10EEEE}"); + const marks = [_][]const u8{ "\u{0305}", "\u{030D}", "\u{030E}", "\u{0310}", "\u{0312}", "\u{033D}", "\u{0346}", "\u{1D242}" }; + for (0..rng.uintLessThan(usize, 4)) |_| try out.appendSlice(arena, marks[rng.uintLessThan(usize, marks.len)]); + } + try out.appendSlice(arena, "\x1b[39;59m"); + break :blk out.items; + }, + 5 => "\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n", + 6 => "\x1b[2;8r\x1b[S\x1b[T\x1b[r", + 7 => "\x1b[3L\x1b[2M\x1b[4@\x1b[2P", + else => "text", + }; +} + +/// Every answer whole: kitty's `ESC _ G ... ESC \`, or a CSI. +fn answersParse(got: []const u8) bool { + var rest = got; + while (rest.len > 0) { + if (std.mem.startsWith(u8, rest, "\x1b_G")) { + const end = std.mem.indexOf(u8, rest, "\x1b\\") orelse return false; + if (std.mem.indexOfScalar(u8, rest[3..end], 0x1b) != null) return false; + rest = rest[end + 2 ..]; + } else if (std.mem.startsWith(u8, rest, "\x1b[")) { + var i: usize = 2; + while (i < rest.len and !(rest[i] >= 0x40 and rest[i] <= 0x7e)) i += 1; + if (i == rest.len) return false; + rest = rest[i + 1 ..]; + } else return false; + } + return true; +} + +/// One seed's run, `steps` long; false on a bad answer. +fn fuzzRun(seed: u64, steps: usize, trace: bool) !bool { + var prng: std.Random.DefaultPrng = .init(seed); + const rng = prng.random(); + var r = try Rig.init(1); + defer r.deinit(); + var arena_state: std.heap.ArenaAllocator = .init(gpa); + defer arena_state.deinit(); + for (0..steps) |step| { + _ = arena_state.reset(.retain_capacity); + const arena = arena_state.allocator(); + if (trace) std.debug.print("seed {d} step {d}\n", .{ seed, step }); + switch (rng.uintLessThan(u8, 20)) { + 0 => { + const cols = 20 + rng.uintLessThan(u16, 140); + const rows = 6 + rng.uintLessThan(u16, 50); + r.p.update(.{ .resize = .{ .cols = cols, .rows = rows, .cell_pixels = .{ .w = 1 + rng.uintLessThan(u16, 30), .h = 1 + rng.uintLessThan(u16, 60) } } }); + r.drain(); + }, + 1 => terminal.resizeGrid(r.pane(0), gpa, 1 + rng.uintLessThan(u16, 120), 1 + rng.uintLessThan(u16, 40)), + 2, 3 => { + const drawn = try r.places(); + if (trace) std.debug.print(" {d} places, {d} placements, {d} images\n", .{ drawn.len, r.placementCount(0), r.storage(0).images.count() }); + }, + 4, 5, 6, 7 => r.feedSplit(0, try fuzzOutput(rng, arena), 1 + rng.uintLessThan(usize, 64)), + else => { + var batch: std.ArrayList(u8) = .empty; + for (0..1 + rng.uintLessThan(usize, 4)) |_| try batch.appendSlice(arena, try fuzzCommand(rng, arena)); + r.feedSplit(0, batch.items, 1 + rng.uintLessThan(usize, 200)); + }, + } + const got = try r.take(0); + if (!answersParse(got)) { + if (trace) std.debug.print("seed {d} step {d}: unparsable answer {f}\n", .{ seed, step, std.ascii.hexEscape(got, .lower) }); + return false; + } + } + _ = try r.places(); + return true; +} + +test "kitty: fuzzed traffic neither crashes nor leaks, and every answer parses" { + const steps: usize = @intCast(envNumber("PARDES_KITTY_FUZZ_STEPS", 400)); + if (std.c.getenv("PARDES_KITTY_FUZZ_SEED")) |one| { + const seed = try std.fmt.parseInt(u64, std.mem.span(one), 10); + try std.testing.expect(try fuzzRun(seed, steps, true)); + return; + } + const seeds = envNumber("PARDES_KITTY_FUZZ", 24); + for (0..seeds) |seed| { + if (try fuzzRun(seed, steps, false)) continue; + // Shrink to the shortest failing prefix. + var lo: usize = 1; + var hi: usize = steps; + while (lo < hi) { + const mid = lo + (hi - lo) / 2; + if (try fuzzRun(seed, mid, false)) lo = mid + 1 else hi = mid; + } + std.debug.print("kitty fuzz: seed {d} fails in {d} steps; PARDES_KITTY_FUZZ_SEED={d} PARDES_KITTY_FUZZ_STEPS={d} traces it\n", .{ seed, lo, seed, lo }); + return error.FuzzFailed; + } + if (seeds != 24) std.debug.print("kitty fuzz: {d} seeds of {d} steps ok\n", .{ seeds, steps }); +} -- cgit v1.3 From caffd9c1f8742a17431f7de0a2824d3fc02bfd72 Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Wed, 28 Oct 2026 21:59:19 -0300 Subject: kitty z-index: a terminal image's z= goes with it, images go to the shell lowest first, and the tty hands z on to the outer terminal (under the text below 0); real clients recorded, replayed and run live z-index was lost: an ImagePlace had none, so every image went over the cells in hash-map order, a z<0 picture (a background under text) over the text and overlapping images in any order. ImagePlace.z now carries the placement's z (a virtual placement's from its placeholder target), TerminalImages sorts what it appends lowest z first (stable), and the tty's exactKittyPlacement sets vaxis's z_index, so a kitty terminal outside stacks them and puts z<0 under the text. The GUI draws them in that order but still over the cells: under the text there needs a glyph pass after the images (ui.frag's clear_bg_bit) in gui.zig's vertex buffer. Real clients: test/kitty_harness.zig's PARDES_KITTY_EXPLORE runs commands in the pane under script(1) and prints what pardes placed outside; kitten icat 0.49.2 (--align left/center/right, --place, --scale-up, --unicode-placeholder, --clear, file/memory/stream/detect), chafa 1.18.3, viu and yazi 26.9.1 all landed where they should. Their recorded traffic (test/kitty-fixtures/*.vt) replays through the core (test/kitty.zig) to the cells they drew live. The harness now also runs yazi live (shared memory, a virtual placement, placeholders), checks z=-1 outside, and runs a second pardes under a terminal without kitty graphics: no graphics command reaches it and the image is glyph art in all 32 cells. The harness empties NO_COLOR (zig build sets it, and vaxis drew no colour at all under the harness) by setenv, not unsetenv, which compacts the environment std captured. Also: tests that a pane's image follows pardes's own scrollback, an edited copy taller than its rows, a narrow pane's edge, Collapse and a cell-size change; and a knownGap: images do not survive a dump (Dump, Handover, a pane reopened from the Store), whose VT text has none. Co-Authored-By: Claude Opus 5.5 --- src/TerminalImages.zig | 15 ++- src/surface.zig | 6 + src/tty/tty.zig | 2 + test/kitty-fixtures/chafa.vt | 2 + test/kitty-fixtures/icat-center.vt | 1 + test/kitty-fixtures/icat-clear.vt | 1 + test/kitty-fixtures/icat-left.vt | 1 + test/kitty-fixtures/icat-place.vt | 1 + test/kitty-fixtures/icat-placeholder.vt | 4 + test/kitty-fixtures/icat-right.vt | 1 + test/kitty.zig | 225 +++++++++++++++++++++++++++++++- test/kitty_client.zig | 3 + test/kitty_harness.zig | 116 ++++++++++++++++ 13 files changed, 369 insertions(+), 9 deletions(-) create mode 100644 test/kitty-fixtures/chafa.vt create mode 100644 test/kitty-fixtures/icat-center.vt create mode 100644 test/kitty-fixtures/icat-clear.vt create mode 100644 test/kitty-fixtures/icat-left.vt create mode 100644 test/kitty-fixtures/icat-place.vt create mode 100644 test/kitty-fixtures/icat-placeholder.vt create mode 100644 test/kitty-fixtures/icat-right.vt (limited to 'test/kitty.zig') diff --git a/src/TerminalImages.zig b/src/TerminalImages.zig index f3333460..f26b5852 100644 --- a/src/TerminalImages.zig +++ b/src/TerminalImages.zig @@ -162,6 +162,14 @@ pub fn draw( const ch: u32 = @max(1, p.cell_pixels.h); const pixels = p.native_images and !ti.petscii; const ctx: Ctx = .{ .ti = ti, .p = p, .s = s, .pane = pane_id, .serial = serial, .tx = tx, .body_y = body_y, .cols = cols, .rows_of = rows_of, .cw = cw, .ch = ch, .pixels = pixels }; + // Handed on lowest z first (the storage's order is a hash map's), the + // order a shell draws them in; equal z keeps the order they came in. + const first = s.nimages; + defer std.sort.insertion(?pardes.ImagePlace, s.images[first..s.nimages], {}, struct { + fn lessThan(_: void, a: ?pardes.ImagePlace, b: ?pardes.ImagePlace) bool { + return (if (a) |x| x.z else 0) < (if (b) |y| y.z else 0); + } + }.lessThan); // Virtual placements: shown through the placeholder cells, one run of // them on a row at a time. The placeholders themselves are not text. @@ -181,7 +189,7 @@ pub fn draw( const target = storage.placeholderTarget(run.image_id, run.placement_id) orelse continue; const rp = run.renderPlacement(&target.placement, &img, cw, ch) catch continue; if (rp.dest_width == 0 or rp.dest_height == 0 or rp.source_width == 0 or rp.source_height == 0) continue; - ctx.place(img, .{ .x = rp.source_x, .y = rp.source_y, .w = rp.source_width, .h = rp.source_height }, .{ + ctx.place(img, target.placement.z, .{ .x = rp.source_x, .y = rp.source_y, .w = rp.source_width, .h = rp.source_height }, .{ .x = @as(i64, at.viewport.x) * cw + rp.offset_x, .y = @as(i64, v) * ch + rp.offset_y, .w = rp.dest_width, @@ -223,7 +231,7 @@ pub fn draw( const sw = if (placed.source_width > 0) @min(placed.source_width, img.width - sx) else img.width - sx; const sh = if (placed.source_height > 0) @min(placed.source_height, img.height - sy) else img.height - sy; if (size.width == 0 or size.height == 0 or sw == 0 or sh == 0) continue; - ctx.place(img, .{ .x = sx, .y = sy, .w = sw, .h = sh }, .{ + ctx.place(img, placed.z, .{ .x = sx, .y = sy, .w = sw, .h = sh }, .{ .x = (@as(i64, at.screen.x) + dx) * cw + placed.x_offset, .y = (@as(i64, at.screen.y) - @as(i64, origin.screen.y) + dy) * ch + placed.y_offset, .w = size.width, @@ -248,7 +256,7 @@ const Ctx = struct { /// Draw `src` of `img` over `dst`, one cell row of it at a time: a row /// is shown, or not, or shown elsewhere, as the body lays it out. - fn place(ctx: Ctx, img: gfx.Image, src: PixelRect, dst: Rect) void { + fn place(ctx: Ctx, img: gfx.Image, z: i32, src: PixelRect, dst: Rect) void { const cw: i64 = ctx.cw; const ch: i64 = ctx.ch; const x0 = @max(dst.x, 0); @@ -294,6 +302,7 @@ const Ctx = struct { .rgba = rgba, .iw = img.width, .ih = img.height, + .z = z, }); continue; } diff --git a/src/surface.zig b/src/surface.zig index 8ed4074c..aa0068e3 100644 --- a/src/surface.zig +++ b/src/surface.zig @@ -257,6 +257,12 @@ pub const ImagePlace = struct { rgba: []const u8, iw: usize, ih: usize, + /// A terminal's kitty graphics stacking order (`z=`): the surface lists + /// a pane's images lowest first, so a shell drawing them in order puts + /// a higher one over a lower; below 0 the program means it under the + /// text, which the tty passes on to the outer terminal (the GUI draws + /// every image over the cells still). 0 for every other image. + z: i32 = 0, /// Rows [y, y+h) of `rgba` are the only ones that differ from the /// same pane page at revision `from`: a shell still holding that one may /// update just these rows instead of taking the whole image again. diff --git a/src/tty/tty.zig b/src/tty/tty.zig index 5ad02c28..a358051e 100644 --- a/src/tty/tty.zig +++ b/src/tty/tty.zig @@ -847,6 +847,8 @@ fn exactKittyPlacement( .height = std.math.cast(u16, src_h) orelse return null, }, .pixel_offset = if (pixel_x != 0 or pixel_y != 0) .{ .x = @intCast(pixel_x), .y = @intCast(pixel_y) } else null, + // The outer terminal stacks them, under the text below 0. + .z_index = if (place.z != 0) place.z else null, .size = if (full) .{ .cols = std.math.cast(u16, cols) orelse return null, .rows = 1 } else diff --git a/test/kitty-fixtures/chafa.vt b/test/kitty-fixtures/chafa.vt new file mode 100644 index 00000000..5a882361 --- /dev/null +++ b/test/kitty-fixtures/chafa.vt @@ -0,0 +1,2 @@ +]10;?\]11;?\[?25l_Ga=T,f=32,s=64,v=64,c=8,r=4,m=1,q=2\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N\_Gm=1;5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/\_Gm=1;DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w1N5/8NTef/DU3n/w==\_Gm=0\ +[?25h \ No newline at end of file diff --git a/test/kitty-fixtures/icat-center.vt b/test/kitty-fixtures/icat-center.vt new file mode 100644 index 00000000..de47d4cd --- /dev/null +++ b/test/kitty-fixtures/icat-center.vt @@ -0,0 +1 @@ +[?s[*x[?1l[?5l[?2004l[?1000l[?1002l[?1003l[?1005l[?1006l[?8h[?7h[?25h_Ga=q,f=24,s=1,v=1,S=3,i=1;MTIz\_Ga=q,f=24,t=t,s=1,v=1,S=47,i=2;L2Rldi9zaG0va2l0dHktdHR5LWdyYXBoaWNzLXByb3RvY29sLTIyMDEyODU0MjQ\_Ga=q,f=24,t=s,s=1,v=1,S=19,i=3;L2ljYXQtRVRKSEZYWEpPVkxBUw\7[?r8 _Ga=T,q=2,f=100,s=64,v=64;iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAIAAAAlC+aJAAAwS0lEQVR4AQFAML/PAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5+0wES1gqxrAAAAAAElFTkSuQmCC\ diff --git a/test/kitty-fixtures/icat-clear.vt b/test/kitty-fixtures/icat-clear.vt new file mode 100644 index 00000000..ba7cd735 --- /dev/null +++ b/test/kitty-fixtures/icat-clear.vt @@ -0,0 +1 @@ +_Ga=d,d=A\_Ga=d,d=A\[?s[*x[?1l[?5l[?2004l[?1000l[?1002l[?1003l[?1005l[?1006l[?8h[?7h[?25h_Ga=q,f=24,s=1,v=1,S=3,i=1;MTIz\_Ga=q,f=24,t=t,s=1,v=1,S=47,i=2;L2Rldi9zaG0va2l0dHktdHR5LWdyYXBoaWNzLXByb3RvY29sLTM0Mjk2MDk4NzM\_Ga=q,f=24,t=s,s=1,v=1,S=19,i=3;L2ljYXQtM1ozWTZQSVpSTVpDRQ\7[?r8 \ No newline at end of file diff --git a/test/kitty-fixtures/icat-left.vt b/test/kitty-fixtures/icat-left.vt new file mode 100644 index 00000000..4c913e2f --- /dev/null +++ b/test/kitty-fixtures/icat-left.vt @@ -0,0 +1 @@ +[?s[*x[?1l[?5l[?2004l[?1000l[?1002l[?1003l[?1005l[?1006l[?8h[?7h[?25h_Ga=q,f=24,s=1,v=1,S=3,i=1;MTIz\_Ga=q,f=24,t=t,s=1,v=1,S=47,i=2;L2Rldi9zaG0va2l0dHktdHR5LWdyYXBoaWNzLXByb3RvY29sLTM4MDU5NTM1ODk\_Ga=q,f=24,t=s,s=1,v=1,S=19,i=3;L2ljYXQtU083U0NPSk1FUFpKNg\7[?r8 _Ga=T,q=2,f=100,s=64,v=64;iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAIAAAAlC+aJAAAwS0lEQVR4AQFAML/PAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5+0wES1gqxrAAAAAAElFTkSuQmCC\ diff --git a/test/kitty-fixtures/icat-place.vt b/test/kitty-fixtures/icat-place.vt new file mode 100644 index 00000000..3f59865f --- /dev/null +++ b/test/kitty-fixtures/icat-place.vt @@ -0,0 +1 @@ +[?s[*x[?1l[?5l[?2004l[?1000l[?1002l[?1003l[?1005l[?1006l[?8h[?7h[?25h_Ga=q,f=24,s=1,v=1,S=3,i=1;MTIz\_Ga=q,f=24,t=t,s=1,v=1,S=47,i=2;L2Rldi9zaG0va2l0dHktdHR5LWdyYXBoaWNzLXByb3RvY29sLTM5ODY5NDMyNTM\_Ga=q,f=24,t=s,s=1,v=1,S=19,i=3;L2ljYXQtVkVPN0VHWFpTVzdMVw\7[?r8 _Ga=T,q=2,f=100,C=1,s=64,v=64;iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAIAAAAlC+aJAAAwS0lEQVR4AQFAML/PAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5+0wES1gqxrAAAAAAElFTkSuQmCC\ \ No newline at end of file diff --git a/test/kitty-fixtures/icat-placeholder.vt b/test/kitty-fixtures/icat-placeholder.vt new file mode 100644 index 00000000..87692a51 --- /dev/null +++ b/test/kitty-fixtures/icat-placeholder.vt @@ -0,0 +1,4 @@ +[?s[*x[?1l[?5l[?2004l[?1000l[?1002l[?1003l[?1005l[?1006l[?8h[?7h[?25h_Ga=q,f=24,s=1,v=1,S=3,i=1;MTIz\_Ga=q,f=24,t=t,s=1,v=1,S=47,i=2;L2Rldi9zaG0va2l0dHktdHR5LWdyYXBoaWNzLXByb3RvY29sLTM0Mzc4NzgyNzA\_Ga=q,f=24,t=s,s=1,v=1,S=19,i=3;L2ljYXQtNVNMTlg2UjQ3VFBOSw\7[?r8 _Ga=T,q=2,f=100,U=1,s=64,v=64,c=8,r=4,i=159064709;iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAIAAAAlC+aJAAAwS0lEQVR4AQFAML/PAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5+0wES1gqxrAAAAAAElFTkSuQmCC\[38:2:123:34:133m􎻮̅̅͊􎻮̅̍͊􎻮̅̎͊􎻮̅̐͊􎻮̅̒͊􎻮̅̽͊􎻮̅̾͊􎻮̅̿͊ + 􎻮̍̅͊􎻮̍̍͊􎻮̍̎͊􎻮̍̐͊􎻮̍̒͊􎻮̍̽͊􎻮̍̾͊􎻮̍̿͊ + 􎻮̎̅͊􎻮̎̍͊􎻮̎̎͊􎻮̎̐͊􎻮̎̒͊􎻮̎̽͊􎻮̎̾͊􎻮̎̿͊ + 􎻮̐̅͊􎻮̐̍͊􎻮̐̎͊􎻮̐̐͊􎻮̐̒͊􎻮̐̽͊􎻮̐̾͊􎻮̐̿͊ diff --git a/test/kitty-fixtures/icat-right.vt b/test/kitty-fixtures/icat-right.vt new file mode 100644 index 00000000..d1470d7f --- /dev/null +++ b/test/kitty-fixtures/icat-right.vt @@ -0,0 +1 @@ +[?s[*x[?1l[?5l[?2004l[?1000l[?1002l[?1003l[?1005l[?1006l[?8h[?7h[?25h_Ga=q,f=24,s=1,v=1,S=3,i=1;MTIz\_Ga=q,f=24,t=t,s=1,v=1,S=47,i=2;L2Rldi9zaG0va2l0dHktdHR5LWdyYXBoaWNzLXByb3RvY29sLTM3MjQwMjUzNzE\_Ga=q,f=24,t=s,s=1,v=1,S=19,i=3;L2ljYXQtSzVPSENHWVVSM0ZFNA\7[?r8 _Ga=T,q=2,f=100,s=64,v=64;iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAIAAAAlC+aJAAAwS0lEQVR4AQFAML/PAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5wANTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecNTecADU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nDU3nAA1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5w1N5+0wES1gqxrAAAAAAElFTkSuQmCC\ diff --git a/test/kitty.zig b/test/kitty.zig index a100e7a6..de4dd605 100644 --- a/test/kitty.zig +++ b/test/kitty.zig @@ -423,14 +423,26 @@ test "kitty: an image number gets an id, which the reply carries" { try std.testing.expect(r.storage(0).imageByNumber(5) != null); } -test "kitty: z-index orders images, and a negative one goes under the text" { +test "kitty: z-index travels with the image, and images are handed on lowest z first" { var r = try Rig.init(1); defer r.deinit(); - r.feed(0, "\x1b[1;1H" ++ apc("a=T,i=8,f=24,s=4,v=2,c=2,r=1,z=-1,q=2", rgb_b64) ++ "\x1b[1;1Htext"); - try std.testing.expectEqual(@as(usize, 1), r.placementCount(0)); - var it = r.storage(0).placements.iterator(); - try std.testing.expectEqual(@as(i32, -1), it.next().?.value_ptr.z); - try knownGap("pardes draws every terminal image over the cells, in storage order: an ImagePlace has no z-index, so z<0 (under the text) and the order between overlapping images are lost", @hasField(pardes.ImagePlace, "z")); + // Three overlapping at (0,0), given out of order; the virtual one's z + // is its placement's. + r.feed(0, "\x1b[1;1H" ++ apc("a=T,i=8,f=24,s=4,v=2,c=2,r=1,z=5,C=1,q=2", rgb_b64) ++ + apc("a=T,i=9,f=24,s=4,v=2,c=2,r=1,z=-7,C=1,q=2", rgb_b64) ++ + apc("a=T,i=10,f=24,s=4,v=2,c=2,r=1,C=1,q=2", rgb_b64) ++ + apc("a=T,U=1,i=11,f=24,s=4,v=2,c=1,r=1,z=3,q=2", rgb_b64) ++ + "\x1b[1;1H\x1b[38;2;0;0;11m\u{10EEEE}\u{0305}\u{0305}\x1b[39m"); + const drawn = try r.places(); + try std.testing.expectEqual(@as(usize, 4), drawn.len); + var zs: [4]i32 = undefined; + var ids: [4]u32 = undefined; + for (drawn, 0..) |place, i| { + zs[i] = place.?.z; + ids[i] = place.?.native.page; + } + try std.testing.expectEqualSlices(i32, &.{ -7, 0, 3, 5 }, &zs); + try std.testing.expectEqualSlices(u32, &.{ 9, 10, 11, 8 }, &ids); } /// A screen with two images in known places, for the deletes: @@ -1134,3 +1146,204 @@ test "kitty: fuzzed traffic neither crashes nor leaks, and every answer parses" } if (seeds != 24) std.debug.print("kitty fuzz: {d} seeds of {d} steps ok\n", .{ seeds, steps }); } + +// ---- An image's pane, as it lives ---- + +test "kitty: scrolled back by pardes, an image shows on its row; scrolled forward, it goes" { + var r = try Rig.init(1); + defer r.deinit(); + const pane = r.pane(0); + r.feed(0, "\x1b[1;1Hmarker" ++ apc("a=T,i=20,f=24,s=4,v=2,c=2,r=1,q=2", rgb_b64)); + var nl: [2 * 60]u8 = undefined; + for (0..60) |i| nl[2 * i ..][0..2].* = "\r\n".*; + r.feed(0, &nl); + try std.testing.expectEqual(@as(usize, 0), (try r.placesOf(20)).len); + // Back to the top of the history: the marker row is the body's first. + terminal.scrollGrid(pane, -1000); + const o = r.origin(0); + const drawn = try r.placesOf(20); + try std.testing.expectEqual(@as(usize, 1), drawn.len); + try std.testing.expectEqual(o.y, drawn[0].y); + try std.testing.expectEqual(o.x + 6, drawn[0].x); + terminal.followOutput(pane); + try std.testing.expectEqual(@as(usize, 0), (try r.placesOf(20)).len); +} + +test "kitty: an edited copy taller than the rows it covers pushes the images below it down" { + var r = try Rig.init(1); + defer r.deinit(); + const pane = r.pane(0); + r.feed(0, "\x1b[1;1Hone\r\ntwo\r\n\x1b[6;1H" ++ apc("a=T,i=21,f=24,s=4,v=2,c=2,r=1,q=2", rgb_b64)); + const o = r.origin(0); + try std.testing.expectEqual(o.y + 5, (try r.placesOf(21))[0].y); + // Row 1 ("two") edited into three lines. + pane.body.mode = .normal; + pane.ovl = .{ .row = 1, .rows = 1, .text = try gpa.dupe(u8, "two\nthree\nfour") }; + const drawn = try r.placesOf(21); + try std.testing.expectEqual(@as(usize, 1), drawn.len); + try std.testing.expectEqual(o.y + 7, drawn[0].y); +} + +test "kitty: an image wider than its pane is cut at the pane's edge, never drawn over the next one" { + var r = try Rig.init(3); + defer r.deinit(); + // The classic boot: two columns. Pane 0 is in the left one. + const rect = r.p.rects[0]; + const o = r.origin(0); + const right = rect.x + rect.w; + // 2x1 cells at its last-but-one column: one cell is the pane's. + const at = try std.fmt.allocPrint(r.frame.allocator(), "\x1b[1;{d}H", .{r.pane(0).cols}); + r.feed(0, at); + r.feed(0, apc("a=T,i=22,f=24,s=4,v=2,c=4,r=1,q=2", rgb_b64)); + const drawn = try r.placesOf(22); + try std.testing.expectEqual(@as(usize, 1), drawn.len); + try std.testing.expect(drawn[0].x + drawn[0].w <= o.x + r.pane(0).cols); + try std.testing.expect(drawn[0].x + drawn[0].w <= right); + // And the pixels it takes are only that cell's. + const g = drawn[0].native.geometry.?; + try std.testing.expect(g.dst.w <= @as(u32, drawn[0].w) * 10); +} + +test "kitty: a collapsed pane draws no image" { + var r = try Rig.init(3); + defer r.deinit(); + r.feed(1, "\x1b[1;1H" ++ apc("a=T,i=23,f=24,s=4,v=2,c=2,r=1,q=2", rgb_b64)); + try std.testing.expectEqual(@as(usize, 1), (try r.placesOf(23)).len); + try std.testing.expect(r.p.executeBuiltinLine(1, "Collapse")); + try std.testing.expectEqual(@as(usize, 0), (try r.placesOf(23)).len); + try std.testing.expect(r.p.executeBuiltinLine(1, "Collapse")); + try std.testing.expectEqual(@as(usize, 1), (try r.placesOf(23)).len); +} + +test "kitty: a new cell size (font zoom) redraws an image at the same cells, scaled to the new size" { + var r = try Rig.init(1); + defer r.deinit(); + r.feed(0, "\x1b[2;3H" ++ apc("a=T,i=24,f=24,s=4,v=2,c=2,r=1,q=2", rgb_b64)); + var drawn = try r.placesOf(24); + try std.testing.expectEqual(@as(u32, 20), drawn[0].native.geometry.?.dst.w); + r.p.update(.{ .resize = .{ .cols = 120, .rows = 40, .cell_pixels = .{ .w = 15, .h = 30 } } }); + r.drain(); + drawn = try r.placesOf(24); + const o = r.origin(0); + try std.testing.expectEqual(@as(usize, 1), drawn.len); + try std.testing.expectEqual(o.x + 2, drawn[0].x); + try std.testing.expectEqual(o.y + 1, drawn[0].y); + try std.testing.expectEqual(@as(u32, 30), drawn[0].native.geometry.?.dst.w); + try std.testing.expectEqual(@as(u32, 30), drawn[0].native.geometry.?.dst.h); +} + +test "kitty: a dumped and restored terminal keeps its images" { + var r = try Rig.init(1); + defer r.deinit(); + r.feed(0, "\x1b[1;1Hpicture" ++ apc("a=T,i=25,f=24,s=4,v=2,c=2,r=1,q=2", rgb_b64)); + try pardes.dump.dumpState(r.p); + const restored = try pardes.dump.restore(r.p, r.p.dump_out.?, "/tmp/pardes-kitty.dump.zon"); + defer restored.deinit(); + const pane = restored.panes[0].?; + const kept = pane.terminal != null and pane.terminal.?.vt.screens.active.kitty_images.placements.count() > 0; + try knownGap("a terminal's kitty images do not survive a dump (Dump/Load, Handover, a closed pane reopened from the Store): dumpPane writes the screen as VT text (ScreenFormatter), which has no images; ghostty's snapshot format carries them but is unstable (v1)", kept); +} + +// ---- Real clients' traffic ---- +// +// What kitten icat 0.49.2 and chafa 1.18.3 wrote to a pardes pane, recorded +// with script(1) between them and the pane (`PARDES_KITTY_EXPLORE` in +// test/kitty_harness.zig), a 64x64 PNG on a 118-column pane with 8x16 cells: +// their probes, then the image streamed. Replayed in 4 KiB reads, each must +// answer whole and draw its first row where it drew live. + +const Recorded = struct { + name: []const u8, + bytes: []const u8, + /// The pane cell its top-left landed on, live; null: draws nothing. + at: ?[2]u16, +}; + +const recorded = [_]Recorded{ + .{ .name = "icat --align=left", .bytes = @embedFile("kitty-fixtures/icat-left.vt"), .at = .{ 0, 0 } }, + .{ .name = "icat --align=center", .bytes = @embedFile("kitty-fixtures/icat-center.vt"), .at = .{ 55, 0 } }, + .{ .name = "icat --align=right", .bytes = @embedFile("kitty-fixtures/icat-right.vt"), .at = .{ 110, 0 } }, + .{ .name = "icat --place 10x5@20x3", .bytes = @embedFile("kitty-fixtures/icat-place.vt"), .at = .{ 21, 3 } }, + .{ .name = "icat --unicode-placeholder", .bytes = @embedFile("kitty-fixtures/icat-placeholder.vt"), .at = .{ 0, 0 } }, + .{ .name = "chafa -f kitty -s 8x4", .bytes = @embedFile("kitty-fixtures/chafa.vt"), .at = .{ 0, 0 } }, + .{ .name = "icat --clear", .bytes = @embedFile("kitty-fixtures/icat-clear.vt"), .at = null }, +}; + +test "kitty: recorded kitten icat and chafa traffic replays: answers whole, images where they were drawn" { + for (recorded) |rec| { + var r = try Rig.init(1); + defer r.deinit(); + r.p.update(.{ .resize = .{ .cols = 120, .rows = 40, .cell_pixels = .{ .w = 8, .h = 16 } } }); + r.drain(); + _ = try r.take(0); + r.feedSplit(0, rec.bytes, 4096); + const got = try r.take(0); + std.testing.expect(answersParse(got)) catch |err| { + std.debug.print("{s}: unparsable answer {f}\n", .{ rec.name, std.ascii.hexEscape(got, .lower) }); + return err; + }; + const drawn = try r.places(); + const want = rec.at orelse { + try std.testing.expectEqual(@as(usize, 0), drawn.len); + continue; + }; + const o = r.origin(0); + var top: ?pardes.ImagePlace = null; + for (drawn) |maybe| if (maybe) |place| { + if (top == null or place.y < top.?.y or (place.y == top.?.y and place.x < top.?.x)) top = place; + }; + const first = top orelse { + std.debug.print("{s}: nothing drawn\n", .{rec.name}); + return error.NothingDrawn; + }; + std.testing.expectEqual([2]u16{ o.x + want[0], o.y + want[1] }, [2]u16{ first.x, first.y }) catch |err| { + std.debug.print("{s}: drawn at {d},{d}, live at {d},{d}\n", .{ rec.name, first.x - o.x, first.y - o.y, want[0], want[1] }); + return err; + }; + } +} + +test "kitty: under a shell that draws no pixels, a 64x64 image over 8x4 cells is glyph art in every cell" { + var r = try Rig.init(1); + defer r.deinit(); + r.p.native_images = false; + r.p.update(.{ .resize = .{ .cols = 120, .rows = 40, .cell_pixels = .{ .w = 8, .h = 16 } } }); + r.drain(); + // Not the frame's arena: each frame resets that. + var data: std.heap.ArenaAllocator = .init(gpa); + defer data.deinit(); + const arena = data.allocator(); + const px = try arena.alloc(u8, 64 * 64 * 3); + for (0..64 * 64) |i| px[i * 3 ..][0..3].* = .{ 13, 77, 231 }; + const enc = try b64(arena, px); + for ([_]bool{ false, true }) |helix| { + if (helix) try std.testing.expect(r.p.executeBuiltinLine(0, "Theme helix")); + // As test/kitty_client.zig's `place` sends it: after text, in + // 1 KiB chunks. + var cmds: std.ArrayList(u8) = .empty; + try cmds.appendSlice(arena, "\x1b[H\x1b[2J\r\nANCHOR>"); + var at: usize = 0; + while (at < enc.len) : (at += 1024) { + const end = @min(enc.len, at + 1024); + const more: u8 = if (end < enc.len) '1' else '0'; + if (at == 0) + try cmds.print(arena, "\x1b_Ga=T,i=42,f=24,s=64,v=64,c=8,r=4,m={c};{s}\x1b\\", .{ more, enc[at..end] }) + else + try cmds.print(arena, "\x1b_Gm={c};{s}\x1b\\", .{ more, enc[at..end] }); + } + try cmds.appendSlice(arena, "\r\n"); + r.feed(0, cmds.items); + _ = try r.places(); + const s = &r.p.surface; + const o = r.origin(0); + var painted: usize = 0; + for (0..4) |dy| for (0..8) |dx| { + const cell = s.at(o.x + 7 + @as(u16, @intCast(dx)), o.y + 1 + @as(u16, @intCast(dy))); + if (cell.style.bg == .rgb and !cell.default) painted += 1; + }; + std.testing.expectEqual(@as(usize, 32), painted) catch |err| { + std.debug.print("helix theme {}: {d} cells painted\n", .{ helix, painted }); + return err; + }; + } +} diff --git a/test/kitty_client.zig b/test/kitty_client.zig index 23c7587f..753727df 100644 --- a/test/kitty_client.zig +++ b/test/kitty_client.zig @@ -109,6 +109,9 @@ fn play(arena: std.mem.Allocator, case: []const u8, cmds: *std.ArrayList(u8)) !v } else if (std.mem.eql(u8, case, "cancel")) { // CAN in the middle of the payload: nothing runs, the text goes on. try cmds.print(arena, "\x1b_Ga=T,i=64,f=24,s={d},v={d};{s}\x18CANCELLED-OK\r\n", .{ side, side, b64[0..512] }); + } else if (std.mem.eql(u8, case, "under")) { + // Under the text (z < 0), as a background picture is put. + try cmds.print(arena, "\x1b_Ga=T,i=66,f=24,s={d},v={d},c=8,r=4,z=-1,q=2;{s}\x1b\\\r\n", .{ side, side, b64 }); } else if (std.mem.eql(u8, case, "show")) { try cmds.print(arena, "\x1b_Ga=T,i=65,f=24,s={d},v={d},c=8,r=4,q=2;{s}\x1b\\\r\n", .{ side, side, b64 }); } else if (std.mem.eql(u8, case, "delete")) { diff --git a/test/kitty_harness.zig b/test/kitty_harness.zig index ad864671..652395b8 100644 --- a/test/kitty_harness.zig +++ b/test/kitty_harness.zig @@ -66,6 +66,7 @@ pub fn main(init: std.process.Init) !void { var run: Run = .{ .arena = arena, .h = &h, .base = base, .kc = kc, .gui = gui }; try run.start(); + if (std.c.getenv("PARDES_KITTY_EXPLORE")) |list| return run.explore(std.mem.span(list)); std.debug.print("kitty harness ({s}):\n", .{if (gui) "gui" else "tty"}); try run.query(); try run.place(); @@ -73,14 +74,53 @@ pub fn main(init: std.process.Init) !void { try run.quiet(); try run.cancel(); if (!gui) try run.delete(); + if (!gui) try run.under(); try run.icat(); try run.chafa(); + try run.yazi(); + + if (!gui) try plainOuter(arena, exe, kc, base); std.debug.print("kitty harness: {d} failed, {d} skipped\n", .{ failures, skipped }); if (failures > 0) return error.KittyHarnessFailed; } +/// Outside, a terminal without kitty graphics (it answers DA, not the +/// graphics query): pardes must send it no graphics command, and draws the +/// pane's image as glyph art; the program in the pane is answered as ever. +fn plainOuter(arena: std.mem.Allocator, exe: [:0]const u8, kc: []const u8, base: [:0]const u8) !void { + var h = try eh.Harness.initArgv(gpa, exe, rows, cols, &.{}); + defer h.deinit(); + try h.expectRawWaitFor("\x1b_Gi=1,a=q\x1b\\", 8000, "pardes did not probe for kitty graphics"); + try h.send("\x1b[?62;22c"); + try h.expectWaitFor("$ ", 10_000, "the shell's prompt did not show"); + try h.pump(400); + var run: Run = .{ .arena = arena, .h = &h, .base = base, .kc = kc, .gui = false }; + const probe_end = h.raw.items.len; + const got = try run.case("place"); + check(std.mem.eql(u8, got, "\x1b_Gi=42;OK\x1b\\" ++ sync_reply), "plain outer: the pane's program is answered as ever ({f})", .{std.ascii.hexEscape(got, .lower)}); + const raw = h.raw.items[probe_end..]; + const sent = std.mem.count(u8, raw, "\x1b_G"); + check(sent == 0, "plain outer: no graphics command reaches a terminal without them ({d})", .{sent}); + // Glyph art fills the 8x4 cells after ANCHOR>: a solid picture is all + // background colour (C64's nearest blue), no glyph. + const anchor = try run.find("ANCHOR>") orelse { + check(false, "plain outer: ANCHOR> on the screen", .{}); + return; + }; + var art: usize = 0; + for (0..4) |dy| for (0..8) |dx| { + const cell = h.term.screens.active.pages.getCell(.{ .viewport = .{ .x = @intCast(anchor.x + 7 + dx), .y = @intCast(anchor.y + dy) } }) orelse continue; + if (cell.style().bg_color != .none) art += 1; + }; + check(art == 32, "plain outer: the image is glyph art in its cells ({d} of 32 coloured)", .{art}); +} + fn hermetic(arena: std.mem.Allocator, base: [:0]const u8, gui: bool) !void { + // zig build hands its children NO_COLOR, and vaxis honours it: pardes + // would draw no colour at all, glyph art included. Emptied, not unset: + // unsetenv compacts the environment block std captured (a null later). + _ = setenv("NO_COLOR", "", 1); for ([_][*:0]const u8{ "PARDES_PID", "PARDES_9P", "PARDES_PANE", "PARDES_MOUNT", "PARDES_TEST", "PARDES_TEST_CAPTURE_DIR", "PARDES_TEST_COLS", "PARDES_TEST_ROWS", "PARDES_DUMP" }) |name| _ = unsetenv(name); _ = setenv("HOME", base, 1); @@ -256,6 +296,69 @@ const Run = struct { check(cells.count == 0, "delete: no placement of it left outside ({d})", .{cells.count}); } + /// PARDES_KITTY_EXPLORE=: each line `namecommand` runs in + /// the pane under `script`, whose log (the client's own bytes, as it + /// ran under pardes) goes to $PARDES_KITTY_RECORD/.log; then the + /// outer screen and pardes's placements there are printed. + fn explore(r: *Run, list_path: []const u8) !void { + const list = try readFile(r.arena, try r.arena.dupeSentinel(u8, list_path, 0)); + const record = if (std.c.getenv("PARDES_KITTY_RECORD")) |d| std.mem.span(d) else r.base; + var lines = std.mem.splitScalar(u8, list, '\n'); + while (lines.next()) |line| { + const tab = std.mem.indexOfScalar(u8, line, '\t') orelse continue; + const name = line[0..tab]; + const cmd = std.mem.replaceOwned(u8, r.arena, line[tab + 1 ..], "$BASE", r.base) catch line[tab + 1 ..]; + const raw_from = r.h.raw.items.len; + const shell_line = try std.fmt.allocPrint(r.arena, "clear; script -q -O {s}/{s}.log -c '{s}' 2>{s}/{s}.err; touch {s}/{s}.out.done", .{ record, name, cmd, r.base, name, r.base, name }); + _ = try r.shell(name, shell_line); + try r.h.pump(800); + std.debug.print("=== {s}: {s}\n", .{ name, cmd }); + const err = readFile(r.arena, try std.fmt.allocPrintSentinel(r.arena, "{s}/{s}.err", .{ r.base, name }, 0)) catch ""; + if (err.len > 0) std.debug.print("stderr: {s}\n", .{err}); + const raw = r.h.raw.items[raw_from..]; + std.debug.print("outer: {d} transmits, {d} puts, {d} deletes\n", .{ std.mem.count(u8, raw, "\x1b_Gf="), std.mem.count(u8, raw, "\x1b_Ga=p"), std.mem.count(u8, raw, "\x1b_Ga=d") }); + var kinds: std.array_hash_map.String(usize) = .empty; + var from: usize = 0; + while (std.mem.indexOfPos(u8, raw, from, "\x1b_Ga=")) |i| : (from = i + 1) { + const end = std.mem.indexOfAnyPos(u8, raw, i + 1, ";\x1b") orelse continue; + var key = raw[i + 3 .. @min(end, i + 3 + 40)]; + // Ids and geometry vary; the command's shape is the point. + if (std.mem.indexOf(u8, key, ",i=")) |cut| key = key[0..cut]; + const gop = try kinds.getOrPut(r.arena, key); + gop.value_ptr.* = if (gop.found_existing) gop.value_ptr.* + 1 else 1; + } + for (kinds.keys(), kinds.values()) |k, n| std.debug.print(" {d}x {s}\n", .{ n, k }); + const screen = r.h.term.screens.active; + const storage = &screen.kitty_images; + var it = storage.placements.iterator(); + while (it.next()) |entry| { + const img = storage.imageById(entry.key_ptr.image_id) orelse continue; + const where: []const u8 = switch (entry.value_ptr.location) { + .pin => |pin| if (screen.pages.pointFromPin(.viewport, pin.*)) |at| try std.fmt.allocPrint(r.arena, "{d},{d}", .{ at.viewport.x, at.viewport.y }) else "off-viewport", + .virtual => "virtual", + .relative => "relative", + }; + std.debug.print(" image {d} {d}x{d}px at {s} {d}x{d} cells src {d},{d} {d}x{d}\n", .{ entry.key_ptr.image_id, img.width, img.height, where, entry.value_ptr.columns, entry.value_ptr.rows, entry.value_ptr.source_x, entry.value_ptr.source_y, entry.value_ptr.source_width, entry.value_ptr.source_height }); + } + r.h.dump(name); + } + } + + fn under(r: *Run) !void { + _ = try r.case("under"); + const storage = &r.h.term.screens.active.kitty_images; + var it = storage.placements.iterator(); + var seen: usize = 0; + var below: usize = 0; + while (it.next()) |entry| { + const img = storage.imageById(entry.key_ptr.image_id) orelse continue; + if (img.width != client.side or img.height != client.side) continue; + seen += 1; + if (entry.value_ptr.z == -1) below += 1; + } + check(seen > 0 and below == seen, "under: z=-1 reaches the outer terminal on every row ({d} of {d})", .{ below, seen }); + } + fn haveTool(r: *Run, name: []const u8) bool { const which = std.fmt.allocPrintSentinel(r.arena, "command -v {s} >/dev/null 2>&1", .{name}, 0) catch return false; return system(which) == 0; @@ -288,6 +391,19 @@ const Run = struct { check(std.mem.indexOf(u8, raw, "\x1b_Gf=32,s=") != null and err.len == 0, "chafa -f kitty: drawn outside ({s})", .{std.mem.trim(u8, err, " \r\n")}); } + /// yazi previews the PNG (its first entry) through shared memory and a + /// virtual placement shown by placeholders, in its right-hand column. + /// Killed after 6 s, it leaves the preview up. + fn yazi(r: *Run) !void { + if (!r.haveTool("yazi")) return skip("yazi: not installed", .{}); + const raw_from = r.h.raw.items.len; + _ = try r.shell("yazi", try std.fmt.allocPrint(r.arena, "clear; mkdir -p {s}/yz; cp {s}/solid.png {s}/yz/; timeout --foreground -s KILL 6 yazi {s}/yz 2>{s}/yazi.out; touch {s}/yazi.out.done", .{ r.base, r.base, r.base, r.base, r.base, r.base })); + if (r.gui) return r.placedNear("yazi"); + const raw = r.h.raw.items[raw_from..]; + const cells = try r.outerPlacements(client.side, client.side); + check(std.mem.indexOf(u8, raw, "\x1b_Gf=32,s=64,v=64,i=") != null and cells.count == 4 and cells.min_x > cols / 2, "yazi: its preview drawn outside, in its right half ({d} rows at {d},{d})", .{ cells.count, cells.min_x, cells.min_y }); + } + fn placedNear(r: *Run, name: []const u8) !void { const path = try r.capturePath(); const deadline = eh.nowMs() + 4000; -- cgit v1.3