diff --git a/src/window_matcher.v b/src/window_matcher.v
new file mode 100644
index 0000000..94fffc4
--- /dev/null
+++ b/src/window_matcher.v
@@ -0,0 +1,232 @@
+`timescale 1ns / 1ps
+//////////////////////////////////////////////////////////////////////////////////
+// Company: 
+// Engineer: 
+// 
+// Create Date: 06/14/2021 05:44:00 PM
+// Design Name: 
+// Module Name: window_matcher
+// Project Name: 
+// Target Devices: 
+// Tool Versions: 
+// Description: 
+// 
+// Dependencies: 
+// 
+// Revision:
+// Revision 0.01 - File Created
+// Additional Comments:
+// 
+//////////////////////////////////////////////////////////////////////////////////
+
+
+module window_matcher(
+    input clk,
+    input rst,
+    
+    input in_blank,
+    input in_hsync,
+    input in_vsync,
+    input [7:0] in_red,
+    input [7:0] in_green,
+    input [7:0] in_blue,
+    
+    output reg win_hsync,
+    output reg win_vsync,
+    output win_blank,
+    
+    output reg out_data_en,
+    output reg out_data_valid,
+    output reg [23:0] out_data,
+    
+    output reg pattern_locked,
+    output reg [11:0] pattern_w,
+    output reg [11:0] pattern_h
+    );
+    
+    reg [11:0] cur_x;
+    reg [11:0] cur_y;
+    reg [11:0] cur_x_sr [2:0];
+    reg [11:0] marker_x;
+    reg [11:0] marker_y;
+	/* rx_x trails by 4 px in the first window row, since we cannot start counting before the marker was fully detected */
+    reg [11:0] rx_x;
+    reg [11:0] rx_y;
+    wire [23:0] in_pxd = {in_red, in_green, in_blue};
+    reg [11:0] in_pxd_match_sr;
+    wire [3:0] in_pxd_match;
+    reg last_hsync;
+    reg last_vsync;
+    wire in_pxd_pattern_match;
+    reg pattern_found;
+    reg pattern_rx;
+    wire pattern_meta_rx;
+    wire pattern_data_rx;
+    wire [11:0] end_x;
+    wire [11:0] end_y;
+    
+    reg [23:0] pattern_meta [3:0];
+    
+    localparam [23:0] PATTERN_0 = 24'h012345;
+    localparam [23:0] PATTERN_1 = 24'h6789ab;
+    localparam [23:0] PATTERN_2 = 24'hcdef42;
+    localparam [23:0] PATTERN_3 = 24'h543210;
+    
+    
+    assign in_pxd_match = {
+                    in_pxd == PATTERN_3,
+                    in_pxd == PATTERN_2,
+                    in_pxd == PATTERN_1,
+                    in_pxd == PATTERN_0
+                    };
+    
+    assign in_pxd_pattern_match = 
+                       in_pxd_match_sr[2+0*4] == 1'b1
+                    && in_pxd_match_sr[1+1*4] == 1'b1
+                    && in_pxd_match_sr[0+2*4] == 1'b1
+                    && in_pxd_match[3] == 1'b1
+                    && in_blank == 1'b0;
+                    
+    assign pattern_meta_rx = pattern_rx && rx_x < 4 && rx_y == 0;
+    assign pattern_data_rx = pattern_rx && !pattern_meta_rx;
+    
+    assign end_x = marker_x + pattern_meta[2];
+    assign end_y = marker_y + pattern_meta[3];
+    
+    assign win_blank = !win_hsync;
+    
+    always @(posedge clk) begin
+        if (rst) begin
+            out_data <= 0;
+            out_data_valid <= 0;
+            out_data_en <= 0;
+            win_hsync <= 0;
+            win_vsync <= 0;
+            cur_x = 0;
+            cur_y = 0;
+            cur_x_sr[0] <= 0;
+            cur_x_sr[1] <= 0;
+            cur_x_sr[2] <= 0;
+            marker_x <= 0;
+            marker_y <= 0;
+			pattern_w <= 0;
+			pattern_h <= 0;
+            rx_x <= 0;
+            rx_y <= 0;
+            last_hsync <= 0;
+            last_vsync <= 0;
+            in_pxd_match_sr <= 0;
+            pattern_found <= 0;
+            pattern_locked <= 0;
+            pattern_rx <= 0;
+            pattern_meta[0] <= 0;
+            pattern_meta[1] <= 0;
+            pattern_meta[2] <= 0;
+            pattern_meta[3] <= 0;
+        end else begin
+            /* TODO add occlusion handling */
+            
+            last_hsync <= in_hsync; 
+            last_vsync <= in_vsync;
+            
+            if (last_hsync == 1'b1 && in_hsync == 1'b0) begin
+                cur_x <= 0;
+                cur_x_sr[0] <= 0;
+                cur_x_sr[1] <= 0;
+                cur_x_sr[2] <= 0;
+                cur_y <= cur_y + 1;
+                in_pxd_match_sr <= 0;
+                
+                rx_x <= 0;
+
+                if (pattern_rx == 1'b1) begin
+                    rx_y <= rx_y+1;
+                end
+            end
+            
+            if (last_vsync == 1'b1 && in_vsync == 1'b0) begin
+                cur_y <= 0;
+                rx_y <= 0;
+                out_data_en <= 0;
+				rx_x <= 0;
+				rx_y <= 0;
+				pattern_rx <= 0;
+                
+                if (!pattern_found) begin
+                    pattern_locked <= 0;
+					pattern_w = 0;
+					pattern_h = 0;
+					
+					marker_x <= 0;
+					marker_y <= 0;
+                    pattern_meta[0] <= 0;
+                    pattern_meta[1] <= 0;
+                    pattern_meta[2] <= 0;
+                    pattern_meta[3] <= 0;
+					
+                end else begin
+                    pattern_locked <= 1;
+					pattern_w = pattern_meta[2];
+					pattern_h = pattern_meta[3];
+                end
+				
+				pattern_found <= 0;
+            end
+            
+            out_data_valid <= 0;
+            
+            if (in_blank == 1'b0) begin
+                cur_x <= cur_x + 1;
+                cur_x_sr[0] <= cur_x;
+                cur_x_sr[1] <= cur_x_sr[0];
+                cur_x_sr[2] <= cur_x_sr[1];
+            
+                in_pxd_match_sr <= { in_pxd_match_sr[7:0], in_pxd_match };
+            
+                if (in_pxd_pattern_match && !pattern_found) begin
+                    pattern_rx <= 1'b1;
+                    pattern_found <= 1'b1;
+                    marker_x <= cur_x;
+                    marker_y <= cur_y;
+                end
+                
+                if (pattern_rx) begin
+                    rx_x <= rx_x+1;
+
+                    if (pattern_meta_rx) begin
+                        case (rx_x)
+                            0: pattern_meta[0] = in_pxd;
+                            1: pattern_meta[1] = in_pxd;
+                            2: pattern_meta[2] = in_pxd;
+                            3: pattern_meta[3] = in_pxd;
+                        endcase
+                    end
+                    
+                    if (pattern_data_rx) begin
+                        out_data <= in_pxd;
+                        out_data_valid <= 1'b1;
+                        out_data_en <= 1'b1;
+                    end
+                end
+                
+                if (pattern_locked) begin
+                    if (cur_x == marker_x) begin
+                        win_hsync <= 1;
+                    end
+                    
+                    if (cur_x == end_x) begin
+                        win_hsync <= 0;
+                    end
+                    
+                    if (cur_y == marker_y) begin
+                        win_vsync <= 1;
+                    end
+                    
+                    if (cur_y == end_y) begin
+                        win_vsync <= 0;
+                    end
+                end
+            end
+        end
+    end
+endmodule
diff --git a/test_bench/window_matcher_tb.v b/test_bench/window_matcher_tb.v
new file mode 100644
index 0000000..9a7d7b7
--- /dev/null
+++ b/test_bench/window_matcher_tb.v
@@ -0,0 +1,98 @@
+`timescale 1ns / 1ps
+//////////////////////////////////////////////////////////////////////////////////
+// Company: 
+// Engineer: 
+// 
+// Create Date: 06/15/2021 10:49:32 AM
+// Design Name: 
+// Module Name: window_matcher_tb
+// Project Name: 
+// Target Devices: 
+// Tool Versions: 
+// Description: 
+// 
+// Dependencies: 
+// 
+// Revision:
+// Revision 0.01 - File Created
+// Additional Comments:
+// 
+//////////////////////////////////////////////////////////////////////////////////
+
+
+module window_matcher_tb();
+    
+    reg clk;
+    reg rst;
+    
+    wire in_blank;
+    reg in_hsync;
+    reg in_vsync;
+    reg [7:0] in_red;
+    reg [7:0] in_green;
+    reg [7:0] in_blue;
+    
+    wire win_hsync;
+    wire win_vsync;
+    wire win_blank;
+    
+    wire out_data_en;
+    wire out_data_valid;
+    wire [23:0] out_data;
+    
+	wire pattern_locked;
+    wire [11:0] pattern_w;
+    wire [11:0] pattern_h;
+	
+	localparam period = 4;
+	
+	assign in_blank = !(in_vsync && in_hsync);
+    
+    initial begin
+        clk = 0;
+        rst = 1;
+        in_hsync = 0;
+        in_vsync = 0;
+        in_red = 0;
+        in_green = 0;
+        in_blue = 0;
+		
+		repeat(2) #period clk = ~clk;
+		rst = 0;
+		forever #period clk = ~clk;
+    end
+    
+	`include "test_data/00WM_TEST_POS_LOADERS.v"
+	
+	integer read_pos;
+	reg [31:0] expected_data;
+	initial begin
+		`include "test_data/00WM_TEST_POS_RUNNERS.v"
+		$finish;
+	end
+	
+    window_matcher window_matcher_i (
+    .clk(clk),
+    .rst(rst),
+    
+    .in_blank(in_blank),
+    .in_hsync(in_hsync),
+    .in_vsync(in_vsync),
+    .in_red(in_red),
+    .in_green(in_green),
+    .in_blue(in_blue),
+    
+    .win_hsync(win_hsync),
+    .win_vsync(win_vsync),
+    .win_blank(win_blank),
+    
+    .out_data_en(out_data_en),
+    .out_data_valid(out_data_valid),
+    .out_data(out_data),
+    
+	.pattern_locked(pattern_locked),
+    .pattern_w(pattern_w),
+    .pattern_h(pattern_h)
+    );
+    
+endmodule
diff --git a/test_bench/window_matcher_tb_gen.ipynb b/test_bench/window_matcher_tb_gen.ipynb
new file mode 100644
index 0000000..d0a49f0
--- /dev/null
+++ b/test_bench/window_matcher_tb_gen.ipynb
@@ -0,0 +1,558 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "frozen-repair",
+   "metadata": {},
+   "source": [
+    "# Window Matcher Testcase Generator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "automated-evening",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from enum import Enum\n",
+    "from functools import wraps\n",
+    "from itertools import product\n",
+    "from pathlib import Path\n",
+    "from contextlib import redirect_stdout\n",
+    "import math\n",
+    "\n",
+    "import jinja2\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "civic-gilbert",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class AlphaFlags(Enum):\n",
+    "    HSYNC = 1\n",
+    "    VSYNC = 2\n",
+    "    WIN_HSYNC = 4\n",
+    "    WIN_VSYNC = 8\n",
+    "    WIN_HEADER = 16;\n",
+    "\n",
+    "class Channels:\n",
+    "    RED = 0\n",
+    "    GREEN = 1\n",
+    "    BLUE = 2\n",
+    "    ALPHA = 3\n",
+    "    \n",
+    "WINDOW_MAGIC = np.array([[0x01, 0x23, 0x45], [0x67, 0x89, 0xab], [0xcd, 0xef, 0x42], [0x54, 0x32, 0x10]])\n",
+    "    \n",
+    "\n",
+    "def add_alpha(fb):\n",
+    "    return np.pad(fb, [(0,0), (0,0), (0,1)])\n",
+    "    \n",
+    "def coord_pixbuf(w, h):\n",
+    "    fb = np.dstack(np.meshgrid(np.arange(w), np.arange(h))).astype(int)\n",
+    "    fb = np.dstack([\n",
+    "        fb[:,:,0] % 256,\n",
+    "        (((fb[:,:,0] // 256)&0xf) << 4) | ((fb[:,:,1] // 256) & 0xf),\n",
+    "        fb[:,:,1] % 256\n",
+    "    ])\n",
+    "    return add_alpha(fb)\n",
+    "\n",
+    "def random_pixbuf(w, h, seed=None):\n",
+    "    rng = np.random.default_rng(seed=seed)\n",
+    "    return add_alpha(rng.integers(0, 256, (h, w, 3)))\n",
+    "\n",
+    "def zero_pixbuf(w, h, seed=None):\n",
+    "    return np.zeros((h, w, 4), dtype=int)\n",
+    "    \n",
+    "def add_blanking(fb, hsync_fp=30, hsync_bp=50, vsync_fp=7, vsync_bp=3):\n",
+    "    # fb should be in rgba format, a should be 0\n",
+    "    fb[:,:,Channels.ALPHA] |= AlphaFlags.HSYNC.value\n",
+    "    fb = np.pad(fb, [(vsync_fp, vsync_bp), (hsync_fp, hsync_bp), (0,0)])\n",
+    "    fb[vsync_fp:-vsync_bp,:,Channels.ALPHA] |= AlphaFlags.VSYNC.value\n",
+    "    fb[:,:,Channels.ALPHA] |= np.tile(AlphaFlags.WIN_VSYNC.value * (fb[:,:,Channels.ALPHA] & AlphaFlags.WIN_VSYNC.value).any(axis=1)[:,np.newaxis], (1, fb.shape[1]))\n",
+    "    return fb\n",
+    "    \n",
+    "def add_window(fb, win_x, win_y, win_w=500, win_h=500, win_data=None, header=None):\n",
+    "    # first call add_window, then add_blanking!\n",
+    "    if win_data is None:\n",
+    "        win_data = coord_pixbuf(win_w, win_h)\n",
+    "    \n",
+    "    def encode_val(val):\n",
+    "        return np.array([(val//65536)&0xff, (val%65536//256)&0xff, (val%256)&0xff]).astype(int)\n",
+    "    \n",
+    "    win_data[0, :4, :3] = WINDOW_MAGIC\n",
+    "    win_data[0, 4,  :3] = encode_val(win_x)\n",
+    "    win_data[0, 5,  :3] = encode_val(win_y)\n",
+    "    win_data[0, 6,  :3] = encode_val(win_w)\n",
+    "    win_data[0, 7,  :3] = encode_val(win_h)\n",
+    "    win_data[0, :8, 3] |= AlphaFlags.WIN_HEADER.value;\n",
+    "    \n",
+    "    win_h, win_w, _ = win_data.shape\n",
+    "    h, w, _ = fb.shape\n",
+    "    \n",
+    "    if win_x < 0:\n",
+    "        win_w += win_x\n",
+    "        win_data = win_data[:,-win_x:,:]\n",
+    "        win_x = 0\n",
+    "        \n",
+    "    if win_y < 0:\n",
+    "        win_h += win_y\n",
+    "        win_data = win_data[-win_y:,:,:]\n",
+    "        win_y = 0\n",
+    "    \n",
+    "    win_w = min(win_w, w-win_x)\n",
+    "    win_h = min(win_h, h-win_y)\n",
+    "    \n",
+    "    win_data = win_data[:win_h, :win_w, :]\n",
+    "    \n",
+    "    fb[win_y:win_y+win_h, win_x:win_x+win_w, :] = win_data\n",
+    "    fb[win_y:win_y+win_h, win_x:win_x+win_w, Channels.ALPHA] |= AlphaFlags.WIN_HSYNC.value\n",
+    "    fb[win_y:win_y+win_h, :, Channels.ALPHA] |= AlphaFlags.WIN_VSYNC.value\n",
+    "    return fb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "opening-design",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_data_dir = Path('test_data')\n",
+    "registered_testcases = {}\n",
+    "\n",
+    "def testcase(name=None, win_w=0, win_h=0):\n",
+    "    def wrapper(fun):\n",
+    "        nonlocal name\n",
+    "        fb = fun()\n",
+    "        if name is None:\n",
+    "            name = fun.__name__\n",
+    "        with open(test_data_dir / f'{name}.hex', 'w') as f:\n",
+    "            for r, g, b, a in fb.reshape((-1, 4)):\n",
+    "                f.write(f'{r:02x}{g:02x}{b:02x}{a:02x}\\n')\n",
+    "        registered_testcases[name] = (fb.shape[0]*fb.shape[1], win_w, win_h)\n",
+    "        return fun\n",
+    "    return wrapper"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "brave-limitation",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x648 with 16 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "@testcase()\n",
+    "def test_empty():\n",
+    "    return add_blanking(zero_pixbuf(50, 30))\n",
+    "\n",
+    "@testcase()\n",
+    "def test_random():\n",
+    "    return add_blanking(random_pixbuf(50, 30))\n",
+    "\n",
+    "@testcase()\n",
+    "def test_coords():\n",
+    "    return add_blanking(coord_pixbuf(50, 30))\n",
+    "\n",
+    "@testcase(win_w=50, win_h=20)\n",
+    "def test_simple_window():\n",
+    "    return add_blanking(add_window(coord_pixbuf(100, 80), 20, 30, 50, 20))\n",
+    "\n",
+    "fig, axs = plt.subplots(4, 4, figsize=(12, 9))\n",
+    "for ax, bools in zip(axs.flatten(), product([False, True], repeat=4)):\n",
+    "    #if not any(bools):\n",
+    "    #    ax.axis('off')\n",
+    "    #    continue\n",
+    "    \n",
+    "    cxl, cxh, cyl, cyh = bools\n",
+    "    w, h = 100, 80\n",
+    "    win_x = 0 if cxl else 20\n",
+    "    win_y = 0 if cyl else 15\n",
+    "    win_w = w-win_x if cxh else w-win_x-30\n",
+    "    win_h = h-win_y if cyh else h-win_y-20\n",
+    "    \n",
+    "    clip_id = ''.join('01'[i] for i in bools)\n",
+    "    @testcase(f'test_window_clip_{clip_id}', win_w=win_w, win_h=win_h)\n",
+    "    def fun():\n",
+    "        return add_blanking(add_window(coord_pixbuf(w, h), win_x, win_y, win_w, win_h))\n",
+    "    \n",
+    "    ax.imshow(fun()[:,:,3])\n",
+    "    \n",
+    "for bools in product([False, True], repeat=2):\n",
+    "    ox, oy = bools\n",
+    "    w, h = 100, 80\n",
+    "    win_x = 50\n",
+    "    win_y = 50\n",
+    "    win_w = 80 if ox else 30\n",
+    "    win_h = 50 if oy else 20\n",
+    "    \n",
+    "    ov_id = ''.join('01'[i] for i in bools)\n",
+    "    @testcase(f'test_window_overflow_{ov_id}', win_w=win_w, win_h=win_h)\n",
+    "    def fun():\n",
+    "        return add_blanking(add_window(coord_pixbuf(w, h), win_x, win_y, win_w, win_h))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "classified-tenant",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def gen_loader(testcases):\n",
+    "    print()\n",
+    "    for name, (fb_len, _win_w, _win_h) in testcases.items():\n",
+    "        print(f'reg [31:0] test_fb_{name} [0:{fb_len}];')\n",
+    "    \n",
+    "    print()\n",
+    "    print('initial begin')\n",
+    "    for name, fb_len in testcases.items():\n",
+    "        print(f'$readmemh(\"../../../../test_bench/{test_data_dir / name}.hex\", test_fb_{name});')\n",
+    "    print('end')\n",
+    "    \n",
+    "with open(test_data_dir / '00WM_TEST_POS_LOADERS.v', 'w') as f, redirect_stdout(f):\n",
+    "    gen_loader(registered_testcases)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "id": "independent-programmer",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "RUNNER_TPL = '''\n",
+    "/* Start of generated test case {{name}} */\n",
+    "\n",
+    "rst = 1;\n",
+    "repeat(2) @(posedge clk);\n",
+    "rst = 0;\n",
+    "repeat(8) @(posedge clk);\n",
+    "\n",
+    "$display(\"Running {{name}}\");\n",
+    "for (read_pos=0; read_pos<{{fb_len}}; read_pos=read_pos+1) begin\n",
+    "    \n",
+    "    if (!(win_hsync == 0)) $finish;\n",
+    "    if (!(win_vsync == 0)) $finish;\n",
+    "    //if (!(pattern_w == 0)) $finish;\n",
+    "    //if (!(pattern_h == 0)) $finish;\n",
+    "    //if (!(in_blank == 1 || pattern_w == 0)) $finish;\n",
+    "    //if (!(in_blank == 1 || pattern_h == 0)) $finish;\n",
+    "        if (!(!out_data_valid || out_data_en)) $finish;\n",
+    "    if (read_pos > 1) begin\n",
+    "        expected_data = {{mem}}[read_pos-2];\n",
+    "        //if (!(out_data_valid == ( expected_data[{{ FLAG_WIN_VSYNC }}] && ~expected_data[{{ FLAG_WIN_HEADER }}]))) $finish;\n",
+    "        if (!(!out_data_valid || out_data == expected_data[31:8])) begin\n",
+    "            $display(\"Expected: %h actual: %h\", expected_data[31:8], out_data);\n",
+    "            $finish;\n",
+    "        end\n",
+    "    end\n",
+    "    \n",
+    "    in_hsync = {{mem}}[read_pos][{{ FLAG_HSYNC }}];\n",
+    "    in_vsync = {{mem}}[read_pos][{{ FLAG_VSYNC }}];\n",
+    "    in_red   = {{mem}}[read_pos][31:24];\n",
+    "    in_green = {{mem}}[read_pos][23:16];\n",
+    "    in_blue  = {{mem}}[read_pos][15: 8];\n",
+    "    @(posedge clk);\n",
+    "end\n",
+    "\n",
+    "if (!(pattern_locked == {{(win_w > 0)|int}})) $finish;\n",
+    "\n",
+    "if (!(pattern_w == {{win_w}})) $finish;\n",
+    "if (!(pattern_h == {{win_h}})) $finish;\n",
+    "\n",
+    "for (read_pos=0; read_pos<{{fb_len}}; read_pos=read_pos+1) begin\n",
+    "    if (read_pos > 0) begin\n",
+    "        //if (!(win_hsync == {{mem}}[read_pos-1][{{ FLAG_WIN_HSYNC }}])) $finish;\n",
+    "        //if (!(win_vsync == {{mem}}[read_pos-1][{{ FLAG_WIN_VSYNC }}])) $finish;\n",
+    "    end\n",
+    "    \n",
+    "    in_hsync = {{mem}}[read_pos][{{ FLAG_HSYNC }}];\n",
+    "    in_vsync = {{mem}}[read_pos][{{ FLAG_VSYNC }}];\n",
+    "    in_red   = 0;\n",
+    "    in_green = 0;\n",
+    "    in_blue  = 0;\n",
+    "    \n",
+    "    @(posedge clk);\n",
+    "end\n",
+    "\n",
+    "if (!(pattern_locked == 0)) $finish;\n",
+    "if (!(pattern_w == 0)) $finish;\n",
+    "if (!(pattern_h == 0)) $finish;\n",
+    "\n",
+    "/* End of generated test case {{name}} */\n",
+    "'''\n",
+    "\n",
+    "def gen_runner(testcases):\n",
+    "    tpl = jinja2.Environment().from_string(RUNNER_TPL, globals=globals())\n",
+    "    for name, (fb_len, win_w, win_h) in testcases.items():\n",
+    "        print(tpl.render(name=name, fb_len=fb_len, mem=f'test_fb_{name}', win_w=win_w, win_h=win_h,\n",
+    "             FLAG_HSYNC = int(math.log2(AlphaFlags.HSYNC.value)),\n",
+    "             FLAG_VSYNC = int(math.log2(AlphaFlags.VSYNC.value)),\n",
+    "             FLAG_WIN_HSYNC = int(math.log2(AlphaFlags.WIN_HSYNC.value)),\n",
+    "             FLAG_WIN_VSYNC = int(math.log2(AlphaFlags.WIN_VSYNC.value)),\n",
+    "             FLAG_WIN_HEADER = int(math.log2(AlphaFlags.WIN_HEADER.value)),\n",
+    "             ))\n",
+    "\n",
+    "with open(test_data_dir / '00WM_TEST_POS_RUNNERS.v', 'w') as f, redirect_stdout(f):\n",
+    "    gen_runner(registered_testcases)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "collaborative-drilling",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def show(foo):\n",
+    "    fig, ax = plt.subplots(figsize=(12, 9))\n",
+    "    ax.imshow(foo, interpolation='None')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "terminal-reasoning",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x648 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "show(add_blanking(random_pixbuf(200, 100))[:,:,3])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "furnished-omega",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x648 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "show(add_blanking(random_pixbuf(200, 100))[:,:,0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "adjustable-allah",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f04a9b73d60>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsYAAAHQCAYAAACiD6yuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAApx0lEQVR4nO3dcaxcd53f/ffnXl87m0C6uMSpsf1s0taRmqBuoJZByqpKN9tNmq5qtirISN2malTvH6EsKlJxWKnstoqUrXaz2/Z5WD3eEuFVCcEColiIlg3uIkQFCQkbIE7I4iVectdWDCWUsFJNfP3tH3Nsj+25vnPn3MnMHL9f0mjO/Oacmd9Xd/LNx785M5OqQpIkSbrczU16ApIkSdI0MBhLkiRJGIwlSZIkwGAsSZIkAQZjSZIkCTAYS5IkScAYg3GSO5I8n+RIkr3jeh5JUnv2bEmCjON7jJPMA38K/H1gEfgq8O6qenbNn0yS1Io9W5J6xrVivBM4UlXfqaqfAA8Du8b0XJKkduzZkgSsG9PjbgFe7Lu9CLxtuZ3XZ0NdwVVjmookjdcrvPz9qrpm0vNoYVU9G+zbkmbX/+Ev+UmdzKD7xhWMBz3ZeedsJNkD7AG4git5W24b01Qkabw+X5/880nPoaUVezbYtyV1w+N1aNn7xnUqxSKwre/2VuBY/w5Vta+qdlTVjgU2jGkakqQhrNizwb4tqfvGFYy/CmxPcn2S9cBu4OCYnkuS1I49W5IY06kUVXUqyXuAzwHzwINVdXgczwVAQubnYX6+d913m/m53vjc3Lnbc3NUc00C83PU3BzMp+86zT69bebojc2FOnP/mbF5zt4m9N3HuX3Ou31mv/Pv44J9qvlny8X31bnbae4LMFd9j3Vmn+q9STpXZ8dIkbkzF0iKzJ1mbq76LqcJMD93mvm5aq5PM5/e9rq508yndz2XYl2WWDd3mnU5zbq5JRYuul5iLsVCls5d5k6dd3t9erfnOd2MnWJ9c72QJdZzZt/TLNCbywLFQmB9wgJhIXMsZJ51zHPnlrfCXPOamOt/jTSvhbn+7bneayM599o4+1rJRdeVnH1tnPd6mL/w9XLh33/w9rnXw7n7Br4essx287c+7zbnj599PfRdk/7XB6R5nZx5fcw1r5W5uSI599qYT3N95rWR6r0mmtfDmdfGmdfDme2FuaWz13PU2ddG7/WwdP7ro/nbz6XOvjbOe02wdMHro/fcC5xmfU6zEPiX/8/Pja3tdMlr3rOlZfznP/+fk56CJuxf/cwtE33+cZ1jTFV9FvjsuB5fkrR27NmS5C/fSZIkSYDBWJIkSQIMxpIkSRJgMJYkSZIAg7EkSZIEGIwlSZIkwGAsSZIkAQZjSZIkCTAYS5IkSYDBWJIkSQIMxpIkSRJgMJYkSZIAg7EkSZIEGIwlSZIkwGAsSZIkAQZjSZIkCTAYS5IkSQCsa3NwkqPAK8AScKqqdiTZCHwCuA44Cryrql5uN01J0lqwb0vS8tZixfjvVdXNVbWjub0XOFRV24FDzW1J0vSwb0vSAOM4lWIXsL/Z3g+8YwzPIUlaO/ZtSaJ9MC7gj5I8lWRPM3ZtVR0HaK43tXwOSdLasW9L0jJanWMM3FJVx5JsAh5L8q1hD2wa8h6AK7iy5TQkSUOyb0vSMlqtGFfVseb6BPAIsBN4KclmgOb6xDLH7quqHVW1Y4ENbaYhSRqSfVuSljdyME5yVZLXn9kGfhF4BjgI3NXsdhfwaNtJSpLas29L0qW1OZXiWuCRJGce56Gq+u9JvgocSHI38F3gne2nKUlaA/ZtSbqEkYNxVX0H+NkB4/8LuK3NpCRJa8++LUmX5i/fSZIkSRiMJUmSJMBgLEmSJAEGY0mSJAkwGEuSJEmAwViSJEkCDMaSJEkSYDCWJEmSAIOxJEmSBBiMJUmSJMBgLEmSJAEGY0mSJAkwGEuSJEmAwViSJEkCDMaSJEkSYDCWJEmSAIOxJEmSBBiMJUmSJGCIYJzkwSQnkjzTN7YxyWNJvt1cv6HvvnuTHEnyfJLbxzVxSdJg9m1JGs0wK8YfBe64YGwvcKiqtgOHmtskuRHYDdzUHPPhJPNrNltJ0jA+in1bklZtxWBcVV8EfnDB8C5gf7O9H3hH3/jDVXWyql4AjgA712aqkqRh2LclaTSjnmN8bVUdB2iuNzXjW4AX+/ZbbMYukmRPkieTPPkqJ0echiRpSPZtSVrBWn/4LgPGatCOVbWvqnZU1Y4FNqzxNCRJQ7JvS1Jj1GD8UpLNAM31iWZ8EdjWt99W4Njo05MkrRH7tiStYNRgfBC4q9m+C3i0b3x3kg1Jrge2A0+0m6IkaQ3YtyVpBetW2iHJx4FbgTcmWQQ+BNwPHEhyN/Bd4J0AVXU4yQHgWeAUcE9VLY1p7pKkAezbkjSaFYNxVb17mbtuW2b/+4D72kxKkjQ6+7YkjcZfvpMkSZIwGEuSJEmAwViSJEkCDMaSJEkSYDCWJEmSAIOxJEmSBBiMJUmSJMBgLEmSJAEGY0mSJAkwGEuSJEmAwViSJEkCDMaSJEkSYDCWJEmSAIOxJEmSBBiMJUmSJMBgLEmSJAEGY0mSJAkYIhgneTDJiSTP9I39RpK/SPJ0c7mz7757kxxJ8nyS28c1cUnSYPZtSRrNMCvGHwXuGDD+u1V1c3P5LECSG4HdwE3NMR9OMr9Wk5UkDeWj2LcladVWDMZV9UXgB0M+3i7g4ao6WVUvAEeAnS3mJ0laJfu2JI2mzTnG70nyjeYtuzc0Y1uAF/v2WWzGLpJkT5Inkzz5KidbTEOSNCT7tiRdwqjB+PeBvwHcDBwHfqcZz4B9a9ADVNW+qtpRVTsW2DDiNCRJQ7JvS9IKRgrGVfVSVS1V1WngDzj3ttsisK1v163AsXZTlCS1Zd+WpJWNFIyTbO67+cvAmU8+HwR2J9mQ5HpgO/BEuylKktqyb0vSytattEOSjwO3Am9Msgh8CLg1yc303m47CvwqQFUdTnIAeBY4BdxTVUtjmbkkaSD7tiSNZsVgXFXvHjD8kUvsfx9wX5tJSZJGZ9+WpNH4y3eSJEkSBmNJkiQJMBhLkiRJgMFYkiRJAgzGkiRJEmAwliRJkgCDsSRJkgQYjCVJkiTAYCxJkiQBBmNJkiQJMBhLkiRJgMFYkiRJAgzGkiRJEmAwliRJkgCDsSRJkgQYjCVJkiTAYCxJkiQBQwTjJNuS/HGS55IcTvJrzfjGJI8l+XZz/Ya+Y+5NciTJ80luH2cBkqRz7NmSNLphVoxPAe+vqr8FvB24J8mNwF7gUFVtBw41t2nu2w3cBNwBfDjJ/DgmL0m6iD1bkka0YjCuquNV9bVm+xXgOWALsAvY3+y2H3hHs70LeLiqTlbVC8ARYOcaz1uSNIA9W5JGt6pzjJNcB7wFeBy4tqqOQ68RA5ua3bYAL/YdttiMXfhYe5I8meTJVzk5wtQlSZeylj27eTz7tqROGzoYJ3kd8CngfVX1o0vtOmCsLhqo2ldVO6pqxwIbhp2GJGkIa92zwb4tqfuGCsZJFug12I9V1aeb4ZeSbG7u3wycaMYXgW19h28Fjq3NdCVJK7FnS9JohvlWigAfAZ6rqgf67joI3NVs3wU82je+O8mGJNcD24En1m7KkqTl2LMlaXTrhtjnFuBXgG8meboZ+yBwP3Agyd3Ad4F3AlTV4SQHgGfpfTr6nqpaWuuJS5IGsmdL0ohWDMZV9SUGn4MGcNsyx9wH3NdiXpKkEdizJWl0/vKdJEmShMFYkiRJAgzGkiRJEmAwliRJkgCDsSRJkgQYjCVJkiTAYCxJkiQBBmNJkiQJMBhLkiRJgMFYkiRJAgzGkiRJEmAwliRJkgCDsSRJkgQYjCVJkiTAYCxJkiQBBmNJkiQJMBhLkiRJwBDBOMm2JH+c5Lkkh5P8WjP+G0n+IsnTzeXOvmPuTXIkyfNJbh9nAZKkc+zZkjS6dUPscwp4f1V9LcnrgaeSPNbc97tV9dv9Oye5EdgN3AS8Cfh8khuqamktJy5JGsieLUkjWnHFuKqOV9XXmu1XgOeALZc4ZBfwcFWdrKoXgCPAzrWYrCTp0uzZkjS6VZ1jnOQ64C3A483Qe5J8I8mDSd7QjG0BXuw7bJFLN2VJ0hjYsyVpdYYOxkleB3wKeF9V/Qj4feBvADcDx4HfObPrgMNrwOPtSfJkkidf5eRq5y1JuoS17tnNY9q3JXXaUME4yQK9Bvuxqvo0QFW9VFVLVXUa+APOvfW2CGzrO3wrcOzCx6yqfVW1o6p2LLChTQ2SpD7j6NnNY9i3JXXaMN9KEeAjwHNV9UDf+Oa+3X4ZeKbZPgjsTrIhyfXAduCJtZuyJGk59mxJGt0w30pxC/ArwDeTPN2MfRB4d5Kb6b3ldhT4VYCqOpzkAPAsvU9H3+OnmyXpNWPPlqQRrRiMq+pLDD4H7bOXOOY+4L4W85IkjcCeLUmj85fvJEmSJIY7lUKSpDU1f801k56CptANC1dNegq6zLliLEmSJGEwliRJkgCDsSRJkgQYjCVJkiTAYCxJkiQBBmNJkiQJMBhLkiRJgMFYkiRJAgzGkiRJEmAwliRJkgCDsSRJkgQYjCVJkiTAYCxJkiQBBmNJkiQJMBhLkiRJgMFYkiRJAoYIxkmuSPJEkq8nOZzkN5vxjUkeS/Lt5voNfcfcm+RIkueT3D7OAiRJ59izJWl0w6wYnwR+vqp+FrgZuCPJ24G9wKGq2g4cam6T5EZgN3ATcAfw4STzY5i7JOli9mxJGtGKwbh6ftzcXGguBewC9jfj+4F3NNu7gIer6mRVvQAcAXau5aQlSYPZsyVpdEOdY5xkPsnTwAngsap6HLi2qo4DNNebmt23AC/2Hb7YjF34mHuSPJnkyVc52aIESVK/cfTs5nHt25I6bahgXFVLVXUzsBXYmeTNl9g9gx5iwGPuq6odVbVjgQ1DTVaStLJx9Ozmce3bkjptVd9KUVU/BL5A7zy0l5JsBmiuTzS7LQLb+g7bChxrO1FJ0urYsyVpddattEOSa4BXq+qHSX4K+AXgt4CDwF3A/c31o80hB4GHkjwAvAnYDjwxhrmfU0WdOgWnTg1e5hhRLrjW+Qp4tdke/k3V+ebyGjm9RJ1eApZZAhuRr41LO/PaeHWlHc+aay4LY5rR5WMmejaw9L3vjfspNINuf9PNk56CLnMrBmNgM7C/+ZTyHHCgqj6T5MvAgSR3A98F3glQVYeTHACeBU4B91TV0nimL0m6gD1bkkaUqrVcRxtxEsn3gL8Evj/puayhN9KteqB7NVnP9JuVmn6mqq6Z9CReS0leAZ6f9DzW0Ky81lajazV1rR7oXk2zUs+yPXsqgjFAkierasek57FWulYPdK8m65l+XaypK7r2t+laPdC9mrpWD3Svpi7U409CS5IkSRiMJUmSJGC6gvG+SU9gjXWtHuheTdYz/bpYU1d07W/TtXqgezV1rR7oXk0zX8/UnGMsSZIkTdI0rRhLkiRJE2MwliRJkpiCYJzkjiTPJzmSZO+k5zOsJA8mOZHkmb6xjUkeS/Lt5voNfffd29T4fJLbJzPr5SXZluSPkzyX5HCSX2vGZ7KmJFckeSLJ15t6frMZn8l6zkgyn+RPknymuT3r9RxN8s0kTyd5shmb6Zq6zp49HezZ011Pvy717cuiZ1fVxC70fhv4z4C/DqwHvg7cOMk5rWLufxd4K/BM39h/APY223uB32q2b2xq2wBc39Q8P+kaLqhnM/DWZvv1wJ82857Jmuj9WvPrmu0F4HHg7bNaT19d/xp4CPjMrL/mmnkeBd54wdhM19Tliz178nX0zd2ePcX1XFBbZ/r25dCzJ71ivBM4UlXfqaqfAA8DuyY8p6FU1ReBH1wwvAvY32zvB97RN/5wVZ2sqheAI/RqnxpVdbyqvtZsvwI8B2xhRmuqnh83NxeaSzGj9QAk2Qr8Q+C/9A3PbD2X0MWausKePSXs2dNdzxmXSd/uVD2TDsZbgBf7bi82Y7Pq2qo6Dr2mBWxqxmeqziTXAW+h9y/2ma2pefvqaeAE8FhVzXQ9wO8B/wY43Tc2y/VA7398f5TkqSR7mrFZr6nLuvY36MRrzZ4NTGE9jd+jW3278z173YSfPwPGuvj9cTNTZ5LXAZ8C3ldVP0oGTb2364CxqaqpqpaAm5P8NPBIkjdfYveprifJLwEnquqpJLcOc8iAsampp88tVXUsySbgsSTfusS+s1JTl10uf4OZqdOeff5DjGViI+po3+58z570ivEisK3v9lbg2ITmshZeSrIZoLk+0YzPRJ1JFug12I9V1aeb4ZmuCaCqfgh8AbiD2a3nFuAfJTlK7+3rn0/yX5ndegCoqmPN9QngEXpvs810TR3Xtb/BTL/W7NlTX0/n+vbl0LMnHYy/CmxPcn2S9cBu4OCE59TGQeCuZvsu4NG+8d1JNiS5HtgOPDGB+S0rvWWGjwDPVdUDfXfNZE1JrmlWHUjyU8AvAN9iRuupqnuramtVXUfvv5P/UVX/lBmtByDJVUlef2Yb+EXgGWa4psuAPXtK2LOnux7oXt++bHr2pD/9B9xJ79O0fwb8+qTns4p5fxw4DrxK719FdwN/FTgEfLu53ti3/683NT4P/INJz39APT9H7y2ObwBPN5c7Z7Um4G8Df9LU8wzwb5vxmazngtpu5dynm2e2HnrfbPD15nL4zH//s1zT5XCxZ0/HxZ493fUMqG/m+/bl0rP9SWhJkiSJyZ9KIUmSJE0Fg7EkSZKEwViSJEkCDMaSJEkSYDCWJEmSAIOxJEmSBBiMJUmSJMBgLEmSJAEGY0mSJAkwGEuSJEmAwViSJEkCDMaSJEkSYDCWJEmSAIOxJEmSBBiMJUmSJMBgLEmSJAEGY0mSJAkwGEuSJEmAwViSJEkCDMaSJEkSYDCWJEmSAIOxJEmSBBiMJUmSJMBgLEmSJAEGY0mSJAkwGEuSJEmAwViSJEkCDMaSJEkSYDCWJEmSAIOxJEmSBBiMJUmSJMBgLEmSJAEGY0mSJAkwGEuSJEmAwViSJEkCDMaSJEkSYDCWJEmSAIOxJEmSBBiMJUmSJMBgLEmSJAEGY0mSJAkwGEuSJEmAwViSJEkCDMaSJEkSYDCWJEmSAIOxJEmSBBiMJUmSJMBgLEmSJAEGY0mSJAkwGEuSJEmAwViSJEkCDMaSJEkSYDCWJEmSAIOxJEmSBBiMJUmSJMBgLEmSJAEGY0mSJAkwGEuSJEmAwViSJEkCDMaSJEkSYDCWJEmSAIOxJEmSBBiMJUmSJMBgLEmSJAEGY0mSJAkwGEuSJEmAwViSJEkCDMaSJEkSYDCWJEmSAIOxJEmSBBiMJUmSJMBgLEmSJAEGY0mSJAkwGEuSJEmAwViSJEkCDMaSJEkSYDCWJEmSAIOxJEmSBBiMJUmSJMBgLEmSJAEGY0mSJAkwGEuSJEmAwViSJEkCDMaSJEkSMMZgnOSOJM8nOZJk77ieR5LUnj1bkiBVtfYPmswDfwr8fWAR+Crw7qp6ds2fTJLUij1bknrGtWK8EzhSVd+pqp8ADwO7xvRckqR27NmSBKwb0+NuAV7su70IvK1/hyR7gD0A88z/nSu5ekxTkaTxeoWXv19V10x6Hi2s2LPBvi2pG/4Pf8lP6mQG3TeuYDzoyc47Z6Oq9gH7AK7OxnpbbhvTVCRpvD5fn/zzSc+hpRV7Nti3JXXD43Vo2fvGdSrFIrCt7/ZW4NiYnkuS1I49W5IYXzD+KrA9yfVJ1gO7gYNjei5JUjv2bEliTKdSVNWpJO8BPgfMAw9W1eFxPBcAGXiaiKTL3Ri+daeLRunZS9s38L//098c+Tm/cvMnRz5WUne9/el/MvbnWHrvl5a9b1znGFNVnwU+O67H75f5+dfiaSTNmDp1atJTmBmvZc+WpGk1tmD8mjIYSxrEYCxJWoVOBGNXjCUN4okUkqTV6EQwdsVYkiRJbXUiGGd+XF+uIUmSpMtFJ4IxMRhLkiSpnW4EY1eMJUmS1FJHgrHnGEuSJKmdTgTjzLliLEmSpHY6EYxdMZYkSVJbHQnGrhhLkiSpnW4EY0+lkCRJUkudCMblirEkSZJa6kQwdsVYkiRJbXUjGLtiLEmSpJa6EYyTSc9AkiRJM64Twbg8lUKSJEktdSIYM++KsSRJktppFYyTHAVeAZaAU1W1I8lG4BPAdcBR4F1V9XK7aV6aK8aSNJxp6duSNI3WYsX471XV9/tu7wUOVdX9SfY2tz+wBs+zPFeMJWk1Jt+3JWkKjeNUil3Arc32fuALjLnB1pzBWJJaeM37tiRNo7bBuIA/SlLA/19V+4Brq+o4QFUdT7Kp7SRXnIRf1yZpAP/JPNBU9G1JmkZtg/EtVXWsaaKPJfnWsAcm2QPsAbiCK9vNwhVjSRrWmvTt9ZuuHtf8JGliWgXjqjrWXJ9I8giwE3gpyeZm1WEzcGKZY/cB+wCuzsZqNQ+DsaQB7AwXW6u+fdUNm1v1bUmaRiMH4yRXAXNV9Uqz/YvAvwMOAncB9zfXj67FRC+l/PCdJK1omvq2JE2jNivG1wKPpPerc+uAh6rqvyf5KnAgyd3Ad4F3tp/mpbliLElDmZq+LUnTaORgXFXfAX52wPj/Am5rM6lVMxdL0oqmqm9L0hTqxC/feSqFJEmS2upGMPZUCkmSJLXUkWA86RlIkiRp1nUkGLtiLEmSpHa6EYznJz0DSZIkzbpuBGNXjCVJktRSR4LxpGcgSZKkWWcwliRJkuhMMPZUCkmSJLXTiWDsL99JkiSprU4EY0+lkCRJUlsGY0mSJInOBGPPpZAkSVI7HQnGk56BJEmSZp3BWJIkScJgLEmSJAEGY0mSJAkwGEuSJEnAEME4yYPALwEnqurNzdhG4BPAdcBR4F1V9XJz373A3cAS8N6q+txYZt7Hb6WQpHNmoW9L0jQaZq31o8AdF4ztBQ5V1XbgUHObJDcCu4GbmmM+nGR+zWa7nHjx4sXLgMvl66NMe9+WpCm04opxVX0xyXUXDO8Cbm229wNfAD7QjD9cVSeBF5IcAXYCX16j+Q6eo6dSSNJZs9C3JWkajXqO8bVVdRygqo4n2dSMbwG+0rffYjN2kSR7gD0AV3DliNPoMRhL0orWtG+v33T1GKcqSZOx1h++G/TmZQ3asar2AfsArs7GgfsMzWAsSaMaqW9fdcPmdn1bkqbQqMH4pSSbm1WHzcCJZnwR2Na331bgWJsJDsMVY0la0VT1bUmaRqMG44PAXcD9zfWjfeMPJXkAeBOwHXii7SRXYjCWpBVNVd+WpGk0zNe1fZzeBzbemGQR+BC9xnogyd3Ad4F3AlTV4SQHgGeBU8A9VbU0prmfZTCWpHNmoW9L0jQa5lsp3r3MXbcts/99wH1tJrVaBmNJOmcW+rYkTaNO/PLdZf59pZIkSVoDnQjGrhhLkiSprU4EY1eMJUmS1FYngrErxpIkSWrLYCxJkiTRmWDsDzBJkiSpnU4EY38SWpIkSW11Ihh7KoUkSZLa6kYw9lspJEmS1FIngrGnUkiSJKmtTgRjP3wnSZKktjoSjCc9A0mSJM26TgRjf/lOkiRJbXUiGLtiLEmSpLY6EYzxHGNJkiS11JFgPOkJSJIkadZ1Ihj7rRSSJElqa8W11iQPJjmR5Jm+sd9I8hdJnm4ud/bdd2+SI0meT3L7uCZ+/iS9ePHiZcDlMjUTfVuSptAwK8YfBf5f4A8vGP/dqvrt/oEkNwK7gZuANwGfT3JDVS2twVyX54qxJPX7KNPetyVpCq0YjKvqi0muG/LxdgEPV9VJ4IUkR4CdwJdHn+IQDMaSdNZM9G1JmkJtzjF+T5J/BjwJvL+qXga2AF/p22exGbtIkj3AHoAruLLFNPDDd5I0nDXr2+s3XT3mqUrSa2/UYPz7wL8Hqrn+HeBfMPisvoHLuVW1D9gHcHU2tlryjSvGkrSSNe3bV92w2cYrqXNGCsZV9dKZ7SR/AHymubkIbOvbdStwbOTZDctgLEmXNHV9W5Km0EjBOMnmqjre3Pxl4Mwnnw8CDyV5gN6HOLYDT7Se5YrzMRhL0qVMW9+WpGm0YjBO8nHgVuCNSRaBDwG3JrmZ3tttR4FfBaiqw0kOAM8Cp4B7XotPNsdzjCXprFno25I0jYb5Vop3Dxj+yCX2vw+4r82kVssVY0k6Zxb6tiRNo0788l3mTk96CpIkSZpxnQjGc374TpIkSS0ZjCVJkiQMxpIkSRLQmWDsOcaSJElqpxPBeN5vpZAkSVJLnQjGrhhLkiSprW4E40x6BpIkSZp1nQjG864YS5IkqSWDsSRJkkRXgrEfvpMkSVJL3QjGrhhLkiSppU4E43UGY0mSJLXUiWA8H4OxpIt5kpUkaTU6EYxdMZY0yKuTnoAkaaZ0Ixi7YixpAIOxJGk1uhGM55YmPQVJkiTNuBWDcZJtwB8Cfw04Deyrqv+YZCPwCeA64Cjwrqp6uTnmXuBuYAl4b1V9biyzb8z5dW2SBMxGz5akaTXMivEp4P1V9bUkrweeSvIY8M+BQ1V1f5K9wF7gA0luBHYDNwFvAj6f5IaqGtuyrqdSSNJZU9+zJWlarRiMq+o4cLzZfiXJc8AWYBdwa7PbfuALwAea8Yer6iTwQpIjwE7gy2s9+TM8lUKSemahZ0vStFrVOcZJrgPeAjwOXNs0YKrqeJJNzW5bgK/0HbbYjF34WHuAPQBXcOWqJ95vwRVjSbrIWvbs5vHO9u31m64e06wlaXKGDsZJXgd8CnhfVf0oybK7Dhi76CTgqtoH7AO4OhtbnSTsirEknW+tezac37evumGzH+6Q1DlDBeMkC/Qa7Meq6tPN8EtJNjcrD5uBE834IrCt7/CtwLG1mvAgrhhL0jnT3rMlaVoN860UAT4CPFdVD/TddRC4C7i/uX60b/yhJA/Q+yDHduCJtZz0hVwxlqSeWejZkjSthlkxvgX4FeCbSZ5uxj5Ir7keSHI38F3gnQBVdTjJAeBZep+Ovmfcn25eiMFYkhpT37MlaVoN860UX2LwOWgAty1zzH3AfS3mtSoGY0mDzU16Aq+5WejZkjStOvHLdwueSiFpoMsvGEuSRteJYDw3+APUkiRJ0tA6EYw9lUKSJEltdSMYz52a9BQkSZI047oRjF0xliRJUksGY0mSJAmDsSRJkgR0JBivj+cYS5IkqZ1OBGNXjCVJktRWR4KxK8aSJElqpxPBeL0rxpIkSWqpE8F4jtOTnoIkSZJmXCeCsSvGkiRJaqsTwdhzjCVJktRWR4KxK8aSJElqpxPBeD0GY0mSJLXTiWDsirEkSZLaWjEYJ9kG/CHw14DTwL6q+o9JfgP4l8D3ml0/WFWfbY65F7gbWALeW1WfG8Pcz1qI30ohSTAbPVuSptUwK8angPdX1deSvB54KsljzX2/W1W/3b9zkhuB3cBNwJuAzye5oarGtqy74Ne1SdIZU9+zJWlarRiMq+o4cLzZfiXJc8CWSxyyC3i4qk4CLyQ5AuwEvrwG8x1ovSvGkgTMRs+WpGm1qnOMk1wHvAV4HLgFeE+SfwY8SW+F4mV6DfgrfYctcumm3NpCxvnokjSbprVnS9K0GjoYJ3kd8CngfVX1oyS/D/x7oJrr3wH+BTAoptaAx9sD7AG4gitXP/M+c62OlqTuWeue3Tzm2b69ftPV45i2JE3UUME4yQK9Bvuxqvo0QFW91Hf/HwCfaW4uAtv6Dt8KHLvwMatqH7AP4OpsHNiEh7U+LhlL0hnj6NnNY5zt21fdsLlV35akaTTMt1IE+AjwXFU90De+uTmXDeCXgWea7YPAQ0keoPdBju3AE2s66wssDFzwkKTLzyz0bEmaVsOsGN8C/ArwzSRPN2MfBN6d5GZ6b7kdBX4VoKoOJzkAPEvv09H3jPvTzQvxZApJakx9z5akaTXMt1J8icHnoH32EsfcB9zXYl6rspD51+qpJGmqzULPlqRp1YlfvluHwViSJEntdCIY37nlrZOegiRJkmZcJ4Ixc64YSxrgtKfKSpKG14lgnHmDsaSLlcFYkrQKHQnGfiuFpIvVq5OegSRplnQiGOOKsSRJklrqRjCec8VYkiRJ7XQiGHsqhSRJktrqRDD2VApJkiS11Y1g7Ne1SZIkqaVOBGNPpZAkSVJbnQjGnkohSZKktroRjP1WCkmSJLXUjWDsqRSSJElqqRvB2BVjSZIktdSJYFyuGEuSJKmlTgRjkknPQJIkSTNuxWCc5Argi8CGZv9PVtWHkmwEPgFcBxwF3lVVLzfH3AvcDSwB762qz41l9me4YixJwIz0bEmaUsOsGJ8Efr6qfpxkAfhSkv8G/GPgUFXdn2QvsBf4QJIbgd3ATcCbgM8nuaGqlsZUg+cYS9I509+zJWlKrRiMq6qAHzc3F5pLAbuAW5vx/cAXgA804w9X1UnghSRHgJ3Al9dy4ufNcd5TKSQJZqNnS9K0Guoc4yTzwFPA3wT+v6p6PMm1VXUcoKqOJ9nU7L4F+Erf4YvN2Pi4YixJZ019z5akKTVUMG7eUrs5yU8DjyR58yV2H7R8WxftlOwB9gBcwZXDTGP5+bliLElnjaNnw/l9e/2mq9tOU5Kmzqq+laKqfpjkC8AdwEtJNjcrD5uBE81ui8C2vsO2AscGPNY+YB/A1dk4sAkPzRVjSbrIWvbs5vHO9u2rbtjcrm9L0hQa5lsprgFebRrsTwG/APwWcBC4C7i/uX60OeQg8FCSB+h9kGM78MQY5n6WK8aS1DMLPVuSptUwK8abgf3NOWtzwIGq+kySLwMHktwNfBd4J0BVHU5yAHgWOAXcM/ZPN3/lG2N9eEmaIa9Jz57/9kn+yp1HRp7k7dw88rGSuuuvMHpfGdZ8nVz2vvQ+wDxZV2djvS23TXoakjSSz9cnn6qqHZOex2vJvi1pVj1eh/hR/WDg6QZTEYyTfA/4S+D7k57LGnoj3aoHuleT9Uy/WanpZ6rqmklP4rWU5BXg+UnPYw3NymttNbpWU9fqge7VNCv1LNuzpyIYAyR5sksrLl2rB7pXk/VMvy7W1BVd+9t0rR7oXk1dqwe6V1MX6vHrHCRJkiQMxpIkSRIwXcF436QnsMa6Vg90rybrmX5drKkruva36Vo90L2aulYPdK+mma9nas4xliRJkiZpmlaMJUmSpImZeDBOckeS55McSbJ30vMZVpIHk5xI8kzf2MYkjyX5dnP9hr777m1qfD7J7ZOZ9fKSbEvyx0meS3I4ya814zNZU5IrkjyR5OtNPb/ZjM9kPWckmU/yJ0k+09ye9XqOJvlmkqeTPNmMzXRNXWfPng727Omup1+X+vZl0bOramIXYB74M+CvA+uBrwM3TnJOq5j73wXeCjzTN/YfgL3N9l7gt5rtG5vaNgDXNzXPT7qGC+rZDLy12X498KfNvGeyJiDA65rtBeBx4O2zWk9fXf8aeAj4zKy/5pp5HgXeeMHYTNfU5Ys9e/J19M3dnj3F9VxQW2f69uXQsye9YrwTOFJV36mqnwAPA7smPKehVNUXgR9cMLwL2N9s7wfe0Tf+cFWdrKoXgCP0ap8aVXW8qr7WbL8CPAdsYUZrqp4fNzcXmksxo/UAJNkK/EPgv/QNz2w9l9DFmrrCnj0l7NnTXc8Zl0nf7lQ9kw7GW4AX+24vNmOz6tqqOg69pgVsasZnqs4k1wFvofcv9pmtqXn76mngBPBYVc10PcDvAf8GON03Nsv1QO9/fH+U5Kkke5qxWa+py7r2N+jEa82eDUxhPY3fo1t9u/M9e92En3/Q71R38WsyZqbOJK8DPgW8r6p+lAz8KXGYgZqqagm4OclPA48kefMldp/qepL8EnCiqp5KcuswhwwYm5p6+txSVceSbAIeS/KtS+w7KzV12eXyN5iZOu3Z5z/EWCY2oo727c737EmvGC8C2/pubwWOTWgua+GlJJsBmusTzfhM1JlkgV6D/VhVfboZnumaAKrqh8AXgDuY3XpuAf5RkqP03r7++ST/ldmtB4CqOtZcnwAeofc220zX1HFd+xvM9GvNnj319XSub18OPXvSwfirwPYk1ydZD+wGDk54Tm0cBO5qtu8CHu0b351kQ5Lrge3AExOY37LSW2b4CPBcVT3Qd9dM1pTkmmbVgSQ/BfwC8C1mtJ6qureqtlbVdfT+O/kfVfVPmdF6AJJcleT1Z7aBXwSeYYZrugzYs6eEPXu664Hu9e3LpmdP+tN/wJ30Pk37Z8CvT3o+q5j3x4HjwKv0/lV0N/BXgUPAt5vrjX37/3pT4/PAP5j0/AfU83P03uL4BvB0c7lzVmsC/jbwJ009zwD/thmfyXouqO1Wzn26eWbroffNBl9vLofP/Pc/yzVdDhd79nRc7NnTXc+A+ma+b18uPdtfvpMkSZKY/KkUkiRJ0lQwGEuSJEkYjCVJkiTAYCxJkiQBBmNJkiQJMBhLkiRJgMFYkiRJAgzGkiRJEgD/FzHzpbwn4DcvAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 864x648 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(2, 2, figsize=(12, 9))\n",
+    "foo = add_blanking(coord_pixbuf(500, 300))\n",
+    "axs[0,0].imshow(foo[:,:,0], interpolation='None')\n",
+    "axs[0,1].imshow(foo[:,:,1], interpolation='None')\n",
+    "axs[1,0].imshow(foo[:,:,2], interpolation='None')\n",
+    "axs[1,1].imshow(foo[:,:,3], interpolation='None')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "covered-request",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f04a982dfa0>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x864 with 6 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(3, 2, figsize=(12, 12))\n",
+    "foo = add_blanking(add_window(zero_pixbuf(500, 300), 50, 100, 100,  50))\n",
+    "axs[0,0].imshow(foo[:,:,0], interpolation='None')\n",
+    "axs[0,1].imshow(foo[:,:,1], interpolation='None')\n",
+    "axs[1,0].imshow(foo[:,:,2], interpolation='None')\n",
+    "axs[1,1].axis('off')\n",
+    "axs[2,0].imshow(foo[:,:,3] & 0x3, interpolation='None')\n",
+    "axs[2,1].imshow(foo[:,:,3] & 0xC, interpolation='None')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "bulgarian-insertion",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f04a859c6d0>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x864 with 6 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(3, 2, figsize=(12, 12))\n",
+    "foo = add_blanking(add_window(zero_pixbuf(500, 300), -40, -20, 100,  50))\n",
+    "axs[0,0].imshow(foo[:,:,0], interpolation='None')\n",
+    "axs[0,1].imshow(foo[:,:,1], interpolation='None')\n",
+    "axs[1,0].imshow(foo[:,:,2], interpolation='None')\n",
+    "axs[1,1].axis('off')\n",
+    "axs[2,0].imshow(foo[:,:,3] & 0x3, interpolation='None')\n",
+    "axs[2,1].imshow(foo[:,:,3] & 0xC, interpolation='None')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "descending-nature",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f04a8342fd0>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x864 with 6 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(3, 2, figsize=(12, 12))\n",
+    "foo = add_blanking(add_window(zero_pixbuf(500, 300), 420, 290, 100,  50))\n",
+    "axs[0,0].imshow(foo[:,:,0], interpolation='None')\n",
+    "axs[0,1].imshow(foo[:,:,1], interpolation='None')\n",
+    "axs[1,0].imshow(foo[:,:,2], interpolation='None')\n",
+    "axs[1,1].axis('off')\n",
+    "axs[2,0].imshow(foo[:,:,3] & 0x3, interpolation='None')\n",
+    "axs[2,1].imshow(foo[:,:,3] & 0xC, interpolation='None')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/window_matcher_tb_behav.wcfg b/window_matcher_tb_behav.wcfg
new file mode 100644
index 0000000..1b95184
--- /dev/null
+++ b/window_matcher_tb_behav.wcfg
@@ -0,0 +1,269 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<wave_config>
+   <wave_state>
+   </wave_state>
+   <db_ref_list>
+      <db_ref path="window_matcher_tb_behav.wdb" id="1">
+         <top_modules>
+            <top_module name="glbl" />
+            <top_module name="window_matcher_tb" />
+         </top_modules>
+      </db_ref>
+   </db_ref_list>
+   <zoom_setting>
+      <ZoomStartTime time="303526166fs"></ZoomStartTime>
+      <ZoomEndTime time="303705967fs"></ZoomEndTime>
+      <Cursor1Time time="303676000fs"></Cursor1Time>
+   </zoom_setting>
+   <column_width_setting>
+      <NameColumnWidth column_width="175"></NameColumnWidth>
+      <ValueColumnWidth column_width="174"></ValueColumnWidth>
+   </column_width_setting>
+   <WVObjectSize size="60" />
+   <wvobject fp_name="/window_matcher_tb/clk" type="logic">
+      <obj_property name="ElementShortName">clk</obj_property>
+      <obj_property name="ObjectShortName">clk</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/rst" type="logic">
+      <obj_property name="ElementShortName">rst</obj_property>
+      <obj_property name="ObjectShortName">rst</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/in_blank" type="logic">
+      <obj_property name="ElementShortName">in_blank</obj_property>
+      <obj_property name="ObjectShortName">in_blank</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/in_hsync" type="logic">
+      <obj_property name="ElementShortName">in_hsync</obj_property>
+      <obj_property name="ObjectShortName">in_hsync</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/in_vsync" type="logic">
+      <obj_property name="ElementShortName">in_vsync</obj_property>
+      <obj_property name="ObjectShortName">in_vsync</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/in_red" type="array">
+      <obj_property name="ElementShortName">in_red[7:0]</obj_property>
+      <obj_property name="ObjectShortName">in_red[7:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/in_green" type="array">
+      <obj_property name="ElementShortName">in_green[7:0]</obj_property>
+      <obj_property name="ObjectShortName">in_green[7:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/in_blue" type="array">
+      <obj_property name="ElementShortName">in_blue[7:0]</obj_property>
+      <obj_property name="ObjectShortName">in_blue[7:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/win_hsync" type="logic">
+      <obj_property name="ElementShortName">win_hsync</obj_property>
+      <obj_property name="ObjectShortName">win_hsync</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/win_vsync" type="logic">
+      <obj_property name="ElementShortName">win_vsync</obj_property>
+      <obj_property name="ObjectShortName">win_vsync</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/win_blank" type="logic">
+      <obj_property name="ElementShortName">win_blank</obj_property>
+      <obj_property name="ObjectShortName">win_blank</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/out_data_en" type="logic">
+      <obj_property name="ElementShortName">out_data_en</obj_property>
+      <obj_property name="ObjectShortName">out_data_en</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/out_data_valid" type="logic">
+      <obj_property name="ElementShortName">out_data_valid</obj_property>
+      <obj_property name="ObjectShortName">out_data_valid</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/out_data" type="array">
+      <obj_property name="ElementShortName">out_data[23:0]</obj_property>
+      <obj_property name="ObjectShortName">out_data[23:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/pattern_w" type="array">
+      <obj_property name="ElementShortName">pattern_w[11:0]</obj_property>
+      <obj_property name="ObjectShortName">pattern_w[11:0]</obj_property>
+      <obj_property name="Radix">UNSIGNEDDECRADIX</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/pattern_h" type="array">
+      <obj_property name="ElementShortName">pattern_h[11:0]</obj_property>
+      <obj_property name="ObjectShortName">pattern_h[11:0]</obj_property>
+      <obj_property name="Radix">UNSIGNEDDECRADIX</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/read_pos" type="array">
+      <obj_property name="ElementShortName">read_pos[31:0]</obj_property>
+      <obj_property name="ObjectShortName">read_pos[31:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/period" type="array">
+      <obj_property name="ElementShortName">period[31:0]</obj_property>
+      <obj_property name="ObjectShortName">period[31:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/clk" type="logic">
+      <obj_property name="ElementShortName">clk</obj_property>
+      <obj_property name="ObjectShortName">clk</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/rst" type="logic">
+      <obj_property name="ElementShortName">rst</obj_property>
+      <obj_property name="ObjectShortName">rst</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/in_blank" type="logic">
+      <obj_property name="ElementShortName">in_blank</obj_property>
+      <obj_property name="ObjectShortName">in_blank</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/in_hsync" type="logic">
+      <obj_property name="ElementShortName">in_hsync</obj_property>
+      <obj_property name="ObjectShortName">in_hsync</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/in_vsync" type="logic">
+      <obj_property name="ElementShortName">in_vsync</obj_property>
+      <obj_property name="ObjectShortName">in_vsync</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/in_red" type="array">
+      <obj_property name="ElementShortName">in_red[7:0]</obj_property>
+      <obj_property name="ObjectShortName">in_red[7:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/in_green" type="array">
+      <obj_property name="ElementShortName">in_green[7:0]</obj_property>
+      <obj_property name="ObjectShortName">in_green[7:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/in_blue" type="array">
+      <obj_property name="ElementShortName">in_blue[7:0]</obj_property>
+      <obj_property name="ObjectShortName">in_blue[7:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/win_hsync" type="logic">
+      <obj_property name="ElementShortName">win_hsync</obj_property>
+      <obj_property name="ObjectShortName">win_hsync</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/win_vsync" type="logic">
+      <obj_property name="ElementShortName">win_vsync</obj_property>
+      <obj_property name="ObjectShortName">win_vsync</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/win_blank" type="logic">
+      <obj_property name="ElementShortName">win_blank</obj_property>
+      <obj_property name="ObjectShortName">win_blank</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/out_data_en" type="logic">
+      <obj_property name="ElementShortName">out_data_en</obj_property>
+      <obj_property name="ObjectShortName">out_data_en</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/out_data_valid" type="logic">
+      <obj_property name="ElementShortName">out_data_valid</obj_property>
+      <obj_property name="ObjectShortName">out_data_valid</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/out_data" type="array">
+      <obj_property name="ElementShortName">out_data[23:0]</obj_property>
+      <obj_property name="ObjectShortName">out_data[23:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/expected_data" type="array">
+      <obj_property name="ElementShortName">expected_data[31:0]</obj_property>
+      <obj_property name="ObjectShortName">expected_data[31:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/pattern_w" type="array">
+      <obj_property name="ElementShortName">pattern_w[11:0]</obj_property>
+      <obj_property name="ObjectShortName">pattern_w[11:0]</obj_property>
+      <obj_property name="Radix">UNSIGNEDDECRADIX</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/pattern_h" type="array">
+      <obj_property name="ElementShortName">pattern_h[11:0]</obj_property>
+      <obj_property name="ObjectShortName">pattern_h[11:0]</obj_property>
+      <obj_property name="Radix">UNSIGNEDDECRADIX</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/cur_x" type="array">
+      <obj_property name="ElementShortName">cur_x[11:0]</obj_property>
+      <obj_property name="ObjectShortName">cur_x[11:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/cur_y" type="array">
+      <obj_property name="ElementShortName">cur_y[11:0]</obj_property>
+      <obj_property name="ObjectShortName">cur_y[11:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/cur_x_sr" type="array">
+      <obj_property name="ElementShortName">cur_x_sr[2:0][11:0]</obj_property>
+      <obj_property name="ObjectShortName">cur_x_sr[2:0][11:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/marker_x" type="array">
+      <obj_property name="ElementShortName">marker_x[11:0]</obj_property>
+      <obj_property name="ObjectShortName">marker_x[11:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/marker_y" type="array">
+      <obj_property name="ElementShortName">marker_y[11:0]</obj_property>
+      <obj_property name="ObjectShortName">marker_y[11:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/rx_x" type="array">
+      <obj_property name="ElementShortName">rx_x[11:0]</obj_property>
+      <obj_property name="ObjectShortName">rx_x[11:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/rx_y" type="array">
+      <obj_property name="ElementShortName">rx_y[11:0]</obj_property>
+      <obj_property name="ObjectShortName">rx_y[11:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/in_pxd" type="array">
+      <obj_property name="ElementShortName">in_pxd[23:0]</obj_property>
+      <obj_property name="ObjectShortName">in_pxd[23:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/in_pxd_match_sr" type="array">
+      <obj_property name="ElementShortName">in_pxd_match_sr[11:0]</obj_property>
+      <obj_property name="ObjectShortName">in_pxd_match_sr[11:0]</obj_property>
+      <obj_property name="isExpanded"></obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/in_pxd_match" type="array">
+      <obj_property name="ElementShortName">in_pxd_match[3:0]</obj_property>
+      <obj_property name="ObjectShortName">in_pxd_match[3:0]</obj_property>
+      <obj_property name="isExpanded"></obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/last_hsync" type="logic">
+      <obj_property name="ElementShortName">last_hsync</obj_property>
+      <obj_property name="ObjectShortName">last_hsync</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/last_vsync" type="logic">
+      <obj_property name="ElementShortName">last_vsync</obj_property>
+      <obj_property name="ObjectShortName">last_vsync</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/in_pxd_pattern_match" type="logic">
+      <obj_property name="ElementShortName">in_pxd_pattern_match</obj_property>
+      <obj_property name="ObjectShortName">in_pxd_pattern_match</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/pattern_found" type="logic">
+      <obj_property name="ElementShortName">pattern_found</obj_property>
+      <obj_property name="ObjectShortName">pattern_found</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/pattern_locked" type="logic">
+      <obj_property name="ElementShortName">pattern_locked</obj_property>
+      <obj_property name="ObjectShortName">pattern_locked</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/pattern_rx" type="logic">
+      <obj_property name="ElementShortName">pattern_rx</obj_property>
+      <obj_property name="ObjectShortName">pattern_rx</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/pattern_meta_rx" type="logic">
+      <obj_property name="ElementShortName">pattern_meta_rx</obj_property>
+      <obj_property name="ObjectShortName">pattern_meta_rx</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/pattern_data_rx" type="logic">
+      <obj_property name="ElementShortName">pattern_data_rx</obj_property>
+      <obj_property name="ObjectShortName">pattern_data_rx</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/end_x" type="array">
+      <obj_property name="ElementShortName">end_x[11:0]</obj_property>
+      <obj_property name="ObjectShortName">end_x[11:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/end_y" type="array">
+      <obj_property name="ElementShortName">end_y[11:0]</obj_property>
+      <obj_property name="ObjectShortName">end_y[11:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/pattern_meta" type="array">
+      <obj_property name="ElementShortName">pattern_meta[3:0][23:0]</obj_property>
+      <obj_property name="ObjectShortName">pattern_meta[3:0][23:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/PATTERN_0" type="array">
+      <obj_property name="ElementShortName">PATTERN_0[23:0]</obj_property>
+      <obj_property name="ObjectShortName">PATTERN_0[23:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/PATTERN_1" type="array">
+      <obj_property name="ElementShortName">PATTERN_1[23:0]</obj_property>
+      <obj_property name="ObjectShortName">PATTERN_1[23:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/PATTERN_2" type="array">
+      <obj_property name="ElementShortName">PATTERN_2[23:0]</obj_property>
+      <obj_property name="ObjectShortName">PATTERN_2[23:0]</obj_property>
+   </wvobject>
+   <wvobject fp_name="/window_matcher_tb/window_matcher_i/PATTERN_3" type="array">
+      <obj_property name="ElementShortName">PATTERN_3[23:0]</obj_property>
+      <obj_property name="ObjectShortName">PATTERN_3[23:0]</obj_property>
+   </wvobject>
+</wave_config>